VC以太网 FINS 协议

今天做在做欧姆龙   以太网 FINS  协议   

有的朋友  分享下   

我这边给个word类操作  类 给大家

// SimpleWordAuto.h: interface for the SimpleWordAuto class.
//
//


#if !defined(AFX_SIMPLEWORDAUTO_H__7F5096E5_F09B_4DA1_9FC2_28FA2D2C1573__INCLUDED_)
#define AFX_SIMPLEWORDAUTO_H__7F5096E5_F09B_4DA1_9FC2_28FA2D2C1573__INCLUDED_


#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000




enum wdAlignParagraphAlignment {
wdAlignParagraphCenter=1,
wdAlignParagraphJustify=3,
wdAlignParagraphRight=2
}; 


#include "msword.h"
#include  <atlbase.h>
#include "comdef.h"
#include <afxdisp.h> //COlVirant 




class SimpleWordAuto  
{
private:
_Application wordapp;
COleVariant vTrue,vFalse,vOptional;
Documents worddocs;
CComVariant tpl,Visble,DocType,NewTemplate;
Selection wordsel;
_Document worddoc;
Tables wordtables;
Table wordtable;
_ParagraphFormat paragraphformat;
Cell cell;
_Font wordFt;
Range range;
CComVariant SaveChanges,OriginalFormat,RouteDocument;
CComVariant ComVariantTrue,ComVariantFalse;
InlineShapes ishaps;
InlineShape ishap;



public:
void AddPicture(LPCTSTR picname); //写入图片
void CreateChart();  //创建图表
BOOL MergeCell(int  cell1row,int cell1col,int  cell2row,int cell2col); //合并单元格
void CloseWordSave(LPCTSTR wordname);   //保存文档
void CloseWord(); //关闭文档
void SetTableFont(int nRow, int nColumn, BOOL bBold, BOOL bItalic = FALSE, BOOL bUnderLine = FALSE);
void SetTableFont(int nRow, int nColumn, LPCTSTR szFontName = "宋体", float fSize=9, long lFontColor=0, long lBackColor = 0);
void SetFont(BOOL bBold, BOOL bItalic = FALSE, BOOL bUnderLine = FALSE );
void SetFont(LPCTSTR szFontName ,float fSize = 9, long lFontColor = 0, long lBackColor=0);
void AddParagraph();            // 增加一个分段回车
void WriteText(LPCTSTR szText); // 输出文字
BOOL CreateWord();              //创建word
void ShowWord(BOOL show);       //显示word
void WriteCell(int nRow, int nColumne, LPCTSTR szText);
BOOL CreateTable(int nRow, int nColumn);  // 创建表格
void SetParagraphFormat(int nAlignment);  // 对齐方式
BOOL CreateDocumtent();
BOOL CreateApp();
SimpleWordAuto();
virtual ~SimpleWordAuto();


};


#endif // !defined(AFX_SIMPLEWORDAUTO_H__7F5096E5_F09B_4DA1_9FC2_28FA2D2C1573__INCLUDED_)

// SimpleWordAuto.cpp: implementation of the SimpleWordAuto class.
//
//


#include "stdafx.h"
#include "wordauto2.h"
#include "SimpleWordAuto.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


//
// Construction/Destruction
//


SimpleWordAuto::SimpleWordAuto()
{
OleInitialize(NULL);    
//CoInitialize(NULL);
ComVariantTrue=CComVariant(true);
ComVariantFalse=CComVariant(false);
vTrue=COleVariant((short)TRUE);
vFalse=COleVariant ((short)FALSE);
tpl=CComVariant(_T(""));
DocType=CComVariant(0);
NewTemplate=CComVariant(false);
vOptional=COleVariant((long)DISP_E_PARAMNOTFOUND,VT_ERROR);


}


SimpleWordAuto::~SimpleWordAuto()
{


wordtable.ReleaseDispatch();
wordtables.ReleaseDispatch();
wordsel.ReleaseDispatch();
worddocs.ReleaseDispatch();
worddoc.ReleaseDispatch();
paragraphformat.ReleaseDispatch();
wordapp.ReleaseDispatch();
wordFt.ReleaseDispatch();
cell.ReleaseDispatch();
range.ReleaseDispatch();
ishaps.ReleaseDispatch();
ishap.ReleaseDispatch();
CoUninitialize();
}


BOOL SimpleWordAuto::CreateApp()
{
if (FALSE == wordapp.CreateDispatch("Word.Application"))
{
MessageBox(NULL,"Application创建失败!","", MB_OK|MB_ICONWARNING);
return FALSE;
}
//    m_wdApp.SetVisible(TRUE);
return TRUE;


}


BOOL SimpleWordAuto::CreateDocumtent()
{
if (!wordapp.m_lpDispatch) 
   {
       MessageBox(NULL,"Application为空,Documents创建失败!", "错误提示",MB_OK|MB_ICONWARNING);
       return FALSE;
   }
   worddocs.AttachDispatch(wordapp.GetDocuments());
   if (!worddocs.m_lpDispatch) 
   {
       MessageBox(NULL,"Documents创建失败!", "错误提示",MB_OK|MB_ICONWARNING);
       return FALSE;
   }
   CComVariant Template(_T(""));    
   CComVariant NewTemplate(false),DocumentType(0),Visible;
   worddocs.Add(&Template,&NewTemplate,&DocumentType,&Visible);    


   worddocs = wordapp.GetActiveDocument();
   if (!worddocs.m_lpDispatch) 
   {
       MessageBox(NULL,"Document获取失败!", "",MB_OK|MB_ICONWARNING);
       return FALSE;
   }
   wordsel = wordapp.GetSelection();
   if (!wordsel.m_lpDispatch) 
   {
       MessageBox(NULL,"Select获取失败!", "",MB_OK|MB_ICONWARNING);
       return FALSE;
   }    
   return TRUE;


}


void SimpleWordAuto::SetParagraphFormat(int nAlignment)
{
if (!wordsel.m_lpDispatch)
{
return ;
}
paragraphformat = wordsel.GetParagraphFormat();
paragraphformat.SetAlignment(nAlignment);
wordsel.SetParagraphFormat(paragraphformat);
}


BOOL SimpleWordAuto::CreateTable(int nRow, int nColumn)
{
if (!wordapp.m_lpDispatch)
{
return FALSE;
}


worddoc = wordapp.GetActiveDocument();
wordtables = worddoc.GetTables();
VARIANT vtDefault, vtAuto;
vtDefault.vt = VT_I4;
vtAuto.vt = VT_I4;
vtDefault.intVal = 1;
vtAuto.intVal = 0;
wordtables.Add(wordsel.GetRange(), nRow, nColumn, &vtDefault, &vtAuto);    
wordtable = wordtables.Item(wordtables.GetCount());

VARIANT vtstyle;
vtstyle.vt = VT_BSTR;
_bstr_t bstr = "网格型";
vtstyle.bstrVal = bstr;
if (wordtable.GetStyle().bstrVal == vtstyle.bstrVal)
{
wordtable.SetStyle(&vtstyle);
wordtable.SetApplyStyleFirstColumn(TRUE);
wordtable.SetApplyStyleHeadingRows(TRUE);
wordtable.SetApplyStyleLastColumn(TRUE);
wordtable.SetApplyStyleLastRow(TRUE);        
}


return TRUE;


}


void SimpleWordAuto::WriteCell(int nRow, int nColumne, LPCTSTR szText)
{


if (wordtable!=NULL)
{
cell = wordtable.Cell(nRow,nColumne);
cell.Select();
wordsel.TypeText(szText);

}

}


void SimpleWordAuto::ShowWord(BOOL show)
{
if (!wordapp.m_lpDispatch) 
{
return ;
}
wordapp.SetVisible(show);


}


BOOL SimpleWordAuto::CreateWord()
{
if (FALSE == CreateApp()) 
{
return FALSE;
}
return CreateDocumtent();


}


void SimpleWordAuto::WriteText(LPCTSTR szText)
{
if (!wordsel.m_lpDispatch) 
{
return ;
}
wordsel.TypeText(szText);
wordtable=NULL;
}


void SimpleWordAuto::AddParagraph()
{
if (!wordsel.m_lpDispatch) 
{
return ;
}
wordsel.EndKey(COleVariant((short)6),COleVariant(short(0)));  //定位到全文末尾

wordsel.TypeParagraph();//新的段落，也就是回车换行


wordtable=NULL;
}


void SimpleWordAuto::SetFont(LPCTSTR szFontName, float fSize, long lFontColor, long lBackColor)
{
if (!wordsel.m_lpDispatch) 
{
MessageBox(NULL,"Select为空，字体设置失败!","错误提示", MB_OK|MB_ICONWARNING);
return;
}
wordsel.SetText("F");
wordFt = wordsel.GetFont();
wordFt.SetSize(fSize);
wordFt.SetName(szFontName);
wordFt.SetColor(lFontColor);
wordsel.SetFont(wordFt);
range = wordsel.GetRange();
range.SetHighlightColorIndex(lBackColor);


}


void SimpleWordAuto::SetFont(BOOL bBold, BOOL bItalic, BOOL bUnderLine)
{
if (!wordsel.m_lpDispatch) 
{
MessageBox(NULL,"Select为空，字体设置失败!", "错误提示",MB_OK|MB_ICONWARNING);
return;
}
wordsel.SetText("F");
wordFt = wordsel.GetFont();
wordFt.SetBold(bBold);
wordFt.SetItalic(bItalic);
wordFt.SetUnderline(bUnderLine);
wordsel.SetFont(wordFt);


}


void SimpleWordAuto::SetTableFont(int nRow, int nColumn, LPCTSTR szFontName, float fSize, long lFontColor, long lBackColor)
{
cell = wordtable.Cell(nRow, nColumn);
cell.Select();
wordFt = wordsel.GetFont();
wordFt.SetName(szFontName);
wordFt.SetSize(fSize);
wordFt.SetColor(lFontColor);
wordsel.SetFont(wordFt);
range = wordsel.GetRange();
range.SetHighlightColorIndex(lBackColor);
}


void SimpleWordAuto::SetTableFont(int nRow, int nColumn, BOOL bBold, BOOL bItalic, BOOL bUnderLine)
{
cell = wordtable.Cell(nRow, nColumn);
cell.Select();
wordFt = wordsel.GetFont();
wordFt.SetBold(bBold);
wordFt.SetItalic(bItalic);
wordFt.SetUnderline(bUnderLine);
wordsel.SetFont(wordFt);


}


void SimpleWordAuto::CloseWord()
{
if (!wordapp.m_lpDispatch)
{
return ;
}
SaveChanges=ComVariantFalse;
wordapp.Quit(&SaveChanges,&OriginalFormat,&RouteDocument);
}


void SimpleWordAuto::CloseWordSave(LPCTSTR wordname)
{
if (!wordapp.m_lpDispatch)
{
return ;
}
if (!worddoc.m_lpDispatch)
{
return ;
}
    worddoc.SaveAs(&CComVariant(wordname), 
&CComVariant((short)0),
vFalse, &CComVariant(""), vTrue, &CComVariant(""),
vFalse, vFalse, vFalse, vFalse, vFalse,
vFalse, vFalse, vFalse, vFalse, vFalse);
SaveChanges=ComVariantTrue;
    wordapp.Quit(&SaveChanges,&OriginalFormat,&RouteDocument);
}


BOOL SimpleWordAuto::MergeCell(int  cell1row,int cell1col,int  cell2row,int cell2col)
{
Cell cell1=wordtable.Cell(cell1row,cell1col);
Cell cell2=wordtable.Cell(cell2row,cell2col);
cell1.Merge(cell2);


return TRUE;
}


void SimpleWordAuto::CreateChart()
{
ishaps= wordsel.GetInlineShapes();
CComVariant classt;
classt=CComVariant("MSGraph.Chart.8");
ishap=ishaps.AddOLEObject(&classt,vOptional,vFalse,vFalse,vOptional,vOptional,vOptional,vOptional);


AddParagraph();
}


void SimpleWordAuto::AddPicture(LPCTSTR picname)
{

ishaps= wordsel.GetInlineShapes();
ishap=ishaps.AddPicture(picname,vFalse,vTrue,vOptional);   


AddParagraph();
}

// Machine generated IDispatch wrapper class(es) created with ClassWizard
/
// _Application wrapper class


class _Application : public COleDispatchDriver
{
public:
_Application() {} // Calls COleDispatchDriver default constructor
_Application(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_Application(const _Application& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
LPDISPATCH GetDocuments();
LPDISPATCH GetWindows();
LPDISPATCH GetActiveDocument();
LPDISPATCH GetActiveWindow();
LPDISPATCH GetSelection();
LPDISPATCH GetWordBasic();
LPDISPATCH GetRecentFiles();
LPDISPATCH GetNormalTemplate();
LPDISPATCH GetSystem();
LPDISPATCH GetAutoCorrect();
LPDISPATCH GetFontNames();
LPDISPATCH GetLandscapeFontNames();
LPDISPATCH GetPortraitFontNames();
LPDISPATCH GetLanguages();
LPDISPATCH GetAssistant();
LPDISPATCH GetBrowser();
LPDISPATCH GetFileConverters();
LPDISPATCH GetMailingLabel();
LPDISPATCH GetDialogs();
LPDISPATCH GetCaptionLabels();
LPDISPATCH GetAutoCaptions();
LPDISPATCH GetAddIns();
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
CString GetVersion();
BOOL GetScreenUpdating();
void SetScreenUpdating(BOOL bNewValue);
BOOL GetPrintPreview();
void SetPrintPreview(BOOL bNewValue);
LPDISPATCH GetTasks();
BOOL GetDisplayStatusBar();
void SetDisplayStatusBar(BOOL bNewValue);
BOOL GetSpecialMode();
long GetUsableWidth();
long GetUsableHeight();
BOOL GetMathCoprocessorAvailable();
BOOL GetMouseAvailable();
VARIANT GetInternational(long Index);
CString GetBuild();
BOOL GetCapsLock();
BOOL GetNumLock();
CString GetUserName_();
void SetUserName(LPCTSTR lpszNewValue);
CString GetUserInitials();
void SetUserInitials(LPCTSTR lpszNewValue);
CString GetUserAddress();
void SetUserAddress(LPCTSTR lpszNewValue);
LPDISPATCH GetMacroContainer();
BOOL GetDisplayRecentFiles();
void SetDisplayRecentFiles(BOOL bNewValue);
LPDISPATCH GetCommandBars();
LPDISPATCH GetSynonymInfo(LPCTSTR Word, VARIANT* LanguageID);
LPDISPATCH GetVbe();
CString GetDefaultSaveFormat();
void SetDefaultSaveFormat(LPCTSTR lpszNewValue);
LPDISPATCH GetListGalleries();
CString GetActivePrinter();
void SetActivePrinter(LPCTSTR lpszNewValue);
LPDISPATCH GetTemplates();
LPDISPATCH GetCustomizationContext();
void SetCustomizationContext(LPDISPATCH newValue);
LPDISPATCH GetKeyBindings();
LPDISPATCH GetKeysBoundTo(long KeyCategory, LPCTSTR Command, VARIANT* CommandParameter);
LPDISPATCH GetFindKey(long KeyCode, VARIANT* KeyCode2);
CString GetCaption();
void SetCaption(LPCTSTR lpszNewValue);
CString GetPath();
BOOL GetDisplayScrollBars();
void SetDisplayScrollBars(BOOL bNewValue);
CString GetStartupPath();
void SetStartupPath(LPCTSTR lpszNewValue);
long GetBackgroundSavingStatus();
long GetBackgroundPrintingStatus();
long GetLeft();
void SetLeft(long nNewValue);
long GetTop();
void SetTop(long nNewValue);
long GetWidth();
void SetWidth(long nNewValue);
long GetHeight();
void SetHeight(long nNewValue);
long GetWindowState();
void SetWindowState(long nNewValue);
BOOL GetDisplayAutoCompleteTips();
void SetDisplayAutoCompleteTips(BOOL bNewValue);
LPDISPATCH GetOptions();
long GetDisplayAlerts();
void SetDisplayAlerts(long nNewValue);
LPDISPATCH GetCustomDictionaries();
CString GetPathSeparator();
void SetStatusBar(LPCTSTR lpszNewValue);
BOOL GetMAPIAvailable();
BOOL GetDisplayScreenTips();
void SetDisplayScreenTips(BOOL bNewValue);
long GetEnableCancelKey();
void SetEnableCancelKey(long nNewValue);
BOOL GetUserControl();
LPDISPATCH GetFileSearch();
long GetMailSystem();
CString GetDefaultTableSeparator();
void SetDefaultTableSeparator(LPCTSTR lpszNewValue);
BOOL GetShowVisualBasicEditor();
void SetShowVisualBasicEditor(BOOL bNewValue);
CString GetBrowseExtraFileTypes();
void SetBrowseExtraFileTypes(LPCTSTR lpszNewValue);
BOOL GetIsObjectValid(LPDISPATCH Object);
LPDISPATCH GetHangulHanjaDictionaries();
LPDISPATCH GetMailMessage();
BOOL GetFocusInMailHeader();
void Quit(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument);
void ScreenRefresh();
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 Source, LPCTSTR Destination, LPCTSTR Name, long Object);
void OrganizerDelete(LPCTSTR Source, LPCTSTR Name, long Object);
void OrganizerRename(LPCTSTR Source, LPCTSTR Name, LPCTSTR NewName, long Object);
// method 'AddAddress' not emitted because of invalid return type or parameter type
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 Word, 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 Word, 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 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 SetDefaultTheme(LPCTSTR Name, long DocumentType);
CString GetDefaultTheme(long DocumentType);
LPDISPATCH GetEmailOptions();
long GetLanguage();
LPDISPATCH GetCOMAddIns();
BOOL GetCheckLanguage();
void SetCheckLanguage(BOOL bNewValue);
LPDISPATCH GetLanguageSettings();
LPDISPATCH GetAnswerWizard();
long GetFeatureInstall();
void SetFeatureInstall(long nNewValue);
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 GetAutomationSecurity();
void SetAutomationSecurity(long nNewValue);
LPDISPATCH GetFileDialog(long FileDialogType);
CString GetEmailTemplate();
void SetEmailTemplate(LPCTSTR lpszNewValue);
BOOL GetShowWindowsInTaskbar();
void SetShowWindowsInTaskbar(BOOL bNewValue);
LPDISPATCH GetNewDocument();
BOOL GetShowStartupDialog();
void SetShowStartupDialog(BOOL bNewValue);
LPDISPATCH GetAutoCorrectEmail();
LPDISPATCH GetTaskPanes();
BOOL GetDefaultLegalBlackline();
void SetDefaultLegalBlackline(BOOL bNewValue);
LPDISPATCH GetSmartTagRecognizers();
LPDISPATCH GetSmartTagTypes();
LPDISPATCH GetXMLNamespaces();
void PutFocusInMailHeader();
BOOL GetArbitraryXMLSupportAvailable();
};
/
// _Global wrapper class


class _Global : public COleDispatchDriver
{
public:
_Global() {} // Calls COleDispatchDriver default constructor
_Global(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_Global(const _Global& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
LPDISPATCH GetDocuments();
LPDISPATCH GetWindows();
LPDISPATCH GetActiveDocument();
LPDISPATCH GetActiveWindow();
LPDISPATCH GetSelection();
LPDISPATCH GetWordBasic();
BOOL GetPrintPreview();
void SetPrintPreview(BOOL bNewValue);
LPDISPATCH GetRecentFiles();
LPDISPATCH GetNormalTemplate();
LPDISPATCH GetSystem();
LPDISPATCH GetAutoCorrect();
LPDISPATCH GetFontNames();
LPDISPATCH GetLandscapeFontNames();
LPDISPATCH GetPortraitFontNames();
LPDISPATCH GetLanguages();
LPDISPATCH GetAssistant();
LPDISPATCH GetFileConverters();
LPDISPATCH GetDialogs();
LPDISPATCH GetCaptionLabels();
LPDISPATCH GetAutoCaptions();
LPDISPATCH GetAddIns();
LPDISPATCH GetTasks();
LPDISPATCH GetMacroContainer();
LPDISPATCH GetCommandBars();
LPDISPATCH GetSynonymInfo(LPCTSTR Word, VARIANT* LanguageID);
LPDISPATCH GetVbe();
LPDISPATCH GetListGalleries();
CString GetActivePrinter();
void SetActivePrinter(LPCTSTR lpszNewValue);
LPDISPATCH GetTemplates();
LPDISPATCH GetCustomizationContext();
void SetCustomizationContext(LPDISPATCH newValue);
LPDISPATCH GetKeyBindings();
LPDISPATCH GetKeysBoundTo(long KeyCategory, LPCTSTR Command, VARIANT* CommandParameter);
LPDISPATCH GetFindKey(long KeyCode, VARIANT* KeyCode2);
LPDISPATCH GetOptions();
LPDISPATCH GetCustomDictionaries();
void SetStatusBar(LPCTSTR lpszNewValue);
BOOL GetShowVisualBasicEditor();
void SetShowVisualBasicEditor(BOOL bNewValue);
BOOL GetIsObjectValid(LPDISPATCH Object);
LPDISPATCH GetHangulHanjaDictionaries();
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);
BOOL CheckSpelling(LPCTSTR Word, VARIANT* CustomDictionary, VARIANT* IgnoreUppercase, VARIANT* MainDictionary, VARIANT* CustomDictionary2, VARIANT* CustomDictionary3, VARIANT* CustomDictionary4, VARIANT* CustomDictionary5, 
VARIANT* CustomDictionary6, VARIANT* CustomDictionary7, VARIANT* CustomDictionary8, VARIANT* CustomDictionary9, VARIANT* CustomDictionary10);
LPDISPATCH GetSpellingSuggestions(LPCTSTR Word, 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 Help(VARIANT* HelpType);
LPDISPATCH NewWindow();
CString CleanString(LPCTSTR String);
void ChangeFileOpenDirectory(LPCTSTR Path);
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);
float PointsToPixels(float Points, VARIANT* fVertical);
float PixelsToPoints(float Pixels, VARIANT* fVertical);
LPDISPATCH GetLanguageSettings();
LPDISPATCH GetAnswerWizard();
LPDISPATCH GetAutoCorrectEmail();
};
/
// FontNames wrapper class


class FontNames : public COleDispatchDriver
{
public:
FontNames() {} // Calls COleDispatchDriver default constructor
FontNames(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FontNames(const FontNames& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString Item(long Index);
};
/
// Languages wrapper class


class Languages : public COleDispatchDriver
{
public:
Languages() {} // Calls COleDispatchDriver default constructor
Languages(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Languages(const Languages& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
};
/
// Language wrapper class


class Language : public COleDispatchDriver
{
public:
Language() {} // Calls COleDispatchDriver default constructor
Language(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Language(const Language& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetId();
CString GetNameLocal();
CString GetName();
LPDISPATCH GetActiveGrammarDictionary();
LPDISPATCH GetActiveHyphenationDictionary();
LPDISPATCH GetActiveSpellingDictionary();
LPDISPATCH GetActiveThesaurusDictionary();
CString GetDefaultWritingStyle();
void SetDefaultWritingStyle(LPCTSTR lpszNewValue);
VARIANT GetWritingStyleList();
long GetSpellingDictionaryType();
void SetSpellingDictionaryType(long nNewValue);
};
/
// Documents wrapper class


class Documents : public COleDispatchDriver
{
public:
Documents() {} // Calls COleDispatchDriver default constructor
Documents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Documents(const Documents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
void Close(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument);
void Save(VARIANT* NoPrompt, VARIANT* OriginalFormat);
LPDISPATCH Add(VARIANT* Template, VARIANT* NewTemplate, VARIANT* DocumentType, VARIANT* Visible);
void CheckOut(LPCTSTR FileName);
BOOL CanCheckOut(LPCTSTR FileName);
LPDISPATCH 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);
};
/
// _Document wrapper class


class _Document : public COleDispatchDriver
{
public:
_Document() {} // Calls COleDispatchDriver default constructor
_Document(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_Document(const _Document& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetBuiltInDocumentProperties();
LPDISPATCH GetCustomDocumentProperties();
CString GetPath();
LPDISPATCH GetBookmarks();
LPDISPATCH GetTables();
LPDISPATCH GetFootnotes();
LPDISPATCH GetEndnotes();
LPDISPATCH GetComments();
long GetType();
BOOL GetAutoHyphenation();
void SetAutoHyphenation(BOOL bNewValue);
BOOL GetHyphenateCaps();
void SetHyphenateCaps(BOOL bNewValue);
long GetHyphenationZone();
void SetHyphenationZone(long nNewValue);
long GetConsecutiveHyphensLimit();
void SetConsecutiveHyphensLimit(long nNewValue);
LPDISPATCH GetSections();
LPDISPATCH GetParagraphs();
LPDISPATCH GetWords();
LPDISPATCH GetSentences();
LPDISPATCH GetCharacters();
LPDISPATCH GetFields();
LPDISPATCH GetFormFields();
LPDISPATCH GetStyles();
LPDISPATCH GetFrames();
LPDISPATCH GetTablesOfFigures();
LPDISPATCH GetVariables();
LPDISPATCH GetMailMerge();
LPDISPATCH GetEnvelope();
CString GetFullName();
LPDISPATCH GetRevisions();
LPDISPATCH GetTablesOfContents();
LPDISPATCH GetTablesOfAuthorities();
LPDISPATCH GetPageSetup();
void SetPageSetup(LPDISPATCH newValue);
LPDISPATCH GetWindows();
BOOL GetHasRoutingSlip();
void SetHasRoutingSlip(BOOL bNewValue);
LPDISPATCH GetRoutingSlip();
BOOL GetRouted();
LPDISPATCH GetTablesOfAuthoritiesCategories();
LPDISPATCH GetIndexes();
BOOL GetSaved();
void SetSaved(BOOL bNewValue);
LPDISPATCH GetContent();
LPDISPATCH GetActiveWindow();
long GetKind();
void SetKind(long nNewValue);
BOOL GetReadOnly();
LPDISPATCH GetSubdocuments();
BOOL GetIsMasterDocument();
float GetDefaultTabStop();
void SetDefaultTabStop(float newValue);
BOOL GetEmbedTrueTypeFonts();
void SetEmbedTrueTypeFonts(BOOL bNewValue);
BOOL GetSaveFormsData();
void SetSaveFormsData(BOOL bNewValue);
BOOL GetReadOnlyRecommended();
void SetReadOnlyRecommended(BOOL bNewValue);
BOOL GetSaveSubsetFonts();
void SetSaveSubsetFonts(BOOL bNewValue);
BOOL GetCompatibility(long Type);
void SetCompatibility(long Type, BOOL bNewValue);
LPDISPATCH GetStoryRanges();
LPDISPATCH GetCommandBars();
BOOL GetIsSubdocument();
long GetSaveFormat();
long GetProtectionType();
LPDISPATCH GetHyperlinks();
LPDISPATCH GetShapes();
LPDISPATCH GetListTemplates();
LPDISPATCH GetLists();
BOOL GetUpdateStylesOnOpen();
void SetUpdateStylesOnOpen(BOOL bNewValue);
VARIANT GetAttachedTemplate();
void SetAttachedTemplate(VARIANT* newValue);
LPDISPATCH GetInlineShapes();
LPDISPATCH GetBackground();
void SetBackground(LPDISPATCH newValue);
BOOL GetGrammarChecked();
void SetGrammarChecked(BOOL bNewValue);
BOOL GetSpellingChecked();
void SetSpellingChecked(BOOL bNewValue);
BOOL GetShowGrammaticalErrors();
void SetShowGrammaticalErrors(BOOL bNewValue);
BOOL GetShowSpellingErrors();
void SetShowSpellingErrors(BOOL bNewValue);
LPDISPATCH GetVersions();
BOOL GetShowSummary();
void SetShowSummary(BOOL bNewValue);
long GetSummaryViewMode();
void SetSummaryViewMode(long nNewValue);
long GetSummaryLength();
void SetSummaryLength(long nNewValue);
BOOL GetPrintFractionalWidths();
void SetPrintFractionalWidths(BOOL bNewValue);
BOOL GetPrintPostScriptOverText();
void SetPrintPostScriptOverText(BOOL bNewValue);
LPDISPATCH GetContainer();
BOOL GetPrintFormsData();
void SetPrintFormsData(BOOL bNewValue);
LPDISPATCH GetListParagraphs();
void SetPassword(LPCTSTR lpszNewValue);
void SetWritePassword(LPCTSTR lpszNewValue);
BOOL GetHasPassword();
BOOL GetWriteReserved();
CString GetActiveWritingStyle(VARIANT* LanguageID);
void SetActiveWritingStyle(VARIANT* LanguageID, LPCTSTR lpszNewValue);
BOOL GetUserControl();
void SetUserControl(BOOL bNewValue);
BOOL GetHasMailer();
void SetHasMailer(BOOL bNewValue);
LPDISPATCH GetMailer();
LPDISPATCH GetReadabilityStatistics();
LPDISPATCH GetGrammaticalErrors();
LPDISPATCH GetSpellingErrors();
LPDISPATCH GetVBProject();
BOOL GetFormsDesign();
CString Get_CodeName();
void Set_CodeName(LPCTSTR lpszNewValue);
CString GetCodeName();
BOOL GetSnapToGrid();
void SetSnapToGrid(BOOL bNewValue);
BOOL GetSnapToShapes();
void SetSnapToShapes(BOOL bNewValue);
float GetGridDistanceHorizontal();
void SetGridDistanceHorizontal(float newValue);
float GetGridDistanceVertical();
void SetGridDistanceVertical(float newValue);
float GetGridOriginHorizontal();
void SetGridOriginHorizontal(float newValue);
float GetGridOriginVertical();
void SetGridOriginVertical(float newValue);
long GetGridSpaceBetweenHorizontalLines();
void SetGridSpaceBetweenHorizontalLines(long nNewValue);
long GetGridSpaceBetweenVerticalLines();
void SetGridSpaceBetweenVerticalLines(long nNewValue);
BOOL GetGridOriginFromMargin();
void SetGridOriginFromMargin(BOOL bNewValue);
BOOL GetKerningByAlgorithm();
void SetKerningByAlgorithm(BOOL bNewValue);
long GetJustificationMode();
void SetJustificationMode(long nNewValue);
long GetFarEastLineBreakLevel();
void SetFarEastLineBreakLevel(long nNewValue);
CString GetNoLineBreakBefore();
void SetNoLineBreakBefore(LPCTSTR lpszNewValue);
CString GetNoLineBreakAfter();
void SetNoLineBreakAfter(LPCTSTR lpszNewValue);
BOOL GetTrackRevisions();
void SetTrackRevisions(BOOL bNewValue);
BOOL GetPrintRevisions();
void SetPrintRevisions(BOOL bNewValue);
BOOL GetShowRevisions();
void SetShowRevisions(BOOL bNewValue);
void Close(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument);
void Repaginate();
void FitToPages();
void ManualHyphenation();
void Select();
void DataForm();
void Route();
void Save();
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 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 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 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 GetActiveTheme();
CString GetActiveThemeDisplayName();
LPDISPATCH GetEmail();
LPDISPATCH GetScripts();
BOOL GetLanguageDetected();
void SetLanguageDetected(BOOL bNewValue);
long GetFarEastLineBreakLanguage();
void SetFarEastLineBreakLanguage(long nNewValue);
LPDISPATCH GetFrameset();
VARIANT GetClickAndTypeParagraphStyle();
void SetClickAndTypeParagraphStyle(VARIANT* newValue);
LPDISPATCH GetHTMLProject();
LPDISPATCH GetWebOptions();
long GetOpenEncoding();
long GetSaveEncoding();
void SetSaveEncoding(long nNewValue);
BOOL GetOptimizeForWord97();
void SetOptimizeForWord97(BOOL bNewValue);
BOOL GetVBASigned();
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 GetMailEnvelope();
BOOL GetDisableFeatures();
void SetDisableFeatures(BOOL bNewValue);
BOOL GetDoNotEmbedSystemFonts();
void SetDoNotEmbedSystemFonts(BOOL bNewValue);
LPDISPATCH GetSignatures();
CString GetDefaultTargetFrame();
void SetDefaultTargetFrame(LPCTSTR lpszNewValue);
LPDISPATCH GetHTMLDivisions();
long GetDisableFeaturesIntroducedAfter();
void SetDisableFeaturesIntroducedAfter(long nNewValue);
BOOL GetRemovePersonalInformation();
void SetRemovePersonalInformation(BOOL bNewValue);
LPDISPATCH GetSmartTags();
void CheckIn(BOOL SaveChanges, VARIANT* Comments, BOOL MakePublic);
BOOL CanCheckin();
void Merge(LPCTSTR FileName, VARIANT* MergeTarget, VARIANT* DetectFormatChanges, VARIANT* UseFormattingFrom, VARIANT* AddToRecentFiles);
BOOL GetEmbedSmartTags();
void SetEmbedSmartTags(BOOL bNewValue);
BOOL GetSmartTagsAsXMLProps();
void SetSmartTagsAsXMLProps(BOOL bNewValue);
long GetTextEncoding();
void SetTextEncoding(long nNewValue);
long GetTextLineEnding();
void SetTextLineEnding(long nNewValue);
void SendForReview(VARIANT* Recipients, VARIANT* Subject, VARIANT* ShowMessage, VARIANT* IncludeAttachment);
void ReplyWithChanges(VARIANT* ShowMessage);
void EndReview();
LPDISPATCH GetStyleSheets();
VARIANT GetDefaultTableStyle();
CString GetPasswordEncryptionProvider();
CString GetPasswordEncryptionAlgorithm();
long GetPasswordEncryptionKeyLength();
BOOL GetPasswordEncryptionFileProperties();
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 GetEmbedLinguisticData();
void SetEmbedLinguisticData(BOOL bNewValue);
BOOL GetFormattingShowFont();
void SetFormattingShowFont(BOOL bNewValue);
BOOL GetFormattingShowClear();
void SetFormattingShowClear(BOOL bNewValue);
BOOL GetFormattingShowParagraph();
void SetFormattingShowParagraph(BOOL bNewValue);
BOOL GetFormattingShowNumbering();
void SetFormattingShowNumbering(BOOL bNewValue);
long GetFormattingShowFilter();
void SetFormattingShowFilter(long nNewValue);
void CheckNewSmartTags();
LPDISPATCH GetPermission();
LPDISPATCH GetXMLNodes();
LPDISPATCH GetXMLSchemaReferences();
LPDISPATCH GetSmartDocument();
LPDISPATCH GetSharedWorkspace();
LPDISPATCH GetSync();
BOOL GetEnforceStyle();
void SetEnforceStyle(BOOL bNewValue);
BOOL GetAutoFormatOverride();
void SetAutoFormatOverride(BOOL bNewValue);
BOOL GetXMLSaveDataOnly();
void SetXMLSaveDataOnly(BOOL bNewValue);
BOOL GetXMLHideNamespaces();
void SetXMLHideNamespaces(BOOL bNewValue);
BOOL GetXMLShowAdvancedErrors();
void SetXMLShowAdvancedErrors(BOOL bNewValue);
BOOL GetXMLUseXSLTWhenSaving();
void SetXMLUseXSLTWhenSaving(BOOL bNewValue);
CString GetXMLSaveThroughXSLT();
void SetXMLSaveThroughXSLT(LPCTSTR lpszNewValue);
LPDISPATCH GetDocumentLibraryVersions();
BOOL GetReadingModeLayoutFrozen();
void SetReadingModeLayoutFrozen(BOOL bNewValue);
BOOL GetRemoveDateAndTime();
void SetRemoveDateAndTime(BOOL bNewValue);
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 Compare(LPCTSTR Name, VARIANT* AuthorName, VARIANT* CompareTarget, VARIANT* DetectFormatChanges, VARIANT* IgnoreAllComparisonWarnings, VARIANT* AddToRecentFiles, VARIANT* RemovePersonalInformation, VARIANT* RemoveDateAndTime);
void RemoveLockedStyles();
LPDISPATCH GetChildNodeSuggestions();
LPDISPATCH SelectSingleNode(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes);
LPDISPATCH SelectNodes(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes);
LPDISPATCH GetXMLSchemaViolations();
long GetReadingLayoutSizeX();
void SetReadingLayoutSizeX(long nNewValue);
long GetReadingLayoutSizeY();
void SetReadingLayoutSizeY(long nNewValue);
};
/
// Template wrapper class


class Template : public COleDispatchDriver
{
public:
Template() {} // Calls COleDispatchDriver default constructor
Template(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Template(const Template& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetPath();
LPDISPATCH GetAutoTextEntries();
long GetLanguageID();
void SetLanguageID(long nNewValue);
BOOL GetSaved();
void SetSaved(BOOL bNewValue);
long GetType();
CString GetFullName();
LPDISPATCH GetBuiltInDocumentProperties();
LPDISPATCH GetCustomDocumentProperties();
LPDISPATCH GetListTemplates();
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
LPDISPATCH GetVBProject();
BOOL GetKerningByAlgorithm();
void SetKerningByAlgorithm(BOOL bNewValue);
long GetJustificationMode();
void SetJustificationMode(long nNewValue);
long GetFarEastLineBreakLevel();
void SetFarEastLineBreakLevel(long nNewValue);
CString GetNoLineBreakBefore();
void SetNoLineBreakBefore(LPCTSTR lpszNewValue);
CString GetNoLineBreakAfter();
void SetNoLineBreakAfter(LPCTSTR lpszNewValue);
LPDISPATCH OpenAsDocument();
void Save();
long GetNoProofing();
void SetNoProofing(long nNewValue);
long GetFarEastLineBreakLanguage();
void SetFarEastLineBreakLanguage(long nNewValue);
};
/
// Templates wrapper class


class Templates : public COleDispatchDriver
{
public:
Templates() {} // Calls COleDispatchDriver default constructor
Templates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Templates(const Templates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
};
/
// RoutingSlip wrapper class


class RoutingSlip : public COleDispatchDriver
{
public:
RoutingSlip() {} // Calls COleDispatchDriver default constructor
RoutingSlip(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
RoutingSlip(const RoutingSlip& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetSubject();
void SetSubject(LPCTSTR lpszNewValue);
CString GetMessage();
void SetMessage(LPCTSTR lpszNewValue);
long GetDelivery();
void SetDelivery(long nNewValue);
BOOL GetTrackStatus();
void SetTrackStatus(BOOL bNewValue);
long GetProtect();
void SetProtect(long nNewValue);
BOOL GetReturnWhenDone();
void SetReturnWhenDone(BOOL bNewValue);
long GetStatus();
VARIANT GetRecipients(VARIANT* Index);
void Reset();
void AddRecipient(LPCTSTR Recipient);
};
/
// Bookmark wrapper class


class Bookmark : public COleDispatchDriver
{
public:
Bookmark() {} // Calls COleDispatchDriver default constructor
Bookmark(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Bookmark(const Bookmark& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
LPDISPATCH GetRange();
BOOL GetEmpty();
long GetStart();
void SetStart(long nNewValue);
long GetEnd();
void SetEnd(long nNewValue);
BOOL GetColumn();
long GetStoryType();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void Select();
void Delete();
LPDISPATCH Copy(LPCTSTR Name);
};
/
// Bookmarks wrapper class


class Bookmarks : public COleDispatchDriver
{
public:
Bookmarks() {} // Calls COleDispatchDriver default constructor
Bookmarks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Bookmarks(const Bookmarks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetDefaultSorting();
void SetDefaultSorting(long nNewValue);
BOOL GetShowHidden();
void SetShowHidden(BOOL bNewValue);
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* Range);
BOOL Exists(LPCTSTR Name);
};
/
// Variable wrapper class


class Variable : public COleDispatchDriver
{
public:
Variable() {} // Calls COleDispatchDriver default constructor
Variable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Variable(const Variable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
CString GetValue();
void SetValue(LPCTSTR lpszNewValue);
long GetIndex();
void Delete();
};
/
// Variables wrapper class


class Variables : public COleDispatchDriver
{
public:
Variables() {} // Calls COleDispatchDriver default constructor
Variables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Variables(const Variables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* Value);
};
/
// RecentFile wrapper class


class RecentFile : public COleDispatchDriver
{
public:
RecentFile() {} // Calls COleDispatchDriver default constructor
RecentFile(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
RecentFile(const RecentFile& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
long GetIndex();
BOOL GetReadOnly();
void SetReadOnly(BOOL bNewValue);
CString GetPath();
LPDISPATCH Open();
void Delete();
};
/
// RecentFiles wrapper class


class RecentFiles : public COleDispatchDriver
{
public:
RecentFiles() {} // Calls COleDispatchDriver default constructor
RecentFiles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
RecentFiles(const RecentFiles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetMaximum();
void SetMaximum(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* Document, VARIANT* ReadOnly);
};
/
// Window wrapper class


class Window : public COleDispatchDriver
{
public:
Window() {} // Calls COleDispatchDriver default constructor
Window(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Window(const Window& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetActivePane();
LPDISPATCH GetDocument();
LPDISPATCH GetPanes();
LPDISPATCH GetSelection();
long GetLeft();
void SetLeft(long nNewValue);
long GetTop();
void SetTop(long nNewValue);
long GetWidth();
void SetWidth(long nNewValue);
long GetHeight();
void SetHeight(long nNewValue);
BOOL GetSplit();
void SetSplit(BOOL bNewValue);
long GetSplitVertical();
void SetSplitVertical(long nNewValue);
CString GetCaption();
void SetCaption(LPCTSTR lpszNewValue);
long GetWindowState();
void SetWindowState(long nNewValue);
BOOL GetDisplayRulers();
void SetDisplayRulers(BOOL bNewValue);
BOOL GetDisplayVerticalRuler();
void SetDisplayVerticalRuler(BOOL bNewValue);
LPDISPATCH GetView();
long GetType();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
long GetWindowNumber();
BOOL GetDisplayVerticalScrollBar();
void SetDisplayVerticalScrollBar(BOOL bNewValue);
BOOL GetDisplayHorizontalScrollBar();
void SetDisplayHorizontalScrollBar(BOOL bNewValue);
float GetStyleAreaWidth();
void SetStyleAreaWidth(float newValue);
BOOL GetDisplayScreenTips();
void SetDisplayScreenTips(BOOL bNewValue);
long GetHorizontalPercentScrolled();
void SetHorizontalPercentScrolled(long nNewValue);
long GetVerticalPercentScrolled();
void SetVerticalPercentScrolled(long nNewValue);
BOOL GetDocumentMap();
void SetDocumentMap(BOOL bNewValue);
BOOL GetActive();
long GetDocumentMapPercentWidth();
void SetDocumentMapPercentWidth(long nNewValue);
long GetIndex();
long GetIMEMode();
void SetIMEMode(long nNewValue);
void Activate();
void Close(VARIANT* SaveChanges, VARIANT* RouteDocument);
void LargeScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft);
void SmallScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft);
LPDISPATCH NewWindow();
void PageScroll(VARIANT* Down, VARIANT* Up);
void SetFocus();
LPDISPATCH RangeFromPoint(long x, long y);
void ScrollIntoView(LPDISPATCH obj, VARIANT* Start);
void GetPoint(long* ScreenPixelsLeft, long* ScreenPixelsTop, long* ScreenPixelsWidth, long* ScreenPixelsHeight, LPDISPATCH obj);
long GetUsableWidth();
long GetUsableHeight();
BOOL GetEnvelopeVisible();
void SetEnvelopeVisible(BOOL bNewValue);
BOOL GetDisplayRightRuler();
void SetDisplayRightRuler(BOOL bNewValue);
BOOL GetDisplayLeftScrollBar();
void SetDisplayLeftScrollBar(BOOL bNewValue);
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
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);
void ToggleShowAllReviewers();
BOOL GetThumbnails();
void SetThumbnails(BOOL bNewValue);
};
/
// Windows wrapper class


class Windows : public COleDispatchDriver
{
public:
Windows() {} // Calls COleDispatchDriver default constructor
Windows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Windows(const Windows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(VARIANT* Window);
void Arrange(VARIANT* ArrangeStyle);
BOOL CompareSideBySideWith(VARIANT* Document);
BOOL BreakSideBySide();
void ResetPositionsSideBySide();
BOOL GetSyncScrollingSideBySide();
void SetSyncScrollingSideBySide(BOOL bNewValue);
};
/
// Pane wrapper class


class Pane : public COleDispatchDriver
{
public:
Pane() {} // Calls COleDispatchDriver default constructor
Pane(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Pane(const Pane& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetDocument();
LPDISPATCH GetSelection();
BOOL GetDisplayRulers();
void SetDisplayRulers(BOOL bNewValue);
BOOL GetDisplayVerticalRuler();
void SetDisplayVerticalRuler(BOOL bNewValue);
LPDISPATCH GetZooms();
long GetIndex();
LPDISPATCH GetView();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
long GetHorizontalPercentScrolled();
void SetHorizontalPercentScrolled(long nNewValue);
long GetVerticalPercentScrolled();
void SetVerticalPercentScrolled(long nNewValue);
long GetMinimumFontSize();
void SetMinimumFontSize(long nNewValue);
long GetBrowseWidth();
void Activate();
void Close();
void LargeScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft);
void SmallScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft);
void AutoScroll(long Velocity);
void PageScroll(VARIANT* Down, VARIANT* Up);
void NewFrameset();
void TOCInFrameset();
LPDISPATCH GetFrameset();
LPDISPATCH GetPages();
};
/
// Panes wrapper class


class Panes : public COleDispatchDriver
{
public:
Panes() {} // Calls COleDispatchDriver default constructor
Panes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Panes(const Panes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* SplitVertical);
};
/
// Range wrapper class


class Range : public COleDispatchDriver
{
public:
Range() {} // Calls COleDispatchDriver default constructor
Range(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Range(const Range& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetText();
void SetText(LPCTSTR lpszNewValue);
LPDISPATCH GetFormattedText();
void SetFormattedText(LPDISPATCH newValue);
long GetStart();
void SetStart(long nNewValue);
long GetEnd();
void SetEnd(long nNewValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
LPDISPATCH GetDuplicate();
long GetStoryType();
LPDISPATCH GetTables();
LPDISPATCH GetWords();
LPDISPATCH GetSentences();
LPDISPATCH GetCharacters();
LPDISPATCH GetFootnotes();
LPDISPATCH GetEndnotes();
LPDISPATCH GetComments();
LPDISPATCH GetCells();
LPDISPATCH GetSections();
LPDISPATCH GetParagraphs();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH GetTextRetrievalMode();
void SetTextRetrievalMode(LPDISPATCH newValue);
LPDISPATCH GetFields();
LPDISPATCH GetFormFields();
LPDISPATCH GetFrames();
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
LPDISPATCH GetListFormat();
LPDISPATCH GetBookmarks();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetBold();
void SetBold(long nNewValue);
long GetItalic();
void SetItalic(long nNewValue);
long GetUnderline();
void SetUnderline(long nNewValue);
long GetEmphasisMark();
void SetEmphasisMark(long nNewValue);
BOOL GetDisableCharacterSpaceGrid();
void SetDisableCharacterSpaceGrid(BOOL bNewValue);
LPDISPATCH GetRevisions();
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
long GetStoryLength();
long GetLanguageID();
void SetLanguageID(long nNewValue);
LPDISPATCH GetSynonymInfo();
LPDISPATCH GetHyperlinks();
LPDISPATCH GetListParagraphs();
LPDISPATCH GetSubdocuments();
BOOL GetGrammarChecked();
void SetGrammarChecked(BOOL bNewValue);
BOOL GetSpellingChecked();
void SetSpellingChecked(BOOL bNewValue);
long GetHighlightColorIndex();
void SetHighlightColorIndex(long nNewValue);
LPDISPATCH GetColumns();
LPDISPATCH GetRows();
BOOL GetIsEndOfRowMark();
long GetBookmarkID();
long GetPreviousBookmarkID();
LPDISPATCH GetFind();
LPDISPATCH GetPageSetup();
void SetPageSetup(LPDISPATCH newValue);
LPDISPATCH GetShapeRange();
long GetCase();
void SetCase(long nNewValue);
VARIANT GetInformation(long Type);
LPDISPATCH GetReadabilityStatistics();
LPDISPATCH GetGrammaticalErrors();
LPDISPATCH GetSpellingErrors();
long GetOrientation();
void SetOrientation(long nNewValue);
LPDISPATCH GetInlineShapes();
LPDISPATCH GetNextStoryRange();
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
long GetLanguageIDOther();
void SetLanguageIDOther(long nNewValue);
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();
void InsertSymbol(long CharacterNumber, VARIANT* Font, VARIANT* Unicode, VARIANT* Bias);
void CopyAsPicture();
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 GetLanguageDetected();
void SetLanguageDetected(BOOL bNewValue);
float GetFitTextWidth();
void SetFitTextWidth(float newValue);
long GetHorizontalInVertical();
void SetHorizontalInVertical(long nNewValue);
long GetTwoLinesInOne();
void SetTwoLinesInOne(long nNewValue);
BOOL GetCombineCharacters();
void SetCombineCharacters(BOOL bNewValue);
long GetNoProofing();
void SetNoProofing(long nNewValue);
LPDISPATCH GetTopLevelTables();
LPDISPATCH GetScripts();
long GetCharacterWidth();
void SetCharacterWidth(long nNewValue);
long GetKana();
void SetKana(long nNewValue);
long GetBoldBi();
void SetBoldBi(long nNewValue);
long GetItalicBi();
void SetItalicBi(long nNewValue);
CString GetId();
void SetId(LPCTSTR lpszNewValue);
LPDISPATCH GetHTMLDivisions();
LPDISPATCH GetSmartTags();
BOOL GetShowAll();
void SetShowAll(BOOL bNewValue);
LPDISPATCH GetDocument();
LPDISPATCH GetFootnoteOptions();
LPDISPATCH GetEndnoteOptions();
void PasteAndFormat(long Type);
void PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF);
void PasteAppendTable();
LPDISPATCH GetXMLNodes();
LPDISPATCH GetXMLParentNode();
LPDISPATCH GetEditors();
CString GetXml(BOOL DataOnly);
VARIANT GetEnhMetaFileBits();
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);
};
/
// ListFormat wrapper class


class ListFormat : public COleDispatchDriver
{
public:
ListFormat() {} // Calls COleDispatchDriver default constructor
ListFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListFormat(const ListFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
long GetListLevelNumber();
void SetListLevelNumber(long nNewValue);
LPDISPATCH GetList();
LPDISPATCH GetListTemplate();
long GetListValue();
BOOL GetSingleList();
BOOL GetSingleListTemplate();
long GetListType();
CString GetListString();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long CanContinuePreviousList(LPDISPATCH ListTemplate);
void RemoveNumbers(VARIANT* NumberType);
void ConvertNumbersToText(VARIANT* NumberType);
long CountNumberedItems(VARIANT* NumberType, VARIANT* Level);
void ListOutdent();
void ListIndent();
void ApplyBulletDefault(VARIANT* DefaultListBehavior);
void ApplyNumberDefault(VARIANT* DefaultListBehavior);
void ApplyOutlineNumberDefault(VARIANT* DefaultListBehavior);
void ApplyListTemplate(LPDISPATCH ListTemplate, VARIANT* ContinuePreviousList, VARIANT* ApplyTo, VARIANT* DefaultListBehavior);
LPDISPATCH GetListPictureBullet();
};
/
// Find wrapper class


class Find : public COleDispatchDriver
{
public:
Find() {} // Calls COleDispatchDriver default constructor
Find(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Find(const Find& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetForward();
void SetForward(BOOL bNewValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
BOOL GetFound();
BOOL GetMatchAllWordForms();
void SetMatchAllWordForms(BOOL bNewValue);
BOOL GetMatchCase();
void SetMatchCase(BOOL bNewValue);
BOOL GetMatchWildcards();
void SetMatchWildcards(BOOL bNewValue);
BOOL GetMatchSoundsLike();
void SetMatchSoundsLike(BOOL bNewValue);
BOOL GetMatchWholeWord();
void SetMatchWholeWord(BOOL bNewValue);
BOOL GetMatchFuzzy();
void SetMatchFuzzy(BOOL bNewValue);
BOOL GetMatchByte();
void SetMatchByte(BOOL bNewValue);
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
CString GetText();
void SetText(LPCTSTR lpszNewValue);
long GetLanguageID();
void SetLanguageID(long nNewValue);
long GetHighlight();
void SetHighlight(long nNewValue);
LPDISPATCH GetReplacement();
LPDISPATCH GetFrame();
long GetWrap();
void SetWrap(long nNewValue);
BOOL GetFormat();
void SetFormat(BOOL bNewValue);
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
long GetLanguageIDOther();
void SetLanguageIDOther(long nNewValue);
BOOL GetCorrectHangulEndings();
void SetCorrectHangulEndings(BOOL bNewValue);
void ClearFormatting();
void SetAllFuzzyOptions();
void ClearAllFuzzyOptions();
BOOL Execute(VARIANT* FindText, VARIANT* MatchCase, VARIANT* MatchWholeWord, VARIANT* MatchWildcards, VARIANT* MatchSoundsLike, VARIANT* MatchAllWordForms, VARIANT* Forward, VARIANT* Wrap, VARIANT* Format, VARIANT* ReplaceWith, 
VARIANT* Replace, VARIANT* MatchKashida, VARIANT* MatchDiacritics, VARIANT* MatchAlefHamza, VARIANT* MatchControl);
long GetNoProofing();
void SetNoProofing(long nNewValue);
BOOL GetMatchKashida();
void SetMatchKashida(BOOL bNewValue);
BOOL GetMatchDiacritics();
void SetMatchDiacritics(BOOL bNewValue);
BOOL GetMatchAlefHamza();
void SetMatchAlefHamza(BOOL bNewValue);
BOOL GetMatchControl();
void SetMatchControl(BOOL bNewValue);
};
/
// Replacement wrapper class


class Replacement : public COleDispatchDriver
{
public:
Replacement() {} // Calls COleDispatchDriver default constructor
Replacement(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Replacement(const Replacement& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
CString GetText();
void SetText(LPCTSTR lpszNewValue);
long GetLanguageID();
void SetLanguageID(long nNewValue);
long GetHighlight();
void SetHighlight(long nNewValue);
LPDISPATCH GetFrame();
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
void ClearFormatting();
long GetNoProofing();
void SetNoProofing(long nNewValue);
};
/
// Characters wrapper class


class Characters : public COleDispatchDriver
{
public:
Characters() {} // Calls COleDispatchDriver default constructor
Characters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Characters(const Characters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Words wrapper class


class Words : public COleDispatchDriver
{
public:
Words() {} // Calls COleDispatchDriver default constructor
Words(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Words(const Words& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Sentences wrapper class


class Sentences : public COleDispatchDriver
{
public:
Sentences() {} // Calls COleDispatchDriver default constructor
Sentences(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Sentences(const Sentences& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Sections wrapper class


class Sections : public COleDispatchDriver
{
public:
Sections() {} // Calls COleDispatchDriver default constructor
Sections(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Sections(const Sections& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetPageSetup();
void SetPageSetup(LPDISPATCH newValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* Range, VARIANT* Start);
};
/
// Section wrapper class


class Section : public COleDispatchDriver
{
public:
Section() {} // Calls COleDispatchDriver default constructor
Section(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Section(const Section& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetPageSetup();
void SetPageSetup(LPDISPATCH newValue);
LPDISPATCH GetHeaders();
LPDISPATCH GetFooters();
BOOL GetProtectedForForms();
void SetProtectedForForms(BOOL bNewValue);
long GetIndex();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
};
/
// Paragraphs wrapper class


class Paragraphs : public COleDispatchDriver
{
public:
Paragraphs() {} // Calls COleDispatchDriver default constructor
Paragraphs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Paragraphs(const Paragraphs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetFormat();
void SetFormat(LPDISPATCH newValue);
LPDISPATCH GetTabStops();
void SetTabStops(LPDISPATCH newValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetKeepTogether();
void SetKeepTogether(long nNewValue);
long GetKeepWithNext();
void SetKeepWithNext(long nNewValue);
long GetPageBreakBefore();
void SetPageBreakBefore(long nNewValue);
long GetNoLineNumber();
void SetNoLineNumber(long nNewValue);
float GetRightIndent();
void SetRightIndent(float newValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
float GetFirstLineIndent();
void SetFirstLineIndent(float newValue);
float GetLineSpacing();
void SetLineSpacing(float newValue);
long GetLineSpacingRule();
void SetLineSpacingRule(long nNewValue);
float GetSpaceBefore();
void SetSpaceBefore(float newValue);
float GetSpaceAfter();
void SetSpaceAfter(float newValue);
long GetHyphenation();
void SetHyphenation(long nNewValue);
long GetWidowControl();
void SetWidowControl(long nNewValue);
LPDISPATCH GetShading();
long GetFarEastLineBreakControl();
void SetFarEastLineBreakControl(long nNewValue);
long GetWordWrap();
void SetWordWrap(long nNewValue);
long GetHangingPunctuation();
void SetHangingPunctuation(long nNewValue);
long GetHalfWidthPunctuationOnTopOfLine();
void SetHalfWidthPunctuationOnTopOfLine(long nNewValue);
long GetAddSpaceBetweenFarEastAndAlpha();
void SetAddSpaceBetweenFarEastAndAlpha(long nNewValue);
long GetAddSpaceBetweenFarEastAndDigit();
void SetAddSpaceBetweenFarEastAndDigit(long nNewValue);
long GetBaseLineAlignment();
void SetBaseLineAlignment(long nNewValue);
long GetAutoAdjustRightIndent();
void SetAutoAdjustRightIndent(long nNewValue);
long GetDisableLineHeightGrid();
void SetDisableLineHeightGrid(long nNewValue);
long GetOutlineLevel();
void SetOutlineLevel(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* Range);
void CloseUp();
void OpenUp();
void OpenOrCloseUp();
void TabHangingIndent(short Count);
void TabIndent(short Count);
void Reset();
void Space1();
void Space15();
void Space2();
void IndentCharWidth(short Count);
void IndentFirstLineCharWidth(short Count);
void OutlinePromote();
void OutlineDemote();
void OutlineDemoteToBody();
void Indent();
void Outdent();
float GetCharacterUnitRightIndent();
void SetCharacterUnitRightIndent(float newValue);
float GetCharacterUnitLeftIndent();
void SetCharacterUnitLeftIndent(float newValue);
float GetCharacterUnitFirstLineIndent();
void SetCharacterUnitFirstLineIndent(float newValue);
float GetLineUnitBefore();
void SetLineUnitBefore(float newValue);
float GetLineUnitAfter();
void SetLineUnitAfter(float newValue);
long GetReadingOrder();
void SetReadingOrder(long nNewValue);
long GetSpaceBeforeAuto();
void SetSpaceBeforeAuto(long nNewValue);
long GetSpaceAfterAuto();
void SetSpaceAfterAuto(long nNewValue);
void IncreaseSpacing();
void DecreaseSpacing();
};
/
// Paragraph wrapper class


class Paragraph : public COleDispatchDriver
{
public:
Paragraph() {} // Calls COleDispatchDriver default constructor
Paragraph(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Paragraph(const Paragraph& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetFormat();
void SetFormat(LPDISPATCH newValue);
LPDISPATCH GetTabStops();
void SetTabStops(LPDISPATCH newValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetDropCap();
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetKeepTogether();
void SetKeepTogether(long nNewValue);
long GetKeepWithNext();
void SetKeepWithNext(long nNewValue);
long GetPageBreakBefore();
void SetPageBreakBefore(long nNewValue);
long GetNoLineNumber();
void SetNoLineNumber(long nNewValue);
float GetRightIndent();
void SetRightIndent(float newValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
float GetFirstLineIndent();
void SetFirstLineIndent(float newValue);
float GetLineSpacing();
void SetLineSpacing(float newValue);
long GetLineSpacingRule();
void SetLineSpacingRule(long nNewValue);
float GetSpaceBefore();
void SetSpaceBefore(float newValue);
float GetSpaceAfter();
void SetSpaceAfter(float newValue);
long GetHyphenation();
void SetHyphenation(long nNewValue);
long GetWidowControl();
void SetWidowControl(long nNewValue);
LPDISPATCH GetShading();
long GetFarEastLineBreakControl();
void SetFarEastLineBreakControl(long nNewValue);
long GetWordWrap();
void SetWordWrap(long nNewValue);
long GetHangingPunctuation();
void SetHangingPunctuation(long nNewValue);
long GetHalfWidthPunctuationOnTopOfLine();
void SetHalfWidthPunctuationOnTopOfLine(long nNewValue);
long GetAddSpaceBetweenFarEastAndAlpha();
void SetAddSpaceBetweenFarEastAndAlpha(long nNewValue);
long GetAddSpaceBetweenFarEastAndDigit();
void SetAddSpaceBetweenFarEastAndDigit(long nNewValue);
long GetBaseLineAlignment();
void SetBaseLineAlignment(long nNewValue);
long GetAutoAdjustRightIndent();
void SetAutoAdjustRightIndent(long nNewValue);
long GetDisableLineHeightGrid();
void SetDisableLineHeightGrid(long nNewValue);
long GetOutlineLevel();
void SetOutlineLevel(long nNewValue);
void CloseUp();
void OpenUp();
void OpenOrCloseUp();
void TabHangingIndent(short Count);
void TabIndent(short Count);
void Reset();
void Space1();
void Space15();
void Space2();
void IndentCharWidth(short Count);
void IndentFirstLineCharWidth(short Count);
LPDISPATCH Next(VARIANT* Count);
LPDISPATCH Previous(VARIANT* Count);
void OutlinePromote();
void OutlineDemote();
void OutlineDemoteToBody();
void Indent();
void Outdent();
float GetCharacterUnitRightIndent();
void SetCharacterUnitRightIndent(float newValue);
float GetCharacterUnitLeftIndent();
void SetCharacterUnitLeftIndent(float newValue);
float GetCharacterUnitFirstLineIndent();
void SetCharacterUnitFirstLineIndent(float newValue);
float GetLineUnitBefore();
void SetLineUnitBefore(float newValue);
float GetLineUnitAfter();
void SetLineUnitAfter(float newValue);
long GetReadingOrder();
void SetReadingOrder(long nNewValue);
CString GetId();
void SetId(LPCTSTR lpszNewValue);
long GetSpaceBeforeAuto();
void SetSpaceBeforeAuto(long nNewValue);
long GetSpaceAfterAuto();
void SetSpaceAfterAuto(long nNewValue);
BOOL GetIsStyleSeparator();
void SelectNumber();
};
/
// DropCap wrapper class


class DropCap : public COleDispatchDriver
{
public:
DropCap() {} // Calls COleDispatchDriver default constructor
DropCap(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DropCap(const DropCap& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetPosition();
void SetPosition(long nNewValue);
CString GetFontName();
void SetFontName(LPCTSTR lpszNewValue);
long GetLinesToDrop();
void SetLinesToDrop(long nNewValue);
float GetDistanceFromText();
void SetDistanceFromText(float newValue);
void Clear();
void Enable();
};
/
// TabStops wrapper class


class TabStops : public COleDispatchDriver
{
public:
TabStops() {} // Calls COleDispatchDriver default constructor
TabStops(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TabStops(const TabStops& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(float Position, VARIANT* Alignment, VARIANT* Leader);
void ClearAll();
LPDISPATCH Before(float Position);
LPDISPATCH After(float Position);
};
/
// TabStop wrapper class


class TabStop : public COleDispatchDriver
{
public:
TabStop() {} // Calls COleDispatchDriver default constructor
TabStop(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TabStop(const TabStop& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetAlignment();
void SetAlignment(long nNewValue);
long GetLeader();
void SetLeader(long nNewValue);
float GetPosition();
void SetPosition(float newValue);
BOOL GetCustomTab();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
void Clear();
};
/
// _ParagraphFormat wrapper class


class _ParagraphFormat : public COleDispatchDriver
{
public:
_ParagraphFormat() {} // Calls COleDispatchDriver default constructor
_ParagraphFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_ParagraphFormat(const _ParagraphFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetDuplicate();
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetKeepTogether();
void SetKeepTogether(long nNewValue);
long GetKeepWithNext();
void SetKeepWithNext(long nNewValue);
long GetPageBreakBefore();
void SetPageBreakBefore(long nNewValue);
long GetNoLineNumber();
void SetNoLineNumber(long nNewValue);
float GetRightIndent();
void SetRightIndent(float newValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
float GetFirstLineIndent();
void SetFirstLineIndent(float newValue);
float GetLineSpacing();
void SetLineSpacing(float newValue);
long GetLineSpacingRule();
void SetLineSpacingRule(long nNewValue);
float GetSpaceBefore();
void SetSpaceBefore(float newValue);
float GetSpaceAfter();
void SetSpaceAfter(float newValue);
long GetHyphenation();
void SetHyphenation(long nNewValue);
long GetWidowControl();
void SetWidowControl(long nNewValue);
long GetFarEastLineBreakControl();
void SetFarEastLineBreakControl(long nNewValue);
long GetWordWrap();
void SetWordWrap(long nNewValue);
long GetHangingPunctuation();
void SetHangingPunctuation(long nNewValue);
long GetHalfWidthPunctuationOnTopOfLine();
void SetHalfWidthPunctuationOnTopOfLine(long nNewValue);
long GetAddSpaceBetweenFarEastAndAlpha();
void SetAddSpaceBetweenFarEastAndAlpha(long nNewValue);
long GetAddSpaceBetweenFarEastAndDigit();
void SetAddSpaceBetweenFarEastAndDigit(long nNewValue);
long GetBaseLineAlignment();
void SetBaseLineAlignment(long nNewValue);
long GetAutoAdjustRightIndent();
void SetAutoAdjustRightIndent(long nNewValue);
long GetDisableLineHeightGrid();
void SetDisableLineHeightGrid(long nNewValue);
LPDISPATCH GetTabStops();
void SetTabStops(LPDISPATCH newValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
long GetOutlineLevel();
void SetOutlineLevel(long nNewValue);
void CloseUp();
void OpenUp();
void OpenOrCloseUp();
void TabHangingIndent(short Count);
void TabIndent(short Count);
void Reset();
void Space1();
void Space15();
void Space2();
void IndentCharWidth(short Count);
void IndentFirstLineCharWidth(short Count);
float GetCharacterUnitRightIndent();
void SetCharacterUnitRightIndent(float newValue);
float GetCharacterUnitLeftIndent();
void SetCharacterUnitLeftIndent(float newValue);
float GetCharacterUnitFirstLineIndent();
void SetCharacterUnitFirstLineIndent(float newValue);
float GetLineUnitBefore();
void SetLineUnitBefore(float newValue);
float GetLineUnitAfter();
void SetLineUnitAfter(float newValue);
long GetReadingOrder();
void SetReadingOrder(long nNewValue);
long GetSpaceBeforeAuto();
void SetSpaceBeforeAuto(long nNewValue);
long GetSpaceAfterAuto();
void SetSpaceAfterAuto(long nNewValue);
};
/
// _Font wrapper class


class _Font : public COleDispatchDriver
{
public:
_Font() {} // Calls COleDispatchDriver default constructor
_Font(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_Font(const _Font& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetDuplicate();
long GetBold();
void SetBold(long nNewValue);
long GetItalic();
void SetItalic(long nNewValue);
long GetHidden();
void SetHidden(long nNewValue);
long GetSmallCaps();
void SetSmallCaps(long nNewValue);
long GetAllCaps();
void SetAllCaps(long nNewValue);
long GetStrikeThrough();
void SetStrikeThrough(long nNewValue);
long GetDoubleStrikeThrough();
void SetDoubleStrikeThrough(long nNewValue);
long GetColorIndex();
void SetColorIndex(long nNewValue);
long GetSubscript();
void SetSubscript(long nNewValue);
long GetSuperscript();
void SetSuperscript(long nNewValue);
long GetUnderline();
void SetUnderline(long nNewValue);
float GetSize();
void SetSize(float newValue);
CString GetName();
void SetName(LPCTSTR lpszNewValue);
long GetPosition();
void SetPosition(long nNewValue);
float GetSpacing();
void SetSpacing(float newValue);
long GetScaling();
void SetScaling(long nNewValue);
long GetShadow();
void SetShadow(long nNewValue);
long GetOutline();
void SetOutline(long nNewValue);
long GetEmboss();
void SetEmboss(long nNewValue);
float GetKerning();
void SetKerning(float newValue);
long GetEngrave();
void SetEngrave(long nNewValue);
long GetAnimation();
void SetAnimation(long nNewValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
long GetEmphasisMark();
void SetEmphasisMark(long nNewValue);
BOOL GetDisableCharacterSpaceGrid();
void SetDisableCharacterSpaceGrid(BOOL bNewValue);
CString GetNameFarEast();
void SetNameFarEast(LPCTSTR lpszNewValue);
CString GetNameAscii();
void SetNameAscii(LPCTSTR lpszNewValue);
CString GetNameOther();
void SetNameOther(LPCTSTR lpszNewValue);
void Grow();
void Shrink();
void Reset();
void SetAsTemplateDefault();
long GetColor();
void SetColor(long nNewValue);
long GetBoldBi();
void SetBoldBi(long nNewValue);
long GetItalicBi();
void SetItalicBi(long nNewValue);
float GetSizeBi();
void SetSizeBi(float newValue);
CString GetNameBi();
void SetNameBi(LPCTSTR lpszNewValue);
long GetColorIndexBi();
void SetColorIndexBi(long nNewValue);
long GetDiacriticColor();
void SetDiacriticColor(long nNewValue);
long GetUnderlineColor();
void SetUnderlineColor(long nNewValue);
};
/
// Table wrapper class


class Table : public COleDispatchDriver
{
public:
Table() {} // Calls COleDispatchDriver default constructor
Table(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Table(const Table& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetColumns();
LPDISPATCH GetRows();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
BOOL GetUniform();
long GetAutoFormatType();
void Select();
void Delete();
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 Cell(long Row, long Column);
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);
LPDISPATCH GetTables();
long GetNestingLevel();
BOOL GetAllowPageBreaks();
void SetAllowPageBreaks(BOOL bNewValue);
BOOL GetAllowAutoFit();
void SetAllowAutoFit(BOOL bNewValue);
float GetPreferredWidth();
void SetPreferredWidth(float newValue);
long GetPreferredWidthType();
void SetPreferredWidthType(long nNewValue);
float GetTopPadding();
void SetTopPadding(float newValue);
float GetBottomPadding();
void SetBottomPadding(float newValue);
float GetLeftPadding();
void SetLeftPadding(float newValue);
float GetRightPadding();
void SetRightPadding(float newValue);
float GetSpacing();
void SetSpacing(float newValue);
long GetTableDirection();
void SetTableDirection(long nNewValue);
CString GetId();
void SetId(LPCTSTR lpszNewValue);
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
BOOL GetApplyStyleHeadingRows();
void SetApplyStyleHeadingRows(BOOL bNewValue);
BOOL GetApplyStyleLastRow();
void SetApplyStyleLastRow(BOOL bNewValue);
BOOL GetApplyStyleFirstColumn();
void SetApplyStyleFirstColumn(BOOL bNewValue);
BOOL GetApplyStyleLastColumn();
void SetApplyStyleLastColumn(BOOL bNewValue);
};
/
// Row wrapper class


class Row : public COleDispatchDriver
{
public:
Row() {} // Calls COleDispatchDriver default constructor
Row(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Row(const Row& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetAllowBreakAcrossPages();
void SetAllowBreakAcrossPages(long nNewValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetHeadingFormat();
void SetHeadingFormat(long nNewValue);
float GetSpaceBetweenColumns();
void SetSpaceBetweenColumns(float newValue);
float GetHeight();
void SetHeight(float newValue);
long GetHeightRule();
void SetHeightRule(long nNewValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
BOOL GetIsLast();
BOOL GetIsFirst();
long GetIndex();
LPDISPATCH GetCells();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
void Select();
void Delete();
void SetLeftIndent(float LeftIndent, long RulerStyle);
void SetHeight(float RowHeight, long HeightRule);
LPDISPATCH ConvertToText(VARIANT* Separator, VARIANT* NestedTables);
long GetNestingLevel();
CString GetId();
void SetId(LPCTSTR lpszNewValue);
};
/
// Column wrapper class


class Column : public COleDispatchDriver
{
public:
Column() {} // Calls COleDispatchDriver default constructor
Column(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Column(const Column& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetWidth();
void SetWidth(float newValue);
BOOL GetIsFirst();
BOOL GetIsLast();
long GetIndex();
LPDISPATCH GetCells();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
void Select();
void Delete();
void SetWidth(float ColumnWidth, long RulerStyle);
void AutoFit();
void Sort(VARIANT* ExcludeHeader, VARIANT* SortFieldType, VARIANT* SortOrder, VARIANT* CaseSensitive, VARIANT* BidiSort, VARIANT* IgnoreThe, VARIANT* IgnoreKashida, VARIANT* IgnoreDiacritics, VARIANT* IgnoreHe, VARIANT* LanguageID);
long GetNestingLevel();
float GetPreferredWidth();
void SetPreferredWidth(float newValue);
long GetPreferredWidthType();
void SetPreferredWidthType(long nNewValue);
};
/
// Cell wrapper class


class Cell : public COleDispatchDriver
{
public:
Cell() {} // Calls COleDispatchDriver default constructor
Cell(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Cell(const Cell& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetRowIndex();
long GetColumnIndex();
float GetWidth();
void SetWidth(float newValue);
float GetHeight();
void SetHeight(float newValue);
long GetHeightRule();
void SetHeightRule(long nNewValue);
long GetVerticalAlignment();
void SetVerticalAlignment(long nNewValue);
LPDISPATCH GetColumn();
LPDISPATCH GetRow();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
LPDISPATCH GetShading();
LPDISPATCH GetBorders();
void SetBorders(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 GetTables();
long GetNestingLevel();
BOOL GetWordWrap();
void SetWordWrap(BOOL bNewValue);
float GetPreferredWidth();
void SetPreferredWidth(float newValue);
BOOL GetFitText();
void SetFitText(BOOL bNewValue);
float GetTopPadding();
void SetTopPadding(float newValue);
float GetBottomPadding();
void SetBottomPadding(float newValue);
float GetLeftPadding();
void SetLeftPadding(float newValue);
float GetRightPadding();
void SetRightPadding(float newValue);
CString GetId();
void SetId(LPCTSTR lpszNewValue);
long GetPreferredWidthType();
void SetPreferredWidthType(long nNewValue);
};
/
// Tables wrapper class


class Tables : public COleDispatchDriver
{
public:
Tables() {} // Calls COleDispatchDriver default constructor
Tables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Tables(const Tables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, long NumRows, long NumColumns, VARIANT* DefaultTableBehavior, VARIANT* AutoFitBehavior);
long GetNestingLevel();
};
/
// Rows wrapper class


class Rows : public COleDispatchDriver
{
public:
Rows() {} // Calls COleDispatchDriver default constructor
Rows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Rows(const Rows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetAllowBreakAcrossPages();
void SetAllowBreakAcrossPages(long nNewValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetHeadingFormat();
void SetHeadingFormat(long nNewValue);
float GetSpaceBetweenColumns();
void SetSpaceBetweenColumns(float newValue);
float GetHeight();
void SetHeight(float newValue);
long GetHeightRule();
void SetHeightRule(long nNewValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* BeforeRow);
void Select();
void Delete();
void SetLeftIndent(float LeftIndent, long RulerStyle);
void SetHeight(float RowHeight, long HeightRule);
void DistributeHeight();
LPDISPATCH ConvertToText(VARIANT* Separator, VARIANT* NestedTables);
long GetWrapAroundText();
void SetWrapAroundText(long nNewValue);
float GetDistanceTop();
void SetDistanceTop(float newValue);
float GetDistanceBottom();
void SetDistanceBottom(float newValue);
float GetDistanceLeft();
void SetDistanceLeft(float newValue);
float GetDistanceRight();
void SetDistanceRight(float newValue);
float GetHorizontalPosition();
void SetHorizontalPosition(float newValue);
float GetVerticalPosition();
void SetVerticalPosition(float newValue);
long GetRelativeHorizontalPosition();
void SetRelativeHorizontalPosition(long nNewValue);
long GetRelativeVerticalPosition();
void SetRelativeVerticalPosition(long nNewValue);
long GetAllowOverlap();
void SetAllowOverlap(long nNewValue);
long GetNestingLevel();
long GetTableDirection();
void SetTableDirection(long nNewValue);
};
/
// Columns wrapper class


class Columns : public COleDispatchDriver
{
public:
Columns() {} // Calls COleDispatchDriver default constructor
Columns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Columns(const Columns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetFirst();
LPDISPATCH GetLast();
float GetWidth();
void SetWidth(float newValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* BeforeColumn);
void Select();
void Delete();
void SetWidth(float ColumnWidth, long RulerStyle);
void AutoFit();
void DistributeWidth();
long GetNestingLevel();
float GetPreferredWidth();
void SetPreferredWidth(float newValue);
long GetPreferredWidthType();
void SetPreferredWidthType(long nNewValue);
};
/
// Cells wrapper class


class Cells : public COleDispatchDriver
{
public:
Cells() {} // Calls COleDispatchDriver default constructor
Cells(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Cells(const Cells& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetWidth();
void SetWidth(float newValue);
float GetHeight();
void SetHeight(float newValue);
long GetHeightRule();
void SetHeightRule(long nNewValue);
long GetVerticalAlignment();
void SetVerticalAlignment(long nNewValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* BeforeCell);
void Delete(VARIANT* ShiftCells);
void SetWidth(float ColumnWidth, long RulerStyle);
void SetHeight(VARIANT* RowHeight, long HeightRule);
void Merge();
void Split(VARIANT* NumRows, VARIANT* NumColumns, VARIANT* MergeBeforeSplit);
void DistributeHeight();
void DistributeWidth();
void AutoFit();
long GetNestingLevel();
float GetPreferredWidth();
void SetPreferredWidth(float newValue);
long GetPreferredWidthType();
void SetPreferredWidthType(long nNewValue);
};
/
// AutoCorrect wrapper class


class AutoCorrect : public COleDispatchDriver
{
public:
AutoCorrect() {} // Calls COleDispatchDriver default constructor
AutoCorrect(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoCorrect(const AutoCorrect& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetCorrectDays();
void SetCorrectDays(BOOL bNewValue);
BOOL GetCorrectInitialCaps();
void SetCorrectInitialCaps(BOOL bNewValue);
BOOL GetCorrectSentenceCaps();
void SetCorrectSentenceCaps(BOOL bNewValue);
BOOL GetReplaceText();
void SetReplaceText(BOOL bNewValue);
LPDISPATCH GetEntries();
LPDISPATCH GetFirstLetterExceptions();
BOOL GetFirstLetterAutoAdd();
void SetFirstLetterAutoAdd(BOOL bNewValue);
LPDISPATCH GetTwoInitialCapsExceptions();
BOOL GetTwoInitialCapsAutoAdd();
void SetTwoInitialCapsAutoAdd(BOOL bNewValue);
BOOL GetCorrectCapsLock();
void SetCorrectCapsLock(BOOL bNewValue);
BOOL GetCorrectHangulAndAlphabet();
void SetCorrectHangulAndAlphabet(BOOL bNewValue);
LPDISPATCH GetHangulAndAlphabetExceptions();
BOOL GetHangulAndAlphabetAutoAdd();
void SetHangulAndAlphabetAutoAdd(BOOL bNewValue);
BOOL GetReplaceTextFromSpellingChecker();
void SetReplaceTextFromSpellingChecker(BOOL bNewValue);
BOOL GetOtherCorrectionsAutoAdd();
void SetOtherCorrectionsAutoAdd(BOOL bNewValue);
LPDISPATCH GetOtherCorrectionsExceptions();
BOOL GetCorrectKeyboardSetting();
void SetCorrectKeyboardSetting(BOOL bNewValue);
BOOL GetCorrectTableCells();
void SetCorrectTableCells(BOOL bNewValue);
BOOL GetDisplayAutoCorrectOptions();
void SetDisplayAutoCorrectOptions(BOOL bNewValue);
};
/
// AutoCorrectEntries wrapper class


class AutoCorrectEntries : public COleDispatchDriver
{
public:
AutoCorrectEntries() {} // Calls COleDispatchDriver default constructor
AutoCorrectEntries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoCorrectEntries(const AutoCorrectEntries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, LPCTSTR Value);
LPDISPATCH AddRichText(LPCTSTR Name, LPDISPATCH Range);
};
/
// AutoCorrectEntry wrapper class


class AutoCorrectEntry : public COleDispatchDriver
{
public:
AutoCorrectEntry() {} // Calls COleDispatchDriver default constructor
AutoCorrectEntry(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoCorrectEntry(const AutoCorrectEntry& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
CString GetValue();
void SetValue(LPCTSTR lpszNewValue);
BOOL GetRichText();
void Delete();
void Apply(LPDISPATCH Range);
};
/
// FirstLetterExceptions wrapper class


class FirstLetterExceptions : public COleDispatchDriver
{
public:
FirstLetterExceptions() {} // Calls COleDispatchDriver default constructor
FirstLetterExceptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FirstLetterExceptions(const FirstLetterExceptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name);
};
/
// FirstLetterException wrapper class


class FirstLetterException : public COleDispatchDriver
{
public:
FirstLetterException() {} // Calls COleDispatchDriver default constructor
FirstLetterException(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FirstLetterException(const FirstLetterException& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void Delete();
};
/
// TwoInitialCapsExceptions wrapper class


class TwoInitialCapsExceptions : public COleDispatchDriver
{
public:
TwoInitialCapsExceptions() {} // Calls COleDispatchDriver default constructor
TwoInitialCapsExceptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TwoInitialCapsExceptions(const TwoInitialCapsExceptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name);
};
/
// TwoInitialCapsException wrapper class


class TwoInitialCapsException : public COleDispatchDriver
{
public:
TwoInitialCapsException() {} // Calls COleDispatchDriver default constructor
TwoInitialCapsException(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TwoInitialCapsException(const TwoInitialCapsException& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void Delete();
};
/
// Footnotes wrapper class


class Footnotes : public COleDispatchDriver
{
public:
Footnotes() {} // Calls COleDispatchDriver default constructor
Footnotes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Footnotes(const Footnotes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLocation();
void SetLocation(long nNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
long GetNumberingRule();
void SetNumberingRule(long nNewValue);
LPDISPATCH GetSeparator();
LPDISPATCH GetContinuationSeparator();
LPDISPATCH GetContinuationNotice();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Reference, VARIANT* Text);
void Convert();
void SwapWithEndnotes();
void ResetSeparator();
void ResetContinuationSeparator();
void ResetContinuationNotice();
};
/
// Endnotes wrapper class


class Endnotes : public COleDispatchDriver
{
public:
Endnotes() {} // Calls COleDispatchDriver default constructor
Endnotes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Endnotes(const Endnotes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLocation();
void SetLocation(long nNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
long GetNumberingRule();
void SetNumberingRule(long nNewValue);
LPDISPATCH GetSeparator();
LPDISPATCH GetContinuationSeparator();
LPDISPATCH GetContinuationNotice();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Reference, VARIANT* Text);
void Convert();
void SwapWithFootnotes();
void ResetSeparator();
void ResetContinuationSeparator();
void ResetContinuationNotice();
};
/
// Comments wrapper class


class Comments : public COleDispatchDriver
{
public:
Comments() {} // Calls COleDispatchDriver default constructor
Comments(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Comments(const Comments& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetShowBy();
void SetShowBy(LPCTSTR lpszNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Text);
};
/
// Footnote wrapper class


class Footnote : public COleDispatchDriver
{
public:
Footnote() {} // Calls COleDispatchDriver default constructor
Footnote(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Footnote(const Footnote& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
LPDISPATCH GetReference();
long GetIndex();
void Delete();
};
/
// Endnote wrapper class


class Endnote : public COleDispatchDriver
{
public:
Endnote() {} // Calls COleDispatchDriver default constructor
Endnote(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Endnote(const Endnote& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
LPDISPATCH GetReference();
long GetIndex();
void Delete();
};
/
// Comment wrapper class


class Comment : public COleDispatchDriver
{
public:
Comment() {} // Calls COleDispatchDriver default constructor
Comment(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Comment(const Comment& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
LPDISPATCH GetReference();
LPDISPATCH GetScope();
long GetIndex();
CString GetAuthor();
void SetAuthor(LPCTSTR lpszNewValue);
CString GetInitial();
void SetInitial(LPCTSTR lpszNewValue);
BOOL GetShowTip();
void SetShowTip(BOOL bNewValue);
void Delete();
void Edit();
DATE GetDate();
BOOL GetIsInk();
};
/
// Borders wrapper class


class Borders : public COleDispatchDriver
{
public:
Borders() {} // Calls COleDispatchDriver default constructor
Borders(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Borders(const Borders& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetEnable();
void SetEnable(long nNewValue);
long GetDistanceFromTop();
void SetDistanceFromTop(long nNewValue);
BOOL GetShadow();
void SetShadow(BOOL bNewValue);
long GetInsideLineStyle();
void SetInsideLineStyle(long nNewValue);
long GetOutsideLineStyle();
void SetOutsideLineStyle(long nNewValue);
long GetInsideLineWidth();
void SetInsideLineWidth(long nNewValue);
long GetOutsideLineWidth();
void SetOutsideLineWidth(long nNewValue);
long GetInsideColorIndex();
void SetInsideColorIndex(long nNewValue);
long GetOutsideColorIndex();
void SetOutsideColorIndex(long nNewValue);
long GetDistanceFromLeft();
void SetDistanceFromLeft(long nNewValue);
long GetDistanceFromBottom();
void SetDistanceFromBottom(long nNewValue);
long GetDistanceFromRight();
void SetDistanceFromRight(long nNewValue);
BOOL GetAlwaysInFront();
void SetAlwaysInFront(BOOL bNewValue);
BOOL GetSurroundHeader();
void SetSurroundHeader(BOOL bNewValue);
BOOL GetSurroundFooter();
void SetSurroundFooter(BOOL bNewValue);
BOOL GetJoinBorders();
void SetJoinBorders(BOOL bNewValue);
BOOL GetHasHorizontal();
BOOL GetHasVertical();
long GetDistanceFrom();
void SetDistanceFrom(long nNewValue);
BOOL GetEnableFirstPageInSection();
void SetEnableFirstPageInSection(BOOL bNewValue);
BOOL GetEnableOtherPagesInSection();
void SetEnableOtherPagesInSection(BOOL bNewValue);
LPDISPATCH Item(long Index);
void ApplyPageBordersToAllSections();
long GetInsideColor();
void SetInsideColor(long nNewValue);
long GetOutsideColor();
void SetOutsideColor(long nNewValue);
};
/
// Border wrapper class


class Border : public COleDispatchDriver
{
public:
Border() {} // Calls COleDispatchDriver default constructor
Border(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Border(const Border& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
long GetColorIndex();
void SetColorIndex(long nNewValue);
BOOL GetInside();
long GetLineStyle();
void SetLineStyle(long nNewValue);
long GetLineWidth();
void SetLineWidth(long nNewValue);
long GetArtStyle();
void SetArtStyle(long nNewValue);
long GetArtWidth();
void SetArtWidth(long nNewValue);
long GetColor();
void SetColor(long nNewValue);
};
/
// Shading wrapper class


class Shading : public COleDispatchDriver
{
public:
Shading() {} // Calls COleDispatchDriver default constructor
Shading(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Shading(const Shading& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetForegroundPatternColorIndex();
void SetForegroundPatternColorIndex(long nNewValue);
long GetBackgroundPatternColorIndex();
void SetBackgroundPatternColorIndex(long nNewValue);
long GetTexture();
void SetTexture(long nNewValue);
long GetForegroundPatternColor();
void SetForegroundPatternColor(long nNewValue);
long GetBackgroundPatternColor();
void SetBackgroundPatternColor(long nNewValue);
};
/
// TextRetrievalMode wrapper class


class TextRetrievalMode : public COleDispatchDriver
{
public:
TextRetrievalMode() {} // Calls COleDispatchDriver default constructor
TextRetrievalMode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextRetrievalMode(const TextRetrievalMode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetViewType();
void SetViewType(long nNewValue);
LPDISPATCH GetDuplicate();
BOOL GetIncludeHiddenText();
void SetIncludeHiddenText(BOOL bNewValue);
BOOL GetIncludeFieldCodes();
void SetIncludeFieldCodes(BOOL bNewValue);
};
/
// AutoTextEntries wrapper class


class AutoTextEntries : public COleDispatchDriver
{
public:
AutoTextEntries() {} // Calls COleDispatchDriver default constructor
AutoTextEntries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoTextEntries(const AutoTextEntries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, LPDISPATCH Range);
LPDISPATCH AppendToSpike(LPDISPATCH Range);
};
/
// AutoTextEntry wrapper class


class AutoTextEntry : public COleDispatchDriver
{
public:
AutoTextEntry() {} // Calls COleDispatchDriver default constructor
AutoTextEntry(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoTextEntry(const AutoTextEntry& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
CString GetStyleName();
CString GetValue();
void SetValue(LPCTSTR lpszNewValue);
void Delete();
LPDISPATCH Insert(LPDISPATCH Where, VARIANT* RichText);
};
/
// System wrapper class


class System : public COleDispatchDriver
{
public:
System() {} // Calls COleDispatchDriver default constructor
System(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
System(const System& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetOperatingSystem();
CString GetProcessorType();
CString GetVersion();
long GetFreeDiskSpace();
CString GetLanguageDesignation();
long GetHorizontalResolution();
long GetVerticalResolution();
CString GetProfileString(LPCTSTR Section, LPCTSTR Key);
void SetProfileString(LPCTSTR Section, LPCTSTR Key, LPCTSTR lpszNewValue);
CString GetPrivateProfileString(LPCTSTR FileName, LPCTSTR Section, LPCTSTR Key);
void SetPrivateProfileString(LPCTSTR FileName, LPCTSTR Section, LPCTSTR Key, LPCTSTR lpszNewValue);
BOOL GetMathCoprocessorInstalled();
CString GetComputerType();
CString GetMacintoshName();
BOOL GetQuickDrawInstalled();
long GetCursor();
void SetCursor(long nNewValue);
void MSInfo();
void Connect(LPCTSTR Path, VARIANT* Drive, VARIANT* Password);
long GetCountryRegion();
};
/
// OLEFormat wrapper class


class OLEFormat : public COleDispatchDriver
{
public:
OLEFormat() {} // Calls COleDispatchDriver default constructor
OLEFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
OLEFormat(const OLEFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetClassType();
void SetClassType(LPCTSTR lpszNewValue);
BOOL GetDisplayAsIcon();
void SetDisplayAsIcon(BOOL bNewValue);
CString GetIconName();
void SetIconName(LPCTSTR lpszNewValue);
CString GetIconPath();
long GetIconIndex();
void SetIconIndex(long nNewValue);
CString GetIconLabel();
void SetIconLabel(LPCTSTR lpszNewValue);
CString GetLabel();
LPDISPATCH GetObject();
CString GetProgID();
void Activate();
void Edit();
void Open();
void DoVerb(VARIANT* VerbIndex);
void ConvertTo(VARIANT* ClassType, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel);
void ActivateAs(LPCTSTR ClassType);
BOOL GetPreserveFormattingOnUpdate();
void SetPreserveFormattingOnUpdate(BOOL bNewValue);
};
/
// LinkFormat wrapper class


class LinkFormat : public COleDispatchDriver
{
public:
LinkFormat() {} // Calls COleDispatchDriver default constructor
LinkFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
LinkFormat(const LinkFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetAutoUpdate();
void SetAutoUpdate(BOOL bNewValue);
CString GetSourceName();
CString GetSourcePath();
BOOL GetLocked();
void SetLocked(BOOL bNewValue);
long GetType();
CString GetSourceFullName();
void SetSourceFullName(LPCTSTR lpszNewValue);
BOOL GetSavePictureWithDocument();
void SetSavePictureWithDocument(BOOL bNewValue);
void BreakLink();
void Update();
};
/
// _OLEControl wrapper class


class _OLEControl : public COleDispatchDriver
{
public:
_OLEControl() {} // Calls COleDispatchDriver default constructor
_OLEControl(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_OLEControl(const _OLEControl& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
float GetLeft();
void SetLeft(float newValue);
float GetTop();
void SetTop(float newValue);
float GetHeight();
void SetHeight(float newValue);
float GetWidth();
void SetWidth(float newValue);
CString GetName();
void SetName(LPCTSTR lpszNewValue);
LPDISPATCH GetAutomation();
void Select();
void Copy();
void Cut();
void Delete();
void Activate();
};
/
// Fields wrapper class


class Fields : public COleDispatchDriver
{
public:
Fields() {} // Calls COleDispatchDriver default constructor
Fields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Fields(const Fields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
long GetLocked();
void SetLocked(long nNewValue);
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(long Index);
void ToggleShowCodes();
long Update();
void Unlink();
void UpdateSource();
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Type, VARIANT* Text, VARIANT* PreserveFormatting);
};
/
// Field wrapper class


class Field : public COleDispatchDriver
{
public:
Field() {} // Calls COleDispatchDriver default constructor
Field(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Field(const Field& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetCode();
void SetCode(LPDISPATCH newValue);
long GetType();
BOOL GetLocked();
void SetLocked(BOOL bNewValue);
long GetKind();
LPDISPATCH GetResult();
void SetResult(LPDISPATCH newValue);
CString GetData();
void SetData(LPCTSTR lpszNewValue);
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
long GetIndex();
BOOL GetShowCodes();
void SetShowCodes(BOOL bNewValue);
LPDISPATCH GetLinkFormat();
LPDISPATCH GetOLEFormat();
LPDISPATCH GetInlineShape();
void Select();
BOOL Update();
void Unlink();
void UpdateSource();
void DoClick();
void Copy();
void Cut();
void Delete();
};
/
// Browser wrapper class


class Browser : public COleDispatchDriver
{
public:
Browser() {} // Calls COleDispatchDriver default constructor
Browser(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Browser(const Browser& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetTarget();
void SetTarget(long nNewValue);
void Next();
void Previous();
};
/
// Styles wrapper class


class Styles : public COleDispatchDriver
{
public:
Styles() {} // Calls COleDispatchDriver default constructor
Styles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Styles(const Styles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* Type);
};
/
// Style wrapper class


class Style : public COleDispatchDriver
{
public:
Style() {} // Calls COleDispatchDriver default constructor
Style(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Style(const Style& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetNameLocal();
void SetNameLocal(LPCTSTR lpszNewValue);
VARIANT GetBaseStyle();
void SetBaseStyle(VARIANT* newValue);
CString GetDescription();
long GetType();
BOOL GetBuiltIn();
VARIANT GetNextParagraphStyle();
void SetNextParagraphStyle(VARIANT* newValue);
BOOL GetInUse();
LPDISPATCH GetShading();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
LPDISPATCH GetFrame();
long GetLanguageID();
void SetLanguageID(long nNewValue);
BOOL GetAutomaticallyUpdate();
void SetAutomaticallyUpdate(BOOL bNewValue);
LPDISPATCH GetListTemplate();
long GetListLevelNumber();
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
void Delete();
void LinkToListTemplate(LPDISPATCH ListTemplate, VARIANT* ListLevelNumber);
long GetNoProofing();
void SetNoProofing(long nNewValue);
VARIANT GetLinkStyle();
void SetLinkStyle(VARIANT* newValue);
BOOL GetNoSpaceBetweenParagraphsOfSameStyle();
void SetNoSpaceBetweenParagraphsOfSameStyle(BOOL bNewValue);
LPDISPATCH GetTable();
BOOL GetLocked();
void SetLocked(BOOL bNewValue);
};
/
// Frames wrapper class


class Frames : public COleDispatchDriver
{
public:
Frames() {} // Calls COleDispatchDriver default constructor
Frames(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Frames(const Frames& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range);
void Delete();
};
/
// Frame wrapper class


class Frame : public COleDispatchDriver
{
public:
Frame() {} // Calls COleDispatchDriver default constructor
Frame(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Frame(const Frame& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetHeightRule();
void SetHeightRule(long nNewValue);
long GetWidthRule();
void SetWidthRule(long nNewValue);
float GetHorizontalDistanceFromText();
void SetHorizontalDistanceFromText(float newValue);
float GetHeight();
void SetHeight(float newValue);
float GetHorizontalPosition();
void SetHorizontalPosition(float newValue);
BOOL GetLockAnchor();
void SetLockAnchor(BOOL bNewValue);
long GetRelativeHorizontalPosition();
void SetRelativeHorizontalPosition(long nNewValue);
long GetRelativeVerticalPosition();
void SetRelativeVerticalPosition(long nNewValue);
float GetVerticalDistanceFromText();
void SetVerticalDistanceFromText(float newValue);
float GetVerticalPosition();
void SetVerticalPosition(float newValue);
float GetWidth();
void SetWidth(float newValue);
BOOL GetTextWrap();
void SetTextWrap(BOOL bNewValue);
LPDISPATCH GetShading();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetRange();
void Delete();
void Select();
void Copy();
void Cut();
};
/
// FormFields wrapper class


class FormFields : public COleDispatchDriver
{
public:
FormFields() {} // Calls COleDispatchDriver default constructor
FormFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FormFields(const FormFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
BOOL GetShaded();
void SetShaded(BOOL bNewValue);
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPDISPATCH Range, long Type);
};
/
// FormField wrapper class


class FormField : public COleDispatchDriver
{
public:
FormField() {} // Calls COleDispatchDriver default constructor
FormField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FormField(const FormField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetType();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
CString GetEntryMacro();
void SetEntryMacro(LPCTSTR lpszNewValue);
CString GetExitMacro();
void SetExitMacro(LPCTSTR lpszNewValue);
BOOL GetOwnHelp();
void SetOwnHelp(BOOL bNewValue);
BOOL GetOwnStatus();
void SetOwnStatus(BOOL bNewValue);
CString GetHelpText();
void SetHelpText(LPCTSTR lpszNewValue);
CString GetStatusText();
void SetStatusText(LPCTSTR lpszNewValue);
BOOL GetEnabled();
void SetEnabled(BOOL bNewValue);
CString GetResult();
void SetResult(LPCTSTR lpszNewValue);
LPDISPATCH GetTextInput();
LPDISPATCH GetCheckBox();
LPDISPATCH GetDropDown();
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
BOOL GetCalculateOnExit();
void SetCalculateOnExit(BOOL bNewValue);
LPDISPATCH GetRange();
void Select();
void Copy();
void Cut();
void Delete();
};
/
// TextInput wrapper class


class TextInput : public COleDispatchDriver
{
public:
TextInput() {} // Calls COleDispatchDriver default constructor
TextInput(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextInput(const TextInput& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetValid();
CString GetDefault();
void SetDefault(LPCTSTR lpszNewValue);
long GetType();
CString GetFormat();
long GetWidth();
void SetWidth(long nNewValue);
void Clear();
void EditType(long Type, VARIANT* Default, VARIANT* Format, VARIANT* Enabled);
};
/
// CheckBox wrapper class


class CheckBox : public COleDispatchDriver
{
public:
CheckBox() {} // Calls COleDispatchDriver default constructor
CheckBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CheckBox(const CheckBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetValid();
BOOL GetAutoSize();
void SetAutoSize(BOOL bNewValue);
float GetSize();
void SetSize(float newValue);
BOOL GetDefault();
void SetDefault(BOOL bNewValue);
BOOL GetValue();
void SetValue(BOOL bNewValue);
};
/
// DropDown wrapper class


class DropDown : public COleDispatchDriver
{
public:
DropDown() {} // Calls COleDispatchDriver default constructor
DropDown(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DropDown(const DropDown& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetValid();
long GetDefault();
void SetDefault(long nNewValue);
long GetValue();
void SetValue(long nNewValue);
LPDISPATCH GetListEntries();
};
/
// ListEntries wrapper class


class ListEntries : public COleDispatchDriver
{
public:
ListEntries() {} // Calls COleDispatchDriver default constructor
ListEntries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListEntries(const ListEntries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* Index);
void Clear();
};
/
// ListEntry wrapper class


class ListEntry : public COleDispatchDriver
{
public:
ListEntry() {} // Calls COleDispatchDriver default constructor
ListEntry(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListEntry(const ListEntry& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
void Delete();
};
/
// TablesOfFigures wrapper class


class TablesOfFigures : public COleDispatchDriver
{
public:
TablesOfFigures() {} // Calls COleDispatchDriver default constructor
TablesOfFigures(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TablesOfFigures(const TablesOfFigures& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetFormat();
void SetFormat(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* TableID, VARIANT* Level);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Caption, VARIANT* IncludeLabel, VARIANT* UseHeadingStyles, VARIANT* UpperHeadingLevel, VARIANT* LowerHeadingLevel, VARIANT* UseFields, VARIANT* TableID, VARIANT* RightAlignPageNumbers, 
VARIANT* IncludePageNumbers, VARIANT* AddedStyles, VARIANT* UseHyperlinks, VARIANT* HidePageNumbersInWeb);
};
/
// TableOfFigures wrapper class


class TableOfFigures : public COleDispatchDriver
{
public:
TableOfFigures() {} // Calls COleDispatchDriver default constructor
TableOfFigures(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TableOfFigures(const TableOfFigures& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetCaption();
void SetCaption(LPCTSTR lpszNewValue);
BOOL GetIncludeLabel();
void SetIncludeLabel(BOOL bNewValue);
BOOL GetRightAlignPageNumbers();
void SetRightAlignPageNumbers(BOOL bNewValue);
BOOL GetUseHeadingStyles();
void SetUseHeadingStyles(BOOL bNewValue);
long GetLowerHeadingLevel();
void SetLowerHeadingLevel(long nNewValue);
long GetUpperHeadingLevel();
void SetUpperHeadingLevel(long nNewValue);
BOOL GetIncludePageNumbers();
void SetIncludePageNumbers(BOOL bNewValue);
LPDISPATCH GetRange();
BOOL GetUseFields();
void SetUseFields(BOOL bNewValue);
CString GetTableID();
void SetTableID(LPCTSTR lpszNewValue);
LPDISPATCH GetHeadingStyles();
long GetTabLeader();
void SetTabLeader(long nNewValue);
void Delete();
void UpdatePageNumbers();
void Update();
BOOL GetUseHyperlinks();
void SetUseHyperlinks(BOOL bNewValue);
BOOL GetHidePageNumbersInWeb();
void SetHidePageNumbersInWeb(BOOL bNewValue);
};
/
// MailMerge wrapper class


class MailMerge : public COleDispatchDriver
{
public:
MailMerge() {} // Calls COleDispatchDriver default constructor
MailMerge(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMerge(const MailMerge& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetMainDocumentType();
void SetMainDocumentType(long nNewValue);
long GetState();
long GetDestination();
void SetDestination(long nNewValue);
LPDISPATCH GetDataSource();
LPDISPATCH GetFields();
long GetViewMailMergeFieldCodes();
void SetViewMailMergeFieldCodes(long nNewValue);
BOOL GetSuppressBlankLines();
void SetSuppressBlankLines(BOOL bNewValue);
BOOL GetMailAsAttachment();
void SetMailAsAttachment(BOOL bNewValue);
CString GetMailAddressFieldName();
void SetMailAddressFieldName(LPCTSTR lpszNewValue);
CString GetMailSubject();
void SetMailSubject(LPCTSTR lpszNewValue);
void CreateDataSource(VARIANT* Name, VARIANT* PasswordDocument, VARIANT* WritePasswordDocument, VARIANT* HeaderRecord, VARIANT* MSQuery, VARIANT* SQLStatement, VARIANT* SQLStatement1, VARIANT* Connection, VARIANT* LinkToSource);
void CreateHeaderSource(LPCTSTR Name, VARIANT* PasswordDocument, VARIANT* WritePasswordDocument, VARIANT* HeaderRecord);
void Execute(VARIANT* Pause);
void Check();
void EditDataSource();
void EditHeaderSource();
void EditMainDocument();
BOOL GetHighlightMergeFields();
void SetHighlightMergeFields(BOOL bNewValue);
long GetMailFormat();
void SetMailFormat(long nNewValue);
CString GetShowSendToCustom();
void SetShowSendToCustom(LPCTSTR lpszNewValue);
long GetWizardState();
void SetWizardState(long nNewValue);
void OpenDataSource(LPCTSTR Name, VARIANT* Format, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* LinkToSource, VARIANT* AddToRecentFiles, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, 
VARIANT* WritePasswordDocument, VARIANT* WritePasswordTemplate, VARIANT* Connection, VARIANT* SQLStatement, VARIANT* SQLStatement1, VARIANT* OpenExclusive, VARIANT* SubType);
void OpenHeaderSource(LPCTSTR Name, VARIANT* Format, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* AddToRecentFiles, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, VARIANT* WritePasswordDocument, 
VARIANT* WritePasswordTemplate, VARIANT* OpenExclusive);
void ShowWizard(VARIANT* InitialState, VARIANT* ShowDocumentStep, VARIANT* ShowTemplateStep, VARIANT* ShowDataStep, VARIANT* ShowWriteStep, VARIANT* ShowPreviewStep, VARIANT* ShowMergeStep);
};
/
// MailMergeFields wrapper class


class MailMergeFields : public COleDispatchDriver
{
public:
MailMergeFields() {} // Calls COleDispatchDriver default constructor
MailMergeFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeFields(const MailMergeFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, LPCTSTR Name);
LPDISPATCH AddAsk(LPDISPATCH Range, LPCTSTR Name, VARIANT* Prompt, VARIANT* DefaultAskText, VARIANT* AskOnce);
LPDISPATCH AddFillIn(LPDISPATCH Range, VARIANT* Prompt, VARIANT* DefaultFillInText, VARIANT* AskOnce);
LPDISPATCH AddIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo, VARIANT* TrueAutoText, VARIANT* TrueText, VARIANT* FalseAutoText, VARIANT* FalseText);
LPDISPATCH AddMergeRec(LPDISPATCH Range);
LPDISPATCH AddMergeSeq(LPDISPATCH Range);
LPDISPATCH AddNext(LPDISPATCH Range);
LPDISPATCH AddNextIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo);
LPDISPATCH AddSet(LPDISPATCH Range, LPCTSTR Name, VARIANT* ValueText, VARIANT* ValueAutoText);
LPDISPATCH AddSkipIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo);
};
/
// MailMergeField wrapper class


class MailMergeField : public COleDispatchDriver
{
public:
MailMergeField() {} // Calls COleDispatchDriver default constructor
MailMergeField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeField(const MailMergeField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetType();
BOOL GetLocked();
void SetLocked(BOOL bNewValue);
LPDISPATCH GetCode();
void SetCode(LPDISPATCH newValue);
LPDISPATCH GetNext();
LPDISPATCH GetPrevious();
void Select();
void Copy();
void Cut();
void Delete();
};
/
// MailMergeDataSource wrapper class


class MailMergeDataSource : public COleDispatchDriver
{
public:
MailMergeDataSource() {} // Calls COleDispatchDriver default constructor
MailMergeDataSource(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeDataSource(const MailMergeDataSource& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
CString GetHeaderSourceName();
long GetType();
long GetHeaderSourceType();
CString GetConnectString();
CString GetQueryString();
void SetQueryString(LPCTSTR lpszNewValue);
long GetActiveRecord();
void SetActiveRecord(long nNewValue);
long GetFirstRecord();
void SetFirstRecord(long nNewValue);
long GetLastRecord();
void SetLastRecord(long nNewValue);
LPDISPATCH GetFieldNames();
LPDISPATCH GetDataFields();
long GetRecordCount();
BOOL GetIncluded();
void SetIncluded(BOOL bNewValue);
BOOL GetInvalidAddress();
void SetInvalidAddress(BOOL bNewValue);
CString GetInvalidComments();
void SetInvalidComments(LPCTSTR lpszNewValue);
LPDISPATCH GetMappedDataFields();
CString GetTableName();
BOOL FindRecord(LPCTSTR FindText, VARIANT* Field);
void SetAllIncludedFlags(BOOL Included);
void SetAllErrorFlags(BOOL Invalid, LPCTSTR InvalidComment);
void Close();
};
/
// MailMergeFieldNames wrapper class


class MailMergeFieldNames : public COleDispatchDriver
{
public:
MailMergeFieldNames() {} // Calls COleDispatchDriver default constructor
MailMergeFieldNames(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeFieldNames(const MailMergeFieldNames& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
};
/
// MailMergeFieldName wrapper class


class MailMergeFieldName : public COleDispatchDriver
{
public:
MailMergeFieldName() {} // Calls COleDispatchDriver default constructor
MailMergeFieldName(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeFieldName(const MailMergeFieldName& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
long GetIndex();
};
/
// MailMergeDataFields wrapper class


class MailMergeDataFields : public COleDispatchDriver
{
public:
MailMergeDataFields() {} // Calls COleDispatchDriver default constructor
MailMergeDataFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeDataFields(const MailMergeDataFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
};
/
// MailMergeDataField wrapper class


class MailMergeDataField : public COleDispatchDriver
{
public:
MailMergeDataField() {} // Calls COleDispatchDriver default constructor
MailMergeDataField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMergeDataField(const MailMergeDataField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetValue();
CString GetName();
long GetIndex();
};
/
// Envelope wrapper class


class Envelope : public COleDispatchDriver
{
public:
Envelope() {} // Calls COleDispatchDriver default constructor
Envelope(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Envelope(const Envelope& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetAddress();
LPDISPATCH GetReturnAddress();
BOOL GetDefaultPrintBarCode();
void SetDefaultPrintBarCode(BOOL bNewValue);
BOOL GetDefaultPrintFIMA();
void SetDefaultPrintFIMA(BOOL bNewValue);
float GetDefaultHeight();
void SetDefaultHeight(float newValue);
float GetDefaultWidth();
void SetDefaultWidth(float newValue);
CString GetDefaultSize();
void SetDefaultSize(LPCTSTR lpszNewValue);
BOOL GetDefaultOmitReturnAddress();
void SetDefaultOmitReturnAddress(BOOL bNewValue);
long GetFeedSource();
void SetFeedSource(long nNewValue);
float GetAddressFromLeft();
void SetAddressFromLeft(float newValue);
float GetAddressFromTop();
void SetAddressFromTop(float newValue);
float GetReturnAddressFromLeft();
void SetReturnAddressFromLeft(float newValue);
float GetReturnAddressFromTop();
void SetReturnAddressFromTop(float newValue);
LPDISPATCH GetAddressStyle();
LPDISPATCH GetReturnAddressStyle();
long GetDefaultOrientation();
void SetDefaultOrientation(long nNewValue);
BOOL GetDefaultFaceUp();
void SetDefaultFaceUp(BOOL bNewValue);
void UpdateDocument();
void Options();
BOOL GetVertical();
void SetVertical(BOOL bNewValue);
float GetRecipientNamefromLeft();
void SetRecipientNamefromLeft(float newValue);
float GetRecipientNamefromTop();
void SetRecipientNamefromTop(float newValue);
float GetRecipientPostalfromLeft();
void SetRecipientPostalfromLeft(float newValue);
float GetRecipientPostalfromTop();
void SetRecipientPostalfromTop(float newValue);
float GetSenderNamefromLeft();
void SetSenderNamefromLeft(float newValue);
float GetSenderNamefromTop();
void SetSenderNamefromTop(float newValue);
float GetSenderPostalfromLeft();
void SetSenderPostalfromLeft(float newValue);
float GetSenderPostalfromTop();
void SetSenderPostalfromTop(float newValue);
void Insert(VARIANT* ExtractAddress, VARIANT* Address, VARIANT* AutoText, VARIANT* OmitReturnAddress, VARIANT* ReturnAddress, VARIANT* ReturnAutoText, VARIANT* PrintBarCode, VARIANT* PrintFIMA, VARIANT* Size, VARIANT* Height, VARIANT* Width, 
VARIANT* FeedSource, VARIANT* AddressFromLeft, VARIANT* AddressFromTop, VARIANT* ReturnAddressFromLeft, VARIANT* ReturnAddressFromTop, VARIANT* DefaultFaceUp, VARIANT* DefaultOrientation, VARIANT* PrintEPostage, VARIANT* Vertical, 
VARIANT* RecipientNamefromLeft, VARIANT* RecipientNamefromTop, VARIANT* RecipientPostalfromLeft, VARIANT* RecipientPostalfromTop, VARIANT* SenderNamefromLeft, VARIANT* SenderNamefromTop, VARIANT* SenderPostalfromLeft, 
VARIANT* SenderPostalfromTop);
void PrintOut(VARIANT* ExtractAddress, VARIANT* Address, VARIANT* AutoText, VARIANT* OmitReturnAddress, VARIANT* ReturnAddress, VARIANT* ReturnAutoText, VARIANT* PrintBarCode, VARIANT* PrintFIMA, VARIANT* Size, VARIANT* Height, 
VARIANT* Width, VARIANT* FeedSource, VARIANT* AddressFromLeft, VARIANT* AddressFromTop, VARIANT* ReturnAddressFromLeft, VARIANT* ReturnAddressFromTop, VARIANT* DefaultFaceUp, VARIANT* DefaultOrientation, VARIANT* PrintEPostage, 
VARIANT* Vertical, VARIANT* RecipientNamefromLeft, VARIANT* RecipientNamefromTop, VARIANT* RecipientPostalfromLeft, VARIANT* RecipientPostalfromTop, VARIANT* SenderNamefromLeft, VARIANT* SenderNamefromTop, VARIANT* SenderPostalfromLeft, 
VARIANT* SenderPostalfromTop);
};
/
// MailingLabel wrapper class


class MailingLabel : public COleDispatchDriver
{
public:
MailingLabel() {} // Calls COleDispatchDriver default constructor
MailingLabel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailingLabel(const MailingLabel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetDefaultPrintBarCode();
void SetDefaultPrintBarCode(BOOL bNewValue);
long GetDefaultLaserTray();
void SetDefaultLaserTray(long nNewValue);
LPDISPATCH GetCustomLabels();
CString GetDefaultLabelName();
void SetDefaultLabelName(LPCTSTR lpszNewValue);
void LabelOptions();
LPDISPATCH CreateNewDocument(VARIANT* Name, VARIANT* Address, VARIANT* AutoText, VARIANT* ExtractAddress, VARIANT* LaserTray, VARIANT* PrintEPostageLabel, VARIANT* Vertical);
void PrintOut(VARIANT* Name, VARIANT* Address, VARIANT* ExtractAddress, VARIANT* LaserTray, VARIANT* SingleLabel, VARIANT* Row, VARIANT* Column, VARIANT* PrintEPostageLabel, VARIANT* Vertical);
BOOL GetVertical();
void SetVertical(BOOL bNewValue);
};
/
// CustomLabels wrapper class


class CustomLabels : public COleDispatchDriver
{
public:
CustomLabels() {} // Calls COleDispatchDriver default constructor
CustomLabels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CustomLabels(const CustomLabels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* DotMatrix);
};
/
// CustomLabel wrapper class


class CustomLabel : public COleDispatchDriver
{
public:
CustomLabel() {} // Calls COleDispatchDriver default constructor
CustomLabel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CustomLabel(const CustomLabel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
float GetTopMargin();
void SetTopMargin(float newValue);
float GetSideMargin();
void SetSideMargin(float newValue);
float GetHeight();
void SetHeight(float newValue);
float GetWidth();
void SetWidth(float newValue);
float GetVerticalPitch();
void SetVerticalPitch(float newValue);
float GetHorizontalPitch();
void SetHorizontalPitch(float newValue);
long GetNumberAcross();
void SetNumberAcross(long nNewValue);
long GetNumberDown();
void SetNumberDown(long nNewValue);
BOOL GetDotMatrix();
long GetPageSize();
void SetPageSize(long nNewValue);
BOOL GetValid();
void Delete();
};
/
// TablesOfContents wrapper class


class TablesOfContents : public COleDispatchDriver
{
public:
TablesOfContents() {} // Calls COleDispatchDriver default constructor
TablesOfContents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TablesOfContents(const TablesOfContents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetFormat();
void SetFormat(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* TableID, VARIANT* Level);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* UseHeadingStyles, VARIANT* UpperHeadingLevel, VARIANT* LowerHeadingLevel, VARIANT* UseFields, VARIANT* TableID, VARIANT* RightAlignPageNumbers, VARIANT* IncludePageNumbers, VARIANT* AddedStyles, 
VARIANT* UseHyperlinks, VARIANT* HidePageNumbersInWeb, VARIANT* UseOutlineLevels);
};
/
// TableOfContents wrapper class


class TableOfContents : public COleDispatchDriver
{
public:
TableOfContents() {} // Calls COleDispatchDriver default constructor
TableOfContents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TableOfContents(const TableOfContents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetUseHeadingStyles();
void SetUseHeadingStyles(BOOL bNewValue);
BOOL GetUseFields();
void SetUseFields(BOOL bNewValue);
long GetUpperHeadingLevel();
void SetUpperHeadingLevel(long nNewValue);
long GetLowerHeadingLevel();
void SetLowerHeadingLevel(long nNewValue);
CString GetTableID();
void SetTableID(LPCTSTR lpszNewValue);
LPDISPATCH GetHeadingStyles();
BOOL GetRightAlignPageNumbers();
void SetRightAlignPageNumbers(BOOL bNewValue);
BOOL GetIncludePageNumbers();
void SetIncludePageNumbers(BOOL bNewValue);
LPDISPATCH GetRange();
long GetTabLeader();
void SetTabLeader(long nNewValue);
void Delete();
void UpdatePageNumbers();
void Update();
BOOL GetUseHyperlinks();
void SetUseHyperlinks(BOOL bNewValue);
BOOL GetHidePageNumbersInWeb();
void SetHidePageNumbersInWeb(BOOL bNewValue);
};
/
// TablesOfAuthorities wrapper class


class TablesOfAuthorities : public COleDispatchDriver
{
public:
TablesOfAuthorities() {} // Calls COleDispatchDriver default constructor
TablesOfAuthorities(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TablesOfAuthorities(const TablesOfAuthorities& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetFormat();
void SetFormat(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* Category, VARIANT* Bookmark, VARIANT* Passim, VARIANT* KeepEntryFormatting, VARIANT* Separator, VARIANT* IncludeSequenceName, VARIANT* EntrySeparator, VARIANT* PageRangeSeparator, 
VARIANT* IncludeCategoryHeader, VARIANT* PageNumberSeparator);
void NextCitation(LPCTSTR ShortCitation);
LPDISPATCH MarkCitation(LPDISPATCH Range, LPCTSTR ShortCitation, VARIANT* LongCitation, VARIANT* LongCitationAutoText, VARIANT* Category);
void MarkAllCitations(LPCTSTR ShortCitation, VARIANT* LongCitation, VARIANT* LongCitationAutoText, VARIANT* Category);
};
/
// TableOfAuthorities wrapper class


class TableOfAuthorities : public COleDispatchDriver
{
public:
TableOfAuthorities() {} // Calls COleDispatchDriver default constructor
TableOfAuthorities(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TableOfAuthorities(const TableOfAuthorities& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetPassim();
void SetPassim(BOOL bNewValue);
BOOL GetKeepEntryFormatting();
void SetKeepEntryFormatting(BOOL bNewValue);
long GetCategory();
void SetCategory(long nNewValue);
CString GetBookmark();
void SetBookmark(LPCTSTR lpszNewValue);
CString GetSeparator();
void SetSeparator(LPCTSTR lpszNewValue);
CString GetIncludeSequenceName();
void SetIncludeSequenceName(LPCTSTR lpszNewValue);
CString GetEntrySeparator();
void SetEntrySeparator(LPCTSTR lpszNewValue);
CString GetPageRangeSeparator();
void SetPageRangeSeparator(LPCTSTR lpszNewValue);
BOOL GetIncludeCategoryHeader();
void SetIncludeCategoryHeader(BOOL bNewValue);
CString GetPageNumberSeparator();
void SetPageNumberSeparator(LPCTSTR lpszNewValue);
LPDISPATCH GetRange();
long GetTabLeader();
void SetTabLeader(long nNewValue);
void Delete();
void Update();
};
/
// Dialogs wrapper class


class Dialogs : public COleDispatchDriver
{
public:
Dialogs() {} // Calls COleDispatchDriver default constructor
Dialogs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Dialogs(const Dialogs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
};
/
// Dialog wrapper class


class Dialog : public COleDispatchDriver
{
public:
Dialog() {} // Calls COleDispatchDriver default constructor
Dialog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Dialog(const Dialog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetDefaultTab();
void SetDefaultTab(long nNewValue);
long GetType();
long Show(VARIANT* TimeOut);
long Display(VARIANT* TimeOut);
void Execute();
void Update();
CString GetCommandName();
};
/
// PageSetup wrapper class


class PageSetup : public COleDispatchDriver
{
public:
PageSetup() {} // Calls COleDispatchDriver default constructor
PageSetup(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
PageSetup(const PageSetup& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetTopMargin();
void SetTopMargin(float newValue);
float GetBottomMargin();
void SetBottomMargin(float newValue);
float GetLeftMargin();
void SetLeftMargin(float newValue);
float GetRightMargin();
void SetRightMargin(float newValue);
float GetGutter();
void SetGutter(float newValue);
float GetPageWidth();
void SetPageWidth(float newValue);
float GetPageHeight();
void SetPageHeight(float newValue);
long GetOrientation();
void SetOrientation(long nNewValue);
long GetFirstPageTray();
void SetFirstPageTray(long nNewValue);
long GetOtherPagesTray();
void SetOtherPagesTray(long nNewValue);
long GetVerticalAlignment();
void SetVerticalAlignment(long nNewValue);
long GetMirrorMargins();
void SetMirrorMargins(long nNewValue);
float GetHeaderDistance();
void SetHeaderDistance(float newValue);
float GetFooterDistance();
void SetFooterDistance(float newValue);
long GetSectionStart();
void SetSectionStart(long nNewValue);
long GetOddAndEvenPagesHeaderFooter();
void SetOddAndEvenPagesHeaderFooter(long nNewValue);
long GetDifferentFirstPageHeaderFooter();
void SetDifferentFirstPageHeaderFooter(long nNewValue);
long GetSuppressEndnotes();
void SetSuppressEndnotes(long nNewValue);
LPDISPATCH GetLineNumbering();
void SetLineNumbering(LPDISPATCH newValue);
LPDISPATCH GetTextColumns();
void SetTextColumns(LPDISPATCH newValue);
long GetPaperSize();
void SetPaperSize(long nNewValue);
BOOL GetTwoPagesOnOne();
void SetTwoPagesOnOne(BOOL bNewValue);
float GetCharsLine();
void SetCharsLine(float newValue);
float GetLinesPage();
void SetLinesPage(float newValue);
BOOL GetShowGrid();
void SetShowGrid(BOOL bNewValue);
void TogglePortrait();
void SetAsTemplateDefault();
long GetGutterStyle();
void SetGutterStyle(long nNewValue);
long GetSectionDirection();
void SetSectionDirection(long nNewValue);
long GetLayoutMode();
void SetLayoutMode(long nNewValue);
long GetGutterPos();
void SetGutterPos(long nNewValue);
BOOL GetBookFoldPrinting();
void SetBookFoldPrinting(BOOL bNewValue);
BOOL GetBookFoldRevPrinting();
void SetBookFoldRevPrinting(BOOL bNewValue);
long GetBookFoldPrintingSheets();
void SetBookFoldPrintingSheets(long nNewValue);
};
/
// LineNumbering wrapper class


class LineNumbering : public COleDispatchDriver
{
public:
LineNumbering() {} // Calls COleDispatchDriver default constructor
LineNumbering(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
LineNumbering(const LineNumbering& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetRestartMode();
void SetRestartMode(long nNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
float GetDistanceFromText();
void SetDistanceFromText(float newValue);
long GetCountBy();
void SetCountBy(long nNewValue);
long GetActive();
void SetActive(long nNewValue);
};
/
// TextColumns wrapper class


class TextColumns : public COleDispatchDriver
{
public:
TextColumns() {} // Calls COleDispatchDriver default constructor
TextColumns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextColumns(const TextColumns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetEvenlySpaced();
void SetEvenlySpaced(long nNewValue);
long GetLineBetween();
void SetLineBetween(long nNewValue);
float GetWidth();
void SetWidth(float newValue);
float GetSpacing();
void SetSpacing(float newValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* Width, VARIANT* Spacing, VARIANT* EvenlySpaced);
void SetCount(long NumColumns);
long GetFlowDirection();
void SetFlowDirection(long nNewValue);
};
/
// TextColumn wrapper class


class TextColumn : public COleDispatchDriver
{
public:
TextColumn() {} // Calls COleDispatchDriver default constructor
TextColumn(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextColumn(const TextColumn& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetWidth();
void SetWidth(float newValue);
float GetSpaceAfter();
void SetSpaceAfter(float newValue);
};
/
// Selection wrapper class


class Selection : public COleDispatchDriver
{
public:
Selection() {} // Calls COleDispatchDriver default constructor
Selection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Selection(const Selection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetText();
void SetText(LPCTSTR lpszNewValue);
LPDISPATCH GetFormattedText();
void SetFormattedText(LPDISPATCH newValue);
long GetStart();
void SetStart(long nNewValue);
long GetEnd();
void SetEnd(long nNewValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
long GetType();
long GetStoryType();
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
LPDISPATCH GetTables();
LPDISPATCH GetWords();
LPDISPATCH GetSentences();
LPDISPATCH GetCharacters();
LPDISPATCH GetFootnotes();
LPDISPATCH GetEndnotes();
LPDISPATCH GetComments();
LPDISPATCH GetCells();
LPDISPATCH GetSections();
LPDISPATCH GetParagraphs();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetShading();
LPDISPATCH GetFields();
LPDISPATCH GetFormFields();
LPDISPATCH GetFrames();
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
LPDISPATCH GetPageSetup();
void SetPageSetup(LPDISPATCH newValue);
LPDISPATCH GetBookmarks();
long GetStoryLength();
long GetLanguageID();
void SetLanguageID(long nNewValue);
long GetLanguageIDFarEast();
void SetLanguageIDFarEast(long nNewValue);
long GetLanguageIDOther();
void SetLanguageIDOther(long nNewValue);
LPDISPATCH GetHyperlinks();
LPDISPATCH GetColumns();
LPDISPATCH GetRows();
LPDISPATCH GetHeaderFooter();
BOOL GetIsEndOfRowMark();
long GetBookmarkID();
long GetPreviousBookmarkID();
LPDISPATCH GetFind();
LPDISPATCH GetRange();
VARIANT GetInformation(long Type);
long GetFlags();
void SetFlags(long nNewValue);
BOOL GetActive();
BOOL GetStartIsActive();
void SetStartIsActive(BOOL bNewValue);
BOOL GetIPAtEndOfLine();
BOOL GetExtendMode();
void SetExtendMode(BOOL bNewValue);
BOOL GetColumnSelectMode();
void SetColumnSelectMode(BOOL bNewValue);
long GetOrientation();
void SetOrientation(long nNewValue);
LPDISPATCH GetInlineShapes();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetDocument();
LPDISPATCH GetShapeRange();
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);
long Expand(VARIANT* Unit);
void InsertParagraph();
void InsertParagraphAfter();
void InsertSymbol(long CharacterNumber, VARIANT* Font, VARIANT* Unicode, VARIANT* Bias);
void CopyAsPicture();
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);
LPDISPATCH PreviousField();
LPDISPATCH NextField();
void InsertParagraphBefore();
void InsertCells(VARIANT* ShiftCells);
void Extend(VARIANT* Character);
void Shrink();
long MoveLeft(VARIANT* Unit, VARIANT* Count, VARIANT* Extend);
long MoveRight(VARIANT* Unit, VARIANT* Count, VARIANT* Extend);
long MoveUp(VARIANT* Unit, VARIANT* Count, VARIANT* Extend);
long MoveDown(VARIANT* Unit, VARIANT* Count, VARIANT* Extend);
long HomeKey(VARIANT* Unit, VARIANT* Extend);
long EndKey(VARIANT* Unit, VARIANT* Extend);
void EscapeKey();
void TypeText(LPCTSTR Text);
void CopyFormat();
void PasteFormat();
void TypeParagraph();
void TypeBackspace();
void NextSubdocument();
void PreviousSubdocument();
void SelectColumn();
void SelectCurrentFont();
void SelectCurrentAlignment();
void SelectCurrentSpacing();
void SelectCurrentIndent();
void SelectCurrentTabs();
void SelectCurrentColor();
void CreateTextbox();
void WholeStory();
void SelectRow();
void SplitTable();
void InsertRows(VARIANT* NumRows);
void InsertColumns();
void InsertFormula(VARIANT* Formula, VARIANT* NumberFormat);
LPDISPATCH NextRevision(VARIANT* Wrap);
LPDISPATCH PreviousRevision(VARIANT* Wrap);
void PasteAsNestedTable();
LPDISPATCH CreateAutoTextEntry(LPCTSTR Name, LPCTSTR StyleName);
void DetectLanguage();
void SelectCell();
void InsertRowsBelow(VARIANT* NumRows);
void InsertColumnsRight();
void InsertRowsAbove(VARIANT* NumRows);
void RtlRun();
void LtrRun();
void BoldRun();
void ItalicRun();
void RtlPara();
void LtrPara();
void InsertDateTime(VARIANT* DateTimeFormat, VARIANT* InsertAsField, VARIANT* InsertAsFullWidth, VARIANT* DateLanguage, VARIANT* CalendarType);
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);
long GetNoProofing();
void SetNoProofing(long nNewValue);
LPDISPATCH GetTopLevelTables();
BOOL GetLanguageDetected();
void SetLanguageDetected(BOOL bNewValue);
float GetFitTextWidth();
void SetFitTextWidth(float newValue);
void ClearFormatting();
void PasteAppendTable();
LPDISPATCH GetHTMLDivisions();
LPDISPATCH GetSmartTags();
LPDISPATCH GetChildShapeRange();
BOOL GetHasChildShapeRange();
LPDISPATCH GetFootnoteOptions();
LPDISPATCH GetEndnoteOptions();
void ToggleCharacterCode();
void PasteAndFormat(long Type);
void PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF);
void ShrinkDiscontiguousSelection();
void InsertStyleSeparator();
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, VARIANT* SubFieldNumber, 
VARIANT* SubFieldNumber2, VARIANT* SubFieldNumber3);
LPDISPATCH GetXMLNodes();
LPDISPATCH GetXMLParentNode();
LPDISPATCH GetEditors();
CString GetXml(BOOL DataOnly);
VARIANT GetEnhMetaFileBits();
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);
};
/
// TablesOfAuthoritiesCategories wrapper class


class TablesOfAuthoritiesCategories : public COleDispatchDriver
{
public:
TablesOfAuthoritiesCategories() {} // Calls COleDispatchDriver default constructor
TablesOfAuthoritiesCategories(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TablesOfAuthoritiesCategories(const TablesOfAuthoritiesCategories& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
};
/
// TableOfAuthoritiesCategory wrapper class


class TableOfAuthoritiesCategory : public COleDispatchDriver
{
public:
TableOfAuthoritiesCategory() {} // Calls COleDispatchDriver default constructor
TableOfAuthoritiesCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TableOfAuthoritiesCategory(const TableOfAuthoritiesCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
long GetIndex();
};
/
// CaptionLabels wrapper class


class CaptionLabels : public COleDispatchDriver
{
public:
CaptionLabels() {} // Calls COleDispatchDriver default constructor
CaptionLabels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CaptionLabels(const CaptionLabels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name);
};
/
// CaptionLabel wrapper class


class CaptionLabel : public COleDispatchDriver
{
public:
CaptionLabel() {} // Calls COleDispatchDriver default constructor
CaptionLabel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CaptionLabel(const CaptionLabel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
BOOL GetBuiltIn();
long GetId();
BOOL GetIncludeChapterNumber();
void SetIncludeChapterNumber(BOOL bNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
long GetChapterStyleLevel();
void SetChapterStyleLevel(long nNewValue);
long GetSeparator();
void SetSeparator(long nNewValue);
long GetPosition();
void SetPosition(long nNewValue);
void Delete();
};
/
// AutoCaptions wrapper class


class AutoCaptions : public COleDispatchDriver
{
public:
AutoCaptions() {} // Calls COleDispatchDriver default constructor
AutoCaptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoCaptions(const AutoCaptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
void CancelAutoInsert();
};
/
// AutoCaption wrapper class


class AutoCaption : public COleDispatchDriver
{
public:
AutoCaption() {} // Calls COleDispatchDriver default constructor
AutoCaption(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AutoCaption(const AutoCaption& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
BOOL GetAutoInsert();
void SetAutoInsert(BOOL bNewValue);
long GetIndex();
VARIANT GetCaptionLabel();
void SetCaptionLabel(VARIANT* newValue);
};
/
// Indexes wrapper class


class Indexes : public COleDispatchDriver
{
public:
Indexes() {} // Calls COleDispatchDriver default constructor
Indexes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Indexes(const Indexes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetFormat();
void SetFormat(long nNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* CrossReference, VARIANT* CrossReferenceAutoText, VARIANT* BookmarkName, VARIANT* Bold, VARIANT* Italic, VARIANT* Reading);
void MarkAllEntries(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* CrossReference, VARIANT* CrossReferenceAutoText, VARIANT* BookmarkName, VARIANT* Bold, VARIANT* Italic);
void AutoMarkEntries(LPCTSTR ConcordanceFileName);
LPDISPATCH Add(LPDISPATCH Range, VARIANT* HeadingSeparator, VARIANT* RightAlignPageNumbers, VARIANT* Type, VARIANT* NumberOfColumns, VARIANT* AccentedLetters, VARIANT* SortBy, VARIANT* IndexLanguage);
};
/
// Index wrapper class


class Index : public COleDispatchDriver
{
public:
Index() {} // Calls COleDispatchDriver default constructor
Index(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Index(const Index& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetHeadingSeparator();
void SetHeadingSeparator(long nNewValue);
BOOL GetRightAlignPageNumbers();
void SetRightAlignPageNumbers(BOOL bNewValue);
long GetType();
void SetType(long nNewValue);
long GetNumberOfColumns();
void SetNumberOfColumns(long nNewValue);
LPDISPATCH GetRange();
long GetTabLeader();
void SetTabLeader(long nNewValue);
BOOL GetAccentedLetters();
void SetAccentedLetters(BOOL bNewValue);
long GetSortBy();
void SetSortBy(long nNewValue);
long GetFilter();
void SetFilter(long nNewValue);
void Delete();
void Update();
long GetIndexLanguage();
void SetIndexLanguage(long nNewValue);
};
/
// AddIn wrapper class


class AddIn : public COleDispatchDriver
{
public:
AddIn() {} // Calls COleDispatchDriver default constructor
AddIn(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AddIn(const AddIn& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
long GetIndex();
CString GetPath();
BOOL GetInstalled();
void SetInstalled(BOOL bNewValue);
BOOL GetCompiled();
BOOL GetAutoload();
void Delete();
};
/
// AddIns wrapper class


class AddIns : public COleDispatchDriver
{
public:
AddIns() {} // Calls COleDispatchDriver default constructor
AddIns(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
AddIns(const AddIns& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR FileName, VARIANT* Install);
void Unload(BOOL RemoveFromList);
};
/
// Revisions wrapper class


class Revisions : public COleDispatchDriver
{
public:
Revisions() {} // Calls COleDispatchDriver default constructor
Revisions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Revisions(const Revisions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
void AcceptAll();
void RejectAll();
};
/
// Revision wrapper class


class Revision : public COleDispatchDriver
{
public:
Revision() {} // Calls COleDispatchDriver default constructor
Revision(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Revision(const Revision& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetAuthor();
DATE GetDate();
LPDISPATCH GetRange();
long GetType();
long GetIndex();
void Accept();
void Reject();
LPDISPATCH GetStyle();
CString GetFormatDescription();
};
/
// Task wrapper class


class Task : public COleDispatchDriver
{
public:
Task() {} // Calls COleDispatchDriver default constructor
Task(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Task(const Task& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
long GetLeft();
void SetLeft(long nNewValue);
long GetTop();
void SetTop(long nNewValue);
long GetWidth();
void SetWidth(long nNewValue);
long GetHeight();
void SetHeight(long nNewValue);
long GetWindowState();
void SetWindowState(long nNewValue);
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
void Activate(VARIANT* Wait);
void Close();
void Move(long Left, long Top);
void Resize(long Width, long Height);
void SendWindowMessage(long Message, long wParam, long lParam);
};
/
// Tasks wrapper class


class Tasks : public COleDispatchDriver
{
public:
Tasks() {} // Calls COleDispatchDriver default constructor
Tasks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Tasks(const Tasks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
BOOL Exists(LPCTSTR Name);
void ExitWindows_();
};
/
// HeadersFooters wrapper class


class HeadersFooters : public COleDispatchDriver
{
public:
HeadersFooters() {} // Calls COleDispatchDriver default constructor
HeadersFooters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HeadersFooters(const HeadersFooters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
};
/
// HeaderFooter wrapper class


class HeaderFooter : public COleDispatchDriver
{
public:
HeaderFooter() {} // Calls COleDispatchDriver default constructor
HeaderFooter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HeaderFooter(const HeaderFooter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
long GetIndex();
BOOL GetIsHeader();
BOOL GetExists();
void SetExists(BOOL bNewValue);
LPDISPATCH GetPageNumbers();
BOOL GetLinkToPrevious();
void SetLinkToPrevious(BOOL bNewValue);
LPDISPATCH GetShapes();
};
/
// PageNumbers wrapper class


class PageNumbers : public COleDispatchDriver
{
public:
PageNumbers() {} // Calls COleDispatchDriver default constructor
PageNumbers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
PageNumbers(const PageNumbers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
BOOL GetIncludeChapterNumber();
void SetIncludeChapterNumber(BOOL bNewValue);
long GetHeadingLevelForChapter();
void SetHeadingLevelForChapter(long nNewValue);
long GetChapterPageSeparator();
void SetChapterPageSeparator(long nNewValue);
BOOL GetRestartNumberingAtSection();
void SetRestartNumberingAtSection(BOOL bNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
BOOL GetShowFirstPageNumber();
void SetShowFirstPageNumber(BOOL bNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* PageNumberAlignment, VARIANT* FirstPage);
BOOL GetDoubleQuote();
void SetDoubleQuote(BOOL bNewValue);
};
/
// PageNumber wrapper class


class PageNumber : public COleDispatchDriver
{
public:
PageNumber() {} // Calls COleDispatchDriver default constructor
PageNumber(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
PageNumber(const PageNumber& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
long GetAlignment();
void SetAlignment(long nNewValue);
void Select();
void Copy();
void Cut();
void Delete();
};
/
// Subdocuments wrapper class


class Subdocuments : public COleDispatchDriver
{
public:
Subdocuments() {} // Calls COleDispatchDriver default constructor
Subdocuments(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Subdocuments(const Subdocuments& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
BOOL GetExpanded();
void SetExpanded(BOOL bNewValue);
LPDISPATCH Item(long Index);
LPDISPATCH AddFromFile(VARIANT* Name, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, VARIANT* WritePasswordDocument, VARIANT* WritePasswordTemplate);
LPDISPATCH AddFromRange(LPDISPATCH Range);
void Merge(VARIANT* FirstSubdocument, VARIANT* LastSubdocument);
void Delete();
void Select();
};
/
// Subdocument wrapper class


class Subdocument : public COleDispatchDriver
{
public:
Subdocument() {} // Calls COleDispatchDriver default constructor
Subdocument(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Subdocument(const Subdocument& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetLocked();
void SetLocked(BOOL bNewValue);
LPDISPATCH GetRange();
CString GetName();
CString GetPath();
BOOL GetHasFile();
long GetLevel();
void Delete();
void Split(LPDISPATCH Range);
LPDISPATCH Open();
};
/
// HeadingStyles wrapper class


class HeadingStyles : public COleDispatchDriver
{
public:
HeadingStyles() {} // Calls COleDispatchDriver default constructor
HeadingStyles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HeadingStyles(const HeadingStyles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(long Index);
LPDISPATCH Add(VARIANT* Style, short Level);
};
/
// HeadingStyle wrapper class


class HeadingStyle : public COleDispatchDriver
{
public:
HeadingStyle() {} // Calls COleDispatchDriver default constructor
HeadingStyle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HeadingStyle(const HeadingStyle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
VARIANT GetStyle();
void SetStyle(VARIANT* newValue);
short GetLevel();
void SetLevel(short nNewValue);
void Delete();
};
/
// StoryRanges wrapper class


class StoryRanges : public COleDispatchDriver
{
public:
StoryRanges() {} // Calls COleDispatchDriver default constructor
StoryRanges(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
StoryRanges(const StoryRanges& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// ListLevel wrapper class


class ListLevel : public COleDispatchDriver
{
public:
ListLevel() {} // Calls COleDispatchDriver default constructor
ListLevel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListLevel(const ListLevel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
long GetIndex();
CString GetNumberFormat();
void SetNumberFormat(LPCTSTR lpszNewValue);
long GetTrailingCharacter();
void SetTrailingCharacter(long nNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
float GetNumberPosition();
void SetNumberPosition(float newValue);
long GetAlignment();
void SetAlignment(long nNewValue);
float GetTextPosition();
void SetTextPosition(float newValue);
float GetTabPosition();
void SetTabPosition(float newValue);
long GetStartAt();
void SetStartAt(long nNewValue);
CString GetLinkedStyle();
void SetLinkedStyle(LPCTSTR lpszNewValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetResetOnHigher();
void SetResetOnHigher(long nNewValue);
LPDISPATCH GetPictureBullet();
LPDISPATCH ApplyPictureBullet(LPCTSTR FileName);
};
/
// ListLevels wrapper class


class ListLevels : public COleDispatchDriver
{
public:
ListLevels() {} // Calls COleDispatchDriver default constructor
ListLevels(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListLevels(const ListLevels& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// ListTemplate wrapper class


class ListTemplate : public COleDispatchDriver
{
public:
ListTemplate() {} // Calls COleDispatchDriver default constructor
ListTemplate(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListTemplate(const ListTemplate& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetOutlineNumbered();
void SetOutlineNumbered(BOOL bNewValue);
CString GetName();
void SetName(LPCTSTR lpszNewValue);
LPDISPATCH GetListLevels();
LPDISPATCH Convert(VARIANT* Level);
};
/
// ListTemplates wrapper class


class ListTemplates : public COleDispatchDriver
{
public:
ListTemplates() {} // Calls COleDispatchDriver default constructor
ListTemplates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListTemplates(const ListTemplates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(VARIANT* OutlineNumbered, VARIANT* Name);
};
/
// ListParagraphs wrapper class


class ListParagraphs : public COleDispatchDriver
{
public:
ListParagraphs() {} // Calls COleDispatchDriver default constructor
ListParagraphs(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListParagraphs(const ListParagraphs& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// List wrapper class


class List : public COleDispatchDriver
{
public:
List() {} // Calls COleDispatchDriver default constructor
List(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
List(const List& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetRange();
LPDISPATCH GetListParagraphs();
BOOL GetSingleListTemplate();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void ConvertNumbersToText(VARIANT* NumberType);
void RemoveNumbers(VARIANT* NumberType);
long CountNumberedItems(VARIANT* NumberType, VARIANT* Level);
long CanContinuePreviousList(LPDISPATCH ListTemplate);
void ApplyListTemplate(LPDISPATCH ListTemplate, VARIANT* ContinuePreviousList, VARIANT* DefaultListBehavior);
CString GetStyleName();
};
/
// Lists wrapper class


class Lists : public COleDispatchDriver
{
public:
Lists() {} // Calls COleDispatchDriver default constructor
Lists(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Lists(const Lists& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// ListGallery wrapper class


class ListGallery : public COleDispatchDriver
{
public:
ListGallery() {} // Calls COleDispatchDriver default constructor
ListGallery(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListGallery(const ListGallery& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetListTemplates();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetModified(long Index);
void Reset(long Index);
};
/
// ListGalleries wrapper class


class ListGalleries : public COleDispatchDriver
{
public:
ListGalleries() {} // Calls COleDispatchDriver default constructor
ListGalleries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ListGalleries(const ListGalleries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// KeyBindings wrapper class


class KeyBindings : public COleDispatchDriver
{
public:
KeyBindings() {} // Calls COleDispatchDriver default constructor
KeyBindings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
KeyBindings(const KeyBindings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetContext();
LPDISPATCH Item(long Index);
LPDISPATCH Add(long KeyCategory, LPCTSTR Command, long KeyCode, VARIANT* KeyCode2, VARIANT* CommandParameter);
void ClearAll();
LPDISPATCH Key(long KeyCode, VARIANT* KeyCode2);
};
/
// KeysBoundTo wrapper class


class KeysBoundTo : public COleDispatchDriver
{
public:
KeysBoundTo() {} // Calls COleDispatchDriver default constructor
KeysBoundTo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
KeysBoundTo(const KeysBoundTo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetKeyCategory();
CString GetCommand();
CString GetCommandParameter();
LPDISPATCH GetContext();
LPDISPATCH Item(long Index);
LPDISPATCH Key(long KeyCode, VARIANT* KeyCode2);
};
/
// KeyBinding wrapper class


class KeyBinding : public COleDispatchDriver
{
public:
KeyBinding() {} // Calls COleDispatchDriver default constructor
KeyBinding(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
KeyBinding(const KeyBinding& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetCommand();
CString GetKeyString();
BOOL GetProtected();
long GetKeyCategory();
long GetKeyCode();
long GetKeyCode2();
CString GetCommandParameter();
LPDISPATCH GetContext();
void Clear();
void Disable();
void Execute();
void Rebind(long KeyCategory, LPCTSTR Command, VARIANT* CommandParameter);
};
/
// FileConverter wrapper class


class FileConverter : public COleDispatchDriver
{
public:
FileConverter() {} // Calls COleDispatchDriver default constructor
FileConverter(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FileConverter(const FileConverter& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetFormatName();
CString GetClassName();
long GetSaveFormat();
long GetOpenFormat();
BOOL GetCanSave();
BOOL GetCanOpen();
CString GetPath();
CString GetName();
CString GetExtensions();
};
/
// FileConverters wrapper class


class FileConverters : public COleDispatchDriver
{
public:
FileConverters() {} // Calls COleDispatchDriver default constructor
FileConverters(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FileConverters(const FileConverters& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
long GetConvertMacWordChevrons();
void SetConvertMacWordChevrons(long nNewValue);
LPDISPATCH Item(VARIANT* Index);
};
/
// SynonymInfo wrapper class


class SynonymInfo : public COleDispatchDriver
{
public:
SynonymInfo() {} // Calls COleDispatchDriver default constructor
SynonymInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SynonymInfo(const SynonymInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetWord();
BOOL GetFound();
long GetMeaningCount();
VARIANT GetMeaningList();
VARIANT GetPartOfSpeechList();
VARIANT GetSynonymList(VARIANT* Meaning);
VARIANT GetAntonymList();
VARIANT GetRelatedExpressionList();
VARIANT GetRelatedWordList();
};
/
// Hyperlinks wrapper class


class Hyperlinks : public COleDispatchDriver
{
public:
Hyperlinks() {} // Calls COleDispatchDriver default constructor
Hyperlinks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Hyperlinks(const Hyperlinks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPDISPATCH Anchor, VARIANT* Address, VARIANT* SubAddress, VARIANT* ScreenTip, VARIANT* TextToDisplay, VARIANT* Target);
};
/
// Hyperlink wrapper class


class Hyperlink : public COleDispatchDriver
{
public:
Hyperlink() {} // Calls COleDispatchDriver default constructor
Hyperlink(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Hyperlink(const Hyperlink& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
long GetType();
LPDISPATCH GetRange();
LPDISPATCH GetShape();
BOOL GetExtraInfoRequired();
void Delete();
void Follow(VARIANT* NewWindow, VARIANT* AddHistory, VARIANT* ExtraInfo, VARIANT* Method, VARIANT* HeaderInfo);
void AddToFavorites();
void CreateNewDocument(LPCTSTR FileName, BOOL EditNow, BOOL Overwrite);
CString GetAddress();
void SetAddress(LPCTSTR lpszNewValue);
CString GetSubAddress();
void SetSubAddress(LPCTSTR lpszNewValue);
CString GetEmailSubject();
void SetEmailSubject(LPCTSTR lpszNewValue);
CString GetScreenTip();
void SetScreenTip(LPCTSTR lpszNewValue);
CString GetTextToDisplay();
void SetTextToDisplay(LPCTSTR lpszNewValue);
CString GetTarget();
void SetTarget(LPCTSTR lpszNewValue);
};
/
// Shapes wrapper class


class Shapes : public COleDispatchDriver
{
public:
Shapes() {} // Calls COleDispatchDriver default constructor
Shapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Shapes(const Shapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH AddCallout(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor);
LPDISPATCH AddCurve(VARIANT* SafeArrayOfPoints, VARIANT* Anchor);
LPDISPATCH AddLabel(long Orientation, float Left, float Top, float Width, float Height, VARIANT* Anchor);
LPDISPATCH AddLine(float BeginX, float BeginY, float EndX, float EndY, VARIANT* Anchor);
LPDISPATCH AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, VARIANT* Anchor);
LPDISPATCH AddPolyline(VARIANT* SafeArrayOfPoints, VARIANT* Anchor);
LPDISPATCH AddShape(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor);
LPDISPATCH AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top, VARIANT* Anchor);
LPDISPATCH AddTextbox(long Orientation, float Left, float Top, float Width, float Height, VARIANT* Anchor);
LPDISPATCH BuildFreeform(long EditingType, float X1, float Y1);
LPDISPATCH Range(VARIANT* Index);
void SelectAll();
LPDISPATCH AddOLEObject(VARIANT* ClassType, VARIANT* FileName, VARIANT* LinkToFile, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, 
VARIANT* Anchor);
LPDISPATCH AddOLEControl(VARIANT* ClassType, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, VARIANT* Anchor);
LPDISPATCH AddDiagram(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor);
LPDISPATCH AddCanvas(float Left, float Top, float Width, float Height, VARIANT* Anchor);
};
/
// ShapeRange wrapper class


class ShapeRange : public COleDispatchDriver
{
public:
ShapeRange() {} // Calls COleDispatchDriver default constructor
ShapeRange(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ShapeRange(const ShapeRange& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH GetAdjustments();
long GetAutoShapeType();
void SetAutoShapeType(long nNewValue);
LPDISPATCH GetCallout();
LPDISPATCH GetFill();
LPDISPATCH GetGroupItems();
float GetHeight();
void SetHeight(float newValue);
long GetHorizontalFlip();
float GetLeft();
void SetLeft(float newValue);
LPDISPATCH GetLine();
long GetLockAspectRatio();
void SetLockAspectRatio(long nNewValue);
CString GetName();
void SetName(LPCTSTR lpszNewValue);
LPDISPATCH GetNodes();
float GetRotation();
void SetRotation(float newValue);
LPDISPATCH GetPictureFormat();
LPDISPATCH GetShadow();
LPDISPATCH GetTextEffect();
LPDISPATCH GetTextFrame();
LPDISPATCH GetThreeD();
float GetTop();
void SetTop(float newValue);
long GetType();
long GetVerticalFlip();
VARIANT GetVertices();
long GetVisible();
void SetVisible(long nNewValue);
float GetWidth();
void SetWidth(float newValue);
long GetZOrderPosition();
LPDISPATCH GetHyperlink();
long GetRelativeHorizontalPosition();
void SetRelativeHorizontalPosition(long nNewValue);
long GetRelativeVerticalPosition();
void SetRelativeVerticalPosition(long nNewValue);
long GetLockAnchor();
void SetLockAnchor(long nNewValue);
LPDISPATCH GetWrapFormat();
LPDISPATCH GetAnchor();
LPDISPATCH Item(VARIANT* Index);
void Align(long Align, long RelativeTo);
void Apply();
void Delete();
void Distribute(long Distribute, long RelativeTo);
LPDISPATCH Duplicate();
void Flip(long FlipCmd);
void IncrementLeft(float Increment);
void IncrementRotation(float Increment);
void IncrementTop(float Increment);
LPDISPATCH Group();
void PickUp();
LPDISPATCH Regroup();
void ScaleHeight(float Factor, long RelativeToOriginalSize, long Scale);
void ScaleWidth(float Factor, long RelativeToOriginalSize, long Scale);
void Select(VARIANT* Replace);
void SetShapesDefaultProperties();
LPDISPATCH Ungroup();
void ZOrder(long ZOrderCmd);
LPDISPATCH ConvertToFrame();
LPDISPATCH ConvertToInlineShape();
void Activate();
CString GetAlternativeText();
void SetAlternativeText(LPCTSTR lpszNewValue);
long GetHasDiagram();
LPDISPATCH GetDiagram();
long GetHasDiagramNode();
LPDISPATCH GetDiagramNode();
long GetChild();
LPDISPATCH GetParentGroup();
LPDISPATCH GetCanvasItems();
long GetId();
void CanvasCropLeft(float Increment);
void CanvasCropTop(float Increment);
void CanvasCropRight(float Increment);
void CanvasCropBottom(float Increment);
long GetLayoutInCell();
void SetLayoutInCell(long nNewValue);
};
/
// GroupShapes wrapper class


class GroupShapes : public COleDispatchDriver
{
public:
GroupShapes() {} // Calls COleDispatchDriver default constructor
GroupShapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
GroupShapes(const GroupShapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Range(VARIANT* Index);
};
/
// Shape wrapper class


class Shape : public COleDispatchDriver
{
public:
Shape() {} // Calls COleDispatchDriver default constructor
Shape(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Shape(const Shape& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetAdjustments();
long GetAutoShapeType();
void SetAutoShapeType(long nNewValue);
LPDISPATCH GetCallout();
LPDISPATCH GetFill();
LPDISPATCH GetGroupItems();
float GetHeight();
void SetHeight(float newValue);
long GetHorizontalFlip();
float GetLeft();
void SetLeft(float newValue);
LPDISPATCH GetLine();
long GetLockAspectRatio();
void SetLockAspectRatio(long nNewValue);
CString GetName();
void SetName(LPCTSTR lpszNewValue);
LPDISPATCH GetNodes();
float GetRotation();
void SetRotation(float newValue);
LPDISPATCH GetPictureFormat();
LPDISPATCH GetShadow();
LPDISPATCH GetTextEffect();
LPDISPATCH GetTextFrame();
LPDISPATCH GetThreeD();
float GetTop();
void SetTop(float newValue);
long GetType();
long GetVerticalFlip();
VARIANT GetVertices();
long GetVisible();
void SetVisible(long nNewValue);
float GetWidth();
void SetWidth(float newValue);
long GetZOrderPosition();
LPDISPATCH GetHyperlink();
long GetRelativeHorizontalPosition();
void SetRelativeHorizontalPosition(long nNewValue);
long GetRelativeVerticalPosition();
void SetRelativeVerticalPosition(long nNewValue);
long GetLockAnchor();
void SetLockAnchor(long nNewValue);
LPDISPATCH GetWrapFormat();
LPDISPATCH GetOLEFormat();
LPDISPATCH GetAnchor();
LPDISPATCH GetLinkFormat();
void Apply();
void Delete();
LPDISPATCH Duplicate();
void Flip(long FlipCmd);
void IncrementLeft(float Increment);
void IncrementRotation(float Increment);
void IncrementTop(float Increment);
void PickUp();
void ScaleHeight(float Factor, long RelativeToOriginalSize, long Scale);
void ScaleWidth(float Factor, long RelativeToOriginalSize, long Scale);
void Select(VARIANT* Replace);
void SetShapesDefaultProperties();
LPDISPATCH Ungroup();
void ZOrder(long ZOrderCmd);
LPDISPATCH ConvertToInlineShape();
LPDISPATCH ConvertToFrame();
void Activate();
CString GetAlternativeText();
void SetAlternativeText(LPCTSTR lpszNewValue);
LPDISPATCH GetScript();
long GetHasDiagram();
LPDISPATCH GetDiagram();
long GetHasDiagramNode();
LPDISPATCH GetDiagramNode();
long GetChild();
LPDISPATCH GetParentGroup();
LPDISPATCH GetCanvasItems();
long GetId();
void CanvasCropLeft(float Increment);
void CanvasCropTop(float Increment);
void CanvasCropRight(float Increment);
void CanvasCropBottom(float Increment);
long GetLayoutInCell();
void SetLayoutInCell(long nNewValue);
};
/
// TextFrame wrapper class


class TextFrame : public COleDispatchDriver
{
public:
TextFrame() {} // Calls COleDispatchDriver default constructor
TextFrame(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextFrame(const TextFrame& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetMarginBottom();
void SetMarginBottom(float newValue);
float GetMarginLeft();
void SetMarginLeft(float newValue);
float GetMarginRight();
void SetMarginRight(float newValue);
float GetMarginTop();
void SetMarginTop(float newValue);
long GetOrientation();
void SetOrientation(long nNewValue);
LPDISPATCH GetTextRange();
LPDISPATCH GetContainingRange();
LPDISPATCH GetNext();
void SetNext(LPDISPATCH newValue);
LPDISPATCH GetPrevious();
void SetPrevious(LPDISPATCH newValue);
BOOL GetOverflowing();
long GetHasText();
void BreakForwardLink();
BOOL ValidLinkTarget(LPDISPATCH TargetTextFrame);
long GetAutoSize();
void SetAutoSize(long nNewValue);
long GetWordWrap();
void SetWordWrap(long nNewValue);
};
/
// _LetterContent wrapper class


class _LetterContent : public COleDispatchDriver
{
public:
_LetterContent() {} // Calls COleDispatchDriver default constructor
_LetterContent(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
_LetterContent(const _LetterContent& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetDuplicate();
CString GetDateFormat();
void SetDateFormat(LPCTSTR lpszNewValue);
BOOL GetIncludeHeaderFooter();
void SetIncludeHeaderFooter(BOOL bNewValue);
CString GetPageDesign();
void SetPageDesign(LPCTSTR lpszNewValue);
long GetLetterStyle();
void SetLetterStyle(long nNewValue);
BOOL GetLetterhead();
void SetLetterhead(BOOL bNewValue);
long GetLetterheadLocation();
void SetLetterheadLocation(long nNewValue);
float GetLetterheadSize();
void SetLetterheadSize(float newValue);
CString GetRecipientName();
void SetRecipientName(LPCTSTR lpszNewValue);
CString GetRecipientAddress();
void SetRecipientAddress(LPCTSTR lpszNewValue);
CString GetSalutation();
void SetSalutation(LPCTSTR lpszNewValue);
long GetSalutationType();
void SetSalutationType(long nNewValue);
CString GetRecipientReference();
void SetRecipientReference(LPCTSTR lpszNewValue);
CString GetMailingInstructions();
void SetMailingInstructions(LPCTSTR lpszNewValue);
CString GetAttentionLine();
void SetAttentionLine(LPCTSTR lpszNewValue);
CString GetSubject();
void SetSubject(LPCTSTR lpszNewValue);
long GetEnclosureNumber();
void SetEnclosureNumber(long nNewValue);
CString GetCCList();
void SetCCList(LPCTSTR lpszNewValue);
CString GetReturnAddress();
void SetReturnAddress(LPCTSTR lpszNewValue);
CString GetSenderName();
void SetSenderName(LPCTSTR lpszNewValue);
CString GetClosing();
void SetClosing(LPCTSTR lpszNewValue);
CString GetSenderCompany();
void SetSenderCompany(LPCTSTR lpszNewValue);
CString GetSenderJobTitle();
void SetSenderJobTitle(LPCTSTR lpszNewValue);
CString GetSenderInitials();
void SetSenderInitials(LPCTSTR lpszNewValue);
BOOL GetInfoBlock();
void SetInfoBlock(BOOL bNewValue);
CString GetRecipientCode();
void SetRecipientCode(LPCTSTR lpszNewValue);
long GetRecipientGender();
void SetRecipientGender(long nNewValue);
CString GetReturnAddressShortForm();
void SetReturnAddressShortForm(LPCTSTR lpszNewValue);
CString GetSenderCity();
void SetSenderCity(LPCTSTR lpszNewValue);
CString GetSenderCode();
void SetSenderCode(LPCTSTR lpszNewValue);
long GetSenderGender();
void SetSenderGender(long nNewValue);
CString GetSenderReference();
void SetSenderReference(LPCTSTR lpszNewValue);
};
/
// View wrapper class


class View : public COleDispatchDriver
{
public:
View() {} // Calls COleDispatchDriver default constructor
View(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
View(const View& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetType();
void SetType(long nNewValue);
BOOL GetFullScreen();
void SetFullScreen(BOOL bNewValue);
BOOL GetDraft();
void SetDraft(BOOL bNewValue);
BOOL GetShowAll();
void SetShowAll(BOOL bNewValue);
BOOL GetShowFieldCodes();
void SetShowFieldCodes(BOOL bNewValue);
BOOL GetMailMergeDataView();
void SetMailMergeDataView(BOOL bNewValue);
BOOL GetMagnifier();
void SetMagnifier(BOOL bNewValue);
BOOL GetShowFirstLineOnly();
void SetShowFirstLineOnly(BOOL bNewValue);
BOOL GetShowFormat();
void SetShowFormat(BOOL bNewValue);
LPDISPATCH GetZoom();
BOOL GetShowObjectAnchors();
void SetShowObjectAnchors(BOOL bNewValue);
BOOL GetShowTextBoundaries();
void SetShowTextBoundaries(BOOL bNewValue);
BOOL GetShowHighlight();
void SetShowHighlight(BOOL bNewValue);
BOOL GetShowDrawings();
void SetShowDrawings(BOOL bNewValue);
BOOL GetShowTabs();
void SetShowTabs(BOOL bNewValue);
BOOL GetShowSpaces();
void SetShowSpaces(BOOL bNewValue);
BOOL GetShowParagraphs();
void SetShowParagraphs(BOOL bNewValue);
BOOL GetShowHyphens();
void SetShowHyphens(BOOL bNewValue);
BOOL GetShowHiddenText();
void SetShowHiddenText(BOOL bNewValue);
BOOL GetWrapToWindow();
void SetWrapToWindow(BOOL bNewValue);
BOOL GetShowPicturePlaceHolders();
void SetShowPicturePlaceHolders(BOOL bNewValue);
BOOL GetShowBookmarks();
void SetShowBookmarks(BOOL bNewValue);
long GetFieldShading();
void SetFieldShading(long nNewValue);
BOOL GetShowAnimation();
void SetShowAnimation(BOOL bNewValue);
BOOL GetTableGridlines();
void SetTableGridlines(BOOL bNewValue);
BOOL GetShowMainTextLayer();
void SetShowMainTextLayer(BOOL bNewValue);
long GetSeekView();
void SetSeekView(long nNewValue);
long GetSplitSpecial();
void SetSplitSpecial(long nNewValue);
BOOL GetShowOptionalBreaks();
void SetShowOptionalBreaks(BOOL bNewValue);
void CollapseOutline(VARIANT* Range);
void ExpandOutline(VARIANT* Range);
void ShowAllHeadings();
void ShowHeading(long Level);
void PreviousHeaderFooter();
void NextHeaderFooter();
BOOL GetDisplayPageBoundaries();
void SetDisplayPageBoundaries(BOOL bNewValue);
BOOL GetDisplaySmartTags();
void SetDisplaySmartTags(BOOL bNewValue);
BOOL GetShowRevisionsAndComments();
void SetShowRevisionsAndComments(BOOL bNewValue);
BOOL GetShowComments();
void SetShowComments(BOOL bNewValue);
BOOL GetShowInsertionsAndDeletions();
void SetShowInsertionsAndDeletions(BOOL bNewValue);
BOOL GetShowFormatChanges();
void SetShowFormatChanges(BOOL bNewValue);
long GetRevisionsView();
void SetRevisionsView(long nNewValue);
long GetRevisionsMode();
void SetRevisionsMode(long nNewValue);
float GetRevisionsBalloonWidth();
void SetRevisionsBalloonWidth(float newValue);
long GetRevisionsBalloonWidthType();
void SetRevisionsBalloonWidthType(long nNewValue);
long GetRevisionsBalloonSide();
void SetRevisionsBalloonSide(long nNewValue);
LPDISPATCH GetReviewers();
BOOL GetRevisionsBalloonShowConnectingLines();
void SetRevisionsBalloonShowConnectingLines(BOOL bNewValue);
BOOL GetReadingLayout();
void SetReadingLayout(BOOL bNewValue);
long GetShowXMLMarkup();
void SetShowXMLMarkup(long nNewValue);
long GetShadeEditableRanges();
void SetShadeEditableRanges(long nNewValue);
BOOL GetShowInkAnnotations();
void SetShowInkAnnotations(BOOL bNewValue);
BOOL GetDisplayBackgrounds();
void SetDisplayBackgrounds(BOOL bNewValue);
BOOL GetReadingLayoutActualView();
void SetReadingLayoutActualView(BOOL bNewValue);
BOOL GetReadingLayoutAllowMultiplePages();
void SetReadingLayoutAllowMultiplePages(BOOL bNewValue);
};
/
// Zoom wrapper class


class Zoom : public COleDispatchDriver
{
public:
Zoom() {} // Calls COleDispatchDriver default constructor
Zoom(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Zoom(const Zoom& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetPercentage();
void SetPercentage(long nNewValue);
long GetPageFit();
void SetPageFit(long nNewValue);
long GetPageRows();
void SetPageRows(long nNewValue);
long GetPageColumns();
void SetPageColumns(long nNewValue);
};
/
// Zooms wrapper class


class Zooms : public COleDispatchDriver
{
public:
Zooms() {} // Calls COleDispatchDriver default constructor
Zooms(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Zooms(const Zooms& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// InlineShape wrapper class


class InlineShape : public COleDispatchDriver
{
public:
InlineShape() {} // Calls COleDispatchDriver default constructor
InlineShape(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
InlineShape(const InlineShape& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
LPDISPATCH GetRange();
LPDISPATCH GetLinkFormat();
LPDISPATCH GetField();
LPDISPATCH GetOLEFormat();
long GetType();
LPDISPATCH GetHyperlink();
float GetHeight();
void SetHeight(float newValue);
float GetWidth();
void SetWidth(float newValue);
float GetScaleHeight();
void SetScaleHeight(float newValue);
float GetScaleWidth();
void SetScaleWidth(float newValue);
long GetLockAspectRatio();
void SetLockAspectRatio(long nNewValue);
LPDISPATCH GetLine();
LPDISPATCH GetFill();
LPDISPATCH GetPictureFormat();
void SetPictureFormat(LPDISPATCH newValue);
void Activate();
void Reset();
void Delete();
void Select();
LPDISPATCH ConvertToShape();
LPDISPATCH GetHorizontalLineFormat();
LPDISPATCH GetScript();
LPDISPATCH GetTextEffect();
void SetTextEffect(LPDISPATCH newValue);
CString GetAlternativeText();
void SetAlternativeText(LPCTSTR lpszNewValue);
BOOL GetIsPictureBullet();
};
/
// InlineShapes wrapper class


class InlineShapes : public COleDispatchDriver
{
public:
InlineShapes() {} // Calls COleDispatchDriver default constructor
InlineShapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
InlineShapes(const InlineShapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(long Index);
LPDISPATCH AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Range);
LPDISPATCH AddOLEObject(VARIANT* ClassType, VARIANT* FileName, VARIANT* LinkToFile, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel, VARIANT* Range);
LPDISPATCH AddOLEControl(VARIANT* ClassType, VARIANT* Range);
LPDISPATCH New(LPDISPATCH Range);
LPDISPATCH AddHorizontalLine(LPCTSTR FileName, VARIANT* Range);
LPDISPATCH AddHorizontalLineStandard(VARIANT* Range);
LPDISPATCH AddPictureBullet(LPCTSTR FileName, VARIANT* Range);
};
/
// SpellingSuggestions wrapper class


class SpellingSuggestions : public COleDispatchDriver
{
public:
SpellingSuggestions() {} // Calls COleDispatchDriver default constructor
SpellingSuggestions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SpellingSuggestions(const SpellingSuggestions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetSpellingErrorType();
LPDISPATCH Item(long Index);
};
/
// SpellingSuggestion wrapper class


class SpellingSuggestion : public COleDispatchDriver
{
public:
SpellingSuggestion() {} // Calls COleDispatchDriver default constructor
SpellingSuggestion(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SpellingSuggestion(const SpellingSuggestion& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
};
/
// Dictionaries wrapper class


class Dictionaries : public COleDispatchDriver
{
public:
Dictionaries() {} // Calls COleDispatchDriver default constructor
Dictionaries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Dictionaries(const Dictionaries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetMaximum();
LPDISPATCH GetActiveCustomDictionary();
void SetActiveCustomDictionary(LPDISPATCH newValue);
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR FileName);
void ClearAll();
};
/
// HangulHanjaConversionDictionaries wrapper class


class HangulHanjaConversionDictionaries : public COleDispatchDriver
{
public:
HangulHanjaConversionDictionaries() {} // Calls COleDispatchDriver default constructor
HangulHanjaConversionDictionaries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HangulHanjaConversionDictionaries(const HangulHanjaConversionDictionaries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetMaximum();
LPDISPATCH GetActiveCustomDictionary();
void SetActiveCustomDictionary(LPDISPATCH newValue);
LPDISPATCH GetBuiltinDictionary();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR FileName);
void ClearAll();
};
/
// Dictionary wrapper class


class Dictionary : public COleDispatchDriver
{
public:
Dictionary() {} // Calls COleDispatchDriver default constructor
Dictionary(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Dictionary(const Dictionary& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
CString GetPath();
long GetLanguageID();
void SetLanguageID(long nNewValue);
BOOL GetReadOnly();
long GetType();
BOOL GetLanguageSpecific();
void SetLanguageSpecific(BOOL bNewValue);
void Delete();
};
/
// ReadabilityStatistics wrapper class


class ReadabilityStatistics : public COleDispatchDriver
{
public:
ReadabilityStatistics() {} // Calls COleDispatchDriver default constructor
ReadabilityStatistics(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ReadabilityStatistics(const ReadabilityStatistics& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
};
/
// ReadabilityStatistic wrapper class


class ReadabilityStatistic : public COleDispatchDriver
{
public:
ReadabilityStatistic() {} // Calls COleDispatchDriver default constructor
ReadabilityStatistic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ReadabilityStatistic(const ReadabilityStatistic& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetName();
float GetValue();
};
/
// Versions wrapper class


class Versions : public COleDispatchDriver
{
public:
Versions() {} // Calls COleDispatchDriver default constructor
Versions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Versions(const Versions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetAutoVersion();
void SetAutoVersion(long nNewValue);
LPDISPATCH Item(long Index);
void Save(VARIANT* Comment);
};
/
// Version wrapper class


class Version : public COleDispatchDriver
{
public:
Version() {} // Calls COleDispatchDriver default constructor
Version(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Version(const Version& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetSavedBy();
CString GetComment();
DATE GetDate();
long GetIndex();
void Delete();
LPDISPATCH Open();
};
/
// Options wrapper class


class Options : public COleDispatchDriver
{
public:
Options() {} // Calls COleDispatchDriver default constructor
Options(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Options(const Options& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetAllowAccentedUppercase();
void SetAllowAccentedUppercase(BOOL bNewValue);
BOOL GetWPHelp();
void SetWPHelp(BOOL bNewValue);
BOOL GetWPDocNavKeys();
void SetWPDocNavKeys(BOOL bNewValue);
BOOL GetPagination();
void SetPagination(BOOL bNewValue);
BOOL GetBlueScreen();
void SetBlueScreen(BOOL bNewValue);
BOOL GetEnableSound();
void SetEnableSound(BOOL bNewValue);
BOOL GetConfirmConversions();
void SetConfirmConversions(BOOL bNewValue);
BOOL GetUpdateLinksAtOpen();
void SetUpdateLinksAtOpen(BOOL bNewValue);
BOOL GetSendMailAttach();
void SetSendMailAttach(BOOL bNewValue);
long GetMeasurementUnit();
void SetMeasurementUnit(long nNewValue);
long GetButtonFieldClicks();
void SetButtonFieldClicks(long nNewValue);
BOOL GetShortMenuNames();
void SetShortMenuNames(BOOL bNewValue);
BOOL GetRTFInClipboard();
void SetRTFInClipboard(BOOL bNewValue);
BOOL GetUpdateFieldsAtPrint();
void SetUpdateFieldsAtPrint(BOOL bNewValue);
BOOL GetPrintProperties();
void SetPrintProperties(BOOL bNewValue);
BOOL GetPrintFieldCodes();
void SetPrintFieldCodes(BOOL bNewValue);
BOOL GetPrintComments();
void SetPrintComments(BOOL bNewValue);
BOOL GetPrintHiddenText();
void SetPrintHiddenText(BOOL bNewValue);
BOOL GetEnvelopeFeederInstalled();
BOOL GetUpdateLinksAtPrint();
void SetUpdateLinksAtPrint(BOOL bNewValue);
BOOL GetPrintBackground();
void SetPrintBackground(BOOL bNewValue);
BOOL GetPrintDrawingObjects();
void SetPrintDrawingObjects(BOOL bNewValue);
CString GetDefaultTray();
void SetDefaultTray(LPCTSTR lpszNewValue);
long GetDefaultTrayID();
void SetDefaultTrayID(long nNewValue);
BOOL GetCreateBackup();
void SetCreateBackup(BOOL bNewValue);
BOOL GetAllowFastSave();
void SetAllowFastSave(BOOL bNewValue);
BOOL GetSavePropertiesPrompt();
void SetSavePropertiesPrompt(BOOL bNewValue);
BOOL GetSaveNormalPrompt();
void SetSaveNormalPrompt(BOOL bNewValue);
long GetSaveInterval();
void SetSaveInterval(long nNewValue);
BOOL GetBackgroundSave();
void SetBackgroundSave(BOOL bNewValue);
long GetInsertedTextMark();
void SetInsertedTextMark(long nNewValue);
long GetDeletedTextMark();
void SetDeletedTextMark(long nNewValue);
long GetRevisedLinesMark();
void SetRevisedLinesMark(long nNewValue);
long GetInsertedTextColor();
void SetInsertedTextColor(long nNewValue);
long GetDeletedTextColor();
void SetDeletedTextColor(long nNewValue);
long GetRevisedLinesColor();
void SetRevisedLinesColor(long nNewValue);
CString GetDefaultFilePath(long Path);
void SetDefaultFilePath(long Path, LPCTSTR lpszNewValue);
BOOL GetOvertype();
void SetOvertype(BOOL bNewValue);
BOOL GetReplaceSelection();
void SetReplaceSelection(BOOL bNewValue);
BOOL GetAllowDragAndDrop();
void SetAllowDragAndDrop(BOOL bNewValue);
BOOL GetAutoWordSelection();
void SetAutoWordSelection(BOOL bNewValue);
BOOL GetINSKeyForPaste();
void SetINSKeyForPaste(BOOL bNewValue);
BOOL GetSmartCutPaste();
void SetSmartCutPaste(BOOL bNewValue);
BOOL GetTabIndentKey();
void SetTabIndentKey(BOOL bNewValue);
CString GetPictureEditor();
void SetPictureEditor(LPCTSTR lpszNewValue);
BOOL GetAnimateScreenMovements();
void SetAnimateScreenMovements(BOOL bNewValue);
long GetRevisedPropertiesMark();
void SetRevisedPropertiesMark(long nNewValue);
long GetRevisedPropertiesColor();
void SetRevisedPropertiesColor(long nNewValue);
BOOL GetSnapToGrid();
void SetSnapToGrid(BOOL bNewValue);
BOOL GetSnapToShapes();
void SetSnapToShapes(BOOL bNewValue);
float GetGridDistanceHorizontal();
void SetGridDistanceHorizontal(float newValue);
float GetGridDistanceVertical();
void SetGridDistanceVertical(float newValue);
float GetGridOriginHorizontal();
void SetGridOriginHorizontal(float newValue);
float GetGridOriginVertical();
void SetGridOriginVertical(float newValue);
BOOL GetInlineConversion();
void SetInlineConversion(BOOL bNewValue);
BOOL GetIMEAutomaticControl();
void SetIMEAutomaticControl(BOOL bNewValue);
BOOL GetAutoFormatApplyHeadings();
void SetAutoFormatApplyHeadings(BOOL bNewValue);
BOOL GetAutoFormatApplyLists();
void SetAutoFormatApplyLists(BOOL bNewValue);
BOOL GetAutoFormatApplyBulletedLists();
void SetAutoFormatApplyBulletedLists(BOOL bNewValue);
BOOL GetAutoFormatApplyOtherParas();
void SetAutoFormatApplyOtherParas(BOOL bNewValue);
BOOL GetAutoFormatReplaceQuotes();
void SetAutoFormatReplaceQuotes(BOOL bNewValue);
BOOL GetAutoFormatReplaceSymbols();
void SetAutoFormatReplaceSymbols(BOOL bNewValue);
BOOL GetAutoFormatReplaceOrdinals();
void SetAutoFormatReplaceOrdinals(BOOL bNewValue);
BOOL GetAutoFormatReplaceFractions();
void SetAutoFormatReplaceFractions(BOOL bNewValue);
BOOL GetAutoFormatReplacePlainTextEmphasis();
void SetAutoFormatReplacePlainTextEmphasis(BOOL bNewValue);
BOOL GetAutoFormatPreserveStyles();
void SetAutoFormatPreserveStyles(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyHeadings();
void SetAutoFormatAsYouTypeApplyHeadings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyBorders();
void SetAutoFormatAsYouTypeApplyBorders(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyBulletedLists();
void SetAutoFormatAsYouTypeApplyBulletedLists(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyNumberedLists();
void SetAutoFormatAsYouTypeApplyNumberedLists(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceQuotes();
void SetAutoFormatAsYouTypeReplaceQuotes(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceSymbols();
void SetAutoFormatAsYouTypeReplaceSymbols(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceOrdinals();
void SetAutoFormatAsYouTypeReplaceOrdinals(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceFractions();
void SetAutoFormatAsYouTypeReplaceFractions(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplacePlainTextEmphasis();
void SetAutoFormatAsYouTypeReplacePlainTextEmphasis(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeFormatListItemBeginning();
void SetAutoFormatAsYouTypeFormatListItemBeginning(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeDefineStyles();
void SetAutoFormatAsYouTypeDefineStyles(BOOL bNewValue);
BOOL GetAutoFormatPlainTextWordMail();
void SetAutoFormatPlainTextWordMail(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceHyperlinks();
void SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue);
BOOL GetAutoFormatReplaceHyperlinks();
void SetAutoFormatReplaceHyperlinks(BOOL bNewValue);
long GetDefaultHighlightColorIndex();
void SetDefaultHighlightColorIndex(long nNewValue);
long GetDefaultBorderLineStyle();
void SetDefaultBorderLineStyle(long nNewValue);
BOOL GetCheckSpellingAsYouType();
void SetCheckSpellingAsYouType(BOOL bNewValue);
BOOL GetCheckGrammarAsYouType();
void SetCheckGrammarAsYouType(BOOL bNewValue);
BOOL GetIgnoreInternetAndFileAddresses();
void SetIgnoreInternetAndFileAddresses(BOOL bNewValue);
BOOL GetShowReadabilityStatistics();
void SetShowReadabilityStatistics(BOOL bNewValue);
BOOL GetIgnoreUppercase();
void SetIgnoreUppercase(BOOL bNewValue);
BOOL GetIgnoreMixedDigits();
void SetIgnoreMixedDigits(BOOL bNewValue);
BOOL GetSuggestFromMainDictionaryOnly();
void SetSuggestFromMainDictionaryOnly(BOOL bNewValue);
BOOL GetSuggestSpellingCorrections();
void SetSuggestSpellingCorrections(BOOL bNewValue);
long GetDefaultBorderLineWidth();
void SetDefaultBorderLineWidth(long nNewValue);
BOOL GetCheckGrammarWithSpelling();
void SetCheckGrammarWithSpelling(BOOL bNewValue);
long GetDefaultOpenFormat();
void SetDefaultOpenFormat(long nNewValue);
BOOL GetPrintDraft();
void SetPrintDraft(BOOL bNewValue);
BOOL GetPrintReverse();
void SetPrintReverse(BOOL bNewValue);
BOOL GetMapPaperSize();
void SetMapPaperSize(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyTables();
void SetAutoFormatAsYouTypeApplyTables(BOOL bNewValue);
BOOL GetAutoFormatApplyFirstIndents();
void SetAutoFormatApplyFirstIndents(BOOL bNewValue);
BOOL GetAutoFormatMatchParentheses();
void SetAutoFormatMatchParentheses(BOOL bNewValue);
BOOL GetAutoFormatReplaceFarEastDashes();
void SetAutoFormatReplaceFarEastDashes(BOOL bNewValue);
BOOL GetAutoFormatDeleteAutoSpaces();
void SetAutoFormatDeleteAutoSpaces(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyFirstIndents();
void SetAutoFormatAsYouTypeApplyFirstIndents(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyDates();
void SetAutoFormatAsYouTypeApplyDates(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyClosings();
void SetAutoFormatAsYouTypeApplyClosings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeMatchParentheses();
void SetAutoFormatAsYouTypeMatchParentheses(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceFarEastDashes();
void SetAutoFormatAsYouTypeReplaceFarEastDashes(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeDeleteAutoSpaces();
void SetAutoFormatAsYouTypeDeleteAutoSpaces(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeInsertClosings();
void SetAutoFormatAsYouTypeInsertClosings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeAutoLetterWizard();
void SetAutoFormatAsYouTypeAutoLetterWizard(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeInsertOvers();
void SetAutoFormatAsYouTypeInsertOvers(BOOL bNewValue);
BOOL GetDisplayGridLines();
void SetDisplayGridLines(BOOL bNewValue);
BOOL GetMatchFuzzyCase();
void SetMatchFuzzyCase(BOOL bNewValue);
BOOL GetMatchFuzzyByte();
void SetMatchFuzzyByte(BOOL bNewValue);
BOOL GetMatchFuzzyHiragana();
void SetMatchFuzzyHiragana(BOOL bNewValue);
BOOL GetMatchFuzzySmallKana();
void SetMatchFuzzySmallKana(BOOL bNewValue);
BOOL GetMatchFuzzyDash();
void SetMatchFuzzyDash(BOOL bNewValue);
BOOL GetMatchFuzzyIterationMark();
void SetMatchFuzzyIterationMark(BOOL bNewValue);
BOOL GetMatchFuzzyKanji();
void SetMatchFuzzyKanji(BOOL bNewValue);
BOOL GetMatchFuzzyOldKana();
void SetMatchFuzzyOldKana(BOOL bNewValue);
BOOL GetMatchFuzzyProlongedSoundMark();
void SetMatchFuzzyProlongedSoundMark(BOOL bNewValue);
BOOL GetMatchFuzzyDZ();
void SetMatchFuzzyDZ(BOOL bNewValue);
BOOL GetMatchFuzzyBV();
void SetMatchFuzzyBV(BOOL bNewValue);
BOOL GetMatchFuzzyTC();
void SetMatchFuzzyTC(BOOL bNewValue);
BOOL GetMatchFuzzyHF();
void SetMatchFuzzyHF(BOOL bNewValue);
BOOL GetMatchFuzzyZJ();
void SetMatchFuzzyZJ(BOOL bNewValue);
BOOL GetMatchFuzzyAY();
void SetMatchFuzzyAY(BOOL bNewValue);
BOOL GetMatchFuzzyKiKu();
void SetMatchFuzzyKiKu(BOOL bNewValue);
BOOL GetMatchFuzzyPunctuation();
void SetMatchFuzzyPunctuation(BOOL bNewValue);
BOOL GetMatchFuzzySpace();
void SetMatchFuzzySpace(BOOL bNewValue);
BOOL GetApplyFarEastFontsToAscii();
void SetApplyFarEastFontsToAscii(BOOL bNewValue);
BOOL GetConvertHighAnsiToFarEast();
void SetConvertHighAnsiToFarEast(BOOL bNewValue);
BOOL GetPrintOddPagesInAscendingOrder();
void SetPrintOddPagesInAscendingOrder(BOOL bNewValue);
BOOL GetPrintEvenPagesInAscendingOrder();
void SetPrintEvenPagesInAscendingOrder(BOOL bNewValue);
long GetDefaultBorderColorIndex();
void SetDefaultBorderColorIndex(long nNewValue);
BOOL GetEnableMisusedWordsDictionary();
void SetEnableMisusedWordsDictionary(BOOL bNewValue);
BOOL GetAllowCombinedAuxiliaryForms();
void SetAllowCombinedAuxiliaryForms(BOOL bNewValue);
BOOL GetHangulHanjaFastConversion();
void SetHangulHanjaFastConversion(BOOL bNewValue);
BOOL GetCheckHangulEndings();
void SetCheckHangulEndings(BOOL bNewValue);
BOOL GetEnableHangulHanjaRecentOrdering();
void SetEnableHangulHanjaRecentOrdering(BOOL bNewValue);
long GetMultipleWordConversionsMode();
void SetMultipleWordConversionsMode(long nNewValue);
void SetWPHelpOptions(VARIANT* CommandKeyHelp, VARIANT* DocNavigationKeys, VARIANT* MouseSimulation, VARIANT* DemoGuidance, VARIANT* DemoSpeed, VARIANT* HelpType);
long GetDefaultBorderColor();
void SetDefaultBorderColor(long nNewValue);
BOOL GetAllowPixelUnits();
void SetAllowPixelUnits(BOOL bNewValue);
BOOL GetUseCharacterUnit();
void SetUseCharacterUnit(BOOL bNewValue);
BOOL GetAllowCompoundNounProcessing();
void SetAllowCompoundNounProcessing(BOOL bNewValue);
BOOL GetAutoKeyboardSwitching();
void SetAutoKeyboardSwitching(BOOL bNewValue);
long GetDocumentViewDirection();
void SetDocumentViewDirection(long nNewValue);
long GetArabicNumeral();
void SetArabicNumeral(long nNewValue);
long GetMonthNames();
void SetMonthNames(long nNewValue);
long GetCursorMovement();
void SetCursorMovement(long nNewValue);
long GetVisualSelection();
void SetVisualSelection(long nNewValue);
BOOL GetShowDiacritics();
void SetShowDiacritics(BOOL bNewValue);
BOOL GetShowControlCharacters();
void SetShowControlCharacters(BOOL bNewValue);
BOOL GetAddControlCharacters();
void SetAddControlCharacters(BOOL bNewValue);
BOOL GetAddBiDirectionalMarksWhenSavingTextFile();
void SetAddBiDirectionalMarksWhenSavingTextFile(BOOL bNewValue);
BOOL GetStrictInitialAlefHamza();
void SetStrictInitialAlefHamza(BOOL bNewValue);
BOOL GetStrictFinalYaa();
void SetStrictFinalYaa(BOOL bNewValue);
long GetHebrewMode();
void SetHebrewMode(long nNewValue);
long GetArabicMode();
void SetArabicMode(long nNewValue);
BOOL GetAllowClickAndTypeMouse();
void SetAllowClickAndTypeMouse(BOOL bNewValue);
BOOL GetUseGermanSpellingReform();
void SetUseGermanSpellingReform(BOOL bNewValue);
long GetInterpretHighAnsi();
void SetInterpretHighAnsi(long nNewValue);
BOOL GetAddHebDoubleQuote();
void SetAddHebDoubleQuote(BOOL bNewValue);
BOOL GetUseDiffDiacColor();
void SetUseDiffDiacColor(BOOL bNewValue);
long GetDiacriticColorVal();
void SetDiacriticColorVal(long nNewValue);
BOOL GetOptimizeForWord97byDefault();
void SetOptimizeForWord97byDefault(BOOL bNewValue);
BOOL GetLocalNetworkFile();
void SetLocalNetworkFile(BOOL bNewValue);
BOOL GetTypeNReplace();
void SetTypeNReplace(BOOL bNewValue);
BOOL GetSequenceCheck();
void SetSequenceCheck(BOOL bNewValue);
BOOL GetBackgroundOpen();
void SetBackgroundOpen(BOOL bNewValue);
BOOL GetDisableFeaturesbyDefault();
void SetDisableFeaturesbyDefault(BOOL bNewValue);
BOOL GetPasteAdjustWordSpacing();
void SetPasteAdjustWordSpacing(BOOL bNewValue);
BOOL GetPasteAdjustParagraphSpacing();
void SetPasteAdjustParagraphSpacing(BOOL bNewValue);
BOOL GetPasteAdjustTableFormatting();
void SetPasteAdjustTableFormatting(BOOL bNewValue);
BOOL GetPasteSmartStyleBehavior();
void SetPasteSmartStyleBehavior(BOOL bNewValue);
BOOL GetPasteMergeFromPPT();
void SetPasteMergeFromPPT(BOOL bNewValue);
BOOL GetPasteMergeFromXL();
void SetPasteMergeFromXL(BOOL bNewValue);
BOOL GetCtrlClickHyperlinkToOpen();
void SetCtrlClickHyperlinkToOpen(BOOL bNewValue);
long GetPictureWrapType();
void SetPictureWrapType(long nNewValue);
long GetDisableFeaturesIntroducedAfterbyDefault();
void SetDisableFeaturesIntroducedAfterbyDefault(long nNewValue);
BOOL GetPasteSmartCutPaste();
void SetPasteSmartCutPaste(BOOL bNewValue);
BOOL GetDisplayPasteOptions();
void SetDisplayPasteOptions(BOOL bNewValue);
BOOL GetPromptUpdateStyle();
void SetPromptUpdateStyle(BOOL bNewValue);
CString GetDefaultEPostageApp();
void SetDefaultEPostageApp(LPCTSTR lpszNewValue);
long GetDefaultTextEncoding();
void SetDefaultTextEncoding(long nNewValue);
BOOL GetLabelSmartTags();
void SetLabelSmartTags(BOOL bNewValue);
BOOL GetDisplaySmartTagButtons();
void SetDisplaySmartTagButtons(BOOL bNewValue);
BOOL GetWarnBeforeSavingPrintingSendingMarkup();
void SetWarnBeforeSavingPrintingSendingMarkup(BOOL bNewValue);
BOOL GetStoreRSIDOnSave();
void SetStoreRSIDOnSave(BOOL bNewValue);
BOOL GetShowFormatError();
void SetShowFormatError(BOOL bNewValue);
BOOL GetFormatScanning();
void SetFormatScanning(BOOL bNewValue);
BOOL GetPasteMergeLists();
void SetPasteMergeLists(BOOL bNewValue);
BOOL GetAutoCreateNewDrawings();
void SetAutoCreateNewDrawings(BOOL bNewValue);
BOOL GetSmartParaSelection();
void SetSmartParaSelection(BOOL bNewValue);
long GetRevisionsBalloonPrintOrientation();
void SetRevisionsBalloonPrintOrientation(long nNewValue);
long GetCommentsColor();
void SetCommentsColor(long nNewValue);
BOOL GetPrintXMLTag();
void SetPrintXMLTag(BOOL bNewValue);
BOOL GetPrintBackgrounds();
void SetPrintBackgrounds(BOOL bNewValue);
BOOL GetAllowReadingMode();
void SetAllowReadingMode(BOOL bNewValue);
BOOL GetShowMarkupOpenSave();
void SetShowMarkupOpenSave(BOOL bNewValue);
BOOL GetSmartCursoring();
void SetSmartCursoring(BOOL bNewValue);
};
/
// MailMessage wrapper class


class MailMessage : public COleDispatchDriver
{
public:
MailMessage() {} // Calls COleDispatchDriver default constructor
MailMessage(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MailMessage(const MailMessage& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void CheckName();
void Delete();
void DisplayMoveDialog();
void DisplayProperties();
void DisplaySelectNamesDialog();
void Forward();
void GoToNext();
void GoToPrevious();
void Reply();
void ReplyAll();
void ToggleHeader();
};
/
// ProofreadingErrors wrapper class


class ProofreadingErrors : public COleDispatchDriver
{
public:
ProofreadingErrors() {} // Calls COleDispatchDriver default constructor
ProofreadingErrors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ProofreadingErrors(const ProofreadingErrors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetType();
LPDISPATCH Item(long Index);
};
/
// Mailer wrapper class


class Mailer : public COleDispatchDriver
{
public:
Mailer() {} // Calls COleDispatchDriver default constructor
Mailer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Mailer(const Mailer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
VARIANT GetBCCRecipients();
void SetBCCRecipients(VARIANT* newValue);
VARIANT GetCCRecipients();
void SetCCRecipients(VARIANT* newValue);
VARIANT GetRecipients();
void SetRecipients(VARIANT* newValue);
VARIANT GetEnclosures();
void SetEnclosures(VARIANT* newValue);
CString GetSender();
DATE GetSendDateTime();
BOOL GetReceived();
CString GetSubject();
void SetSubject(LPCTSTR lpszNewValue);
};
/
// WrapFormat wrapper class


class WrapFormat : public COleDispatchDriver
{
public:
WrapFormat() {} // Calls COleDispatchDriver default constructor
WrapFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
WrapFormat(const WrapFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetType();
void SetType(long nNewValue);
long GetSide();
void SetSide(long nNewValue);
float GetDistanceTop();
void SetDistanceTop(float newValue);
float GetDistanceBottom();
void SetDistanceBottom(float newValue);
float GetDistanceLeft();
void SetDistanceLeft(float newValue);
float GetDistanceRight();
void SetDistanceRight(float newValue);
long GetAllowOverlap();
void SetAllowOverlap(long nNewValue);
};
/
// HangulAndAlphabetExceptions wrapper class


class HangulAndAlphabetExceptions : public COleDispatchDriver
{
public:
HangulAndAlphabetExceptions() {} // Calls COleDispatchDriver default constructor
HangulAndAlphabetExceptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HangulAndAlphabetExceptions(const HangulAndAlphabetExceptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name);
};
/
// HangulAndAlphabetException wrapper class


class HangulAndAlphabetException : public COleDispatchDriver
{
public:
HangulAndAlphabetException() {} // Calls COleDispatchDriver default constructor
HangulAndAlphabetException(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HangulAndAlphabetException(const HangulAndAlphabetException& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void Delete();
};
/
// Adjustments wrapper class


class Adjustments : public COleDispatchDriver
{
public:
Adjustments() {} // Calls COleDispatchDriver default constructor
Adjustments(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Adjustments(const Adjustments& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
float GetItem(long Index);
void SetItem(long Index, float newValue);
};
/
// CalloutFormat wrapper class


class CalloutFormat : public COleDispatchDriver
{
public:
CalloutFormat() {} // Calls COleDispatchDriver default constructor
CalloutFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CalloutFormat(const CalloutFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetAccent();
void SetAccent(long nNewValue);
long GetAngle();
void SetAngle(long nNewValue);
long GetAutoAttach();
void SetAutoAttach(long nNewValue);
long GetAutoLength();
long GetBorder();
void SetBorder(long nNewValue);
float GetDrop();
long GetDropType();
float GetGap();
void SetGap(float newValue);
float GetLength();
long GetType();
void SetType(long nNewValue);
void AutomaticLength();
void CustomDrop(float Drop);
void CustomLength(float Length);
void PresetDrop(long DropType);
};
/
// ColorFormat wrapper class


class ColorFormat : public COleDispatchDriver
{
public:
ColorFormat() {} // Calls COleDispatchDriver default constructor
ColorFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ColorFormat(const ColorFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetRgb();
void SetRgb(long nNewValue);
long GetType();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
float GetTintAndShade();
void SetTintAndShade(float newValue);
long GetOverPrint();
void SetOverPrint(long nNewValue);
float GetInk(long Index);
void SetInk(long Index, float newValue);
long GetCyan();
void SetCyan(long nNewValue);
long GetMagenta();
void SetMagenta(long nNewValue);
long GetYellow();
void SetYellow(long nNewValue);
long GetBlack();
void SetBlack(long nNewValue);
void SetCMYK(long Cyan, long Magenta, long Yellow, long Black);
};
/
// ConnectorFormat wrapper class


class ConnectorFormat : public COleDispatchDriver
{
public:
ConnectorFormat() {} // Calls COleDispatchDriver default constructor
ConnectorFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ConnectorFormat(const ConnectorFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
long GetBeginConnected();
LPDISPATCH GetBeginConnectedShape();
long GetBeginConnectionSite();
long GetEndConnected();
LPDISPATCH GetEndConnectedShape();
long GetEndConnectionSite();
LPDISPATCH GetParent();
long GetType();
void SetType(long nNewValue);
void BeginConnect(LPDISPATCH* ConnectedShape, long ConnectionSite);
void BeginDisconnect();
void EndConnect(LPDISPATCH* ConnectedShape, long ConnectionSite);
void EndDisconnect();
};
/
// FillFormat wrapper class


class FillFormat : public COleDispatchDriver
{
public:
FillFormat() {} // Calls COleDispatchDriver default constructor
FillFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FillFormat(const FillFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetBackColor();
LPDISPATCH GetForeColor();
long GetGradientColorType();
float GetGradientDegree();
long GetGradientStyle();
long GetGradientVariant();
long GetPattern();
long GetPresetGradientType();
long GetPresetTexture();
CString GetTextureName();
long GetTextureType();
float GetTransparency();
void SetTransparency(float newValue);
long GetType();
long GetVisible();
void SetVisible(long nNewValue);
void OneColorGradient(long Style, long Variant, float Degree);
void Patterned(long Pattern);
void PresetGradient(long Style, long Variant, long PresetGradientType);
void PresetTextured(long PresetTexture);
void Solid();
void TwoColorGradient(long Style, long Variant);
void UserPicture(LPCTSTR PictureFile);
void UserTextured(LPCTSTR TextureFile);
};
/
// FreeformBuilder wrapper class


class FreeformBuilder : public COleDispatchDriver
{
public:
FreeformBuilder() {} // Calls COleDispatchDriver default constructor
FreeformBuilder(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FreeformBuilder(const FreeformBuilder& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void AddNodes(long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3);
LPDISPATCH ConvertToShape(VARIANT* Anchor);
};
/
// LineFormat wrapper class


class LineFormat : public COleDispatchDriver
{
public:
LineFormat() {} // Calls COleDispatchDriver default constructor
LineFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
LineFormat(const LineFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetBackColor();
long GetBeginArrowheadLength();
void SetBeginArrowheadLength(long nNewValue);
long GetBeginArrowheadStyle();
void SetBeginArrowheadStyle(long nNewValue);
long GetBeginArrowheadWidth();
void SetBeginArrowheadWidth(long nNewValue);
long GetDashStyle();
void SetDashStyle(long nNewValue);
long GetEndArrowheadLength();
void SetEndArrowheadLength(long nNewValue);
long GetEndArrowheadStyle();
void SetEndArrowheadStyle(long nNewValue);
long GetEndArrowheadWidth();
void SetEndArrowheadWidth(long nNewValue);
LPDISPATCH GetForeColor();
long GetPattern();
void SetPattern(long nNewValue);
long GetStyle();
void SetStyle(long nNewValue);
float GetTransparency();
void SetTransparency(float newValue);
long GetVisible();
void SetVisible(long nNewValue);
float GetWeight();
void SetWeight(float newValue);
long GetInsetPen();
void SetInsetPen(long nNewValue);
};
/
// PictureFormat wrapper class


class PictureFormat : public COleDispatchDriver
{
public:
PictureFormat() {} // Calls COleDispatchDriver default constructor
PictureFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
PictureFormat(const PictureFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetBrightness();
void SetBrightness(float newValue);
long GetColorType();
void SetColorType(long nNewValue);
float GetContrast();
void SetContrast(float newValue);
float GetCropBottom();
void SetCropBottom(float newValue);
float GetCropLeft();
void SetCropLeft(float newValue);
float GetCropRight();
void SetCropRight(float newValue);
float GetCropTop();
void SetCropTop(float newValue);
long GetTransparencyColor();
void SetTransparencyColor(long nNewValue);
long GetTransparentBackground();
void SetTransparentBackground(long nNewValue);
void IncrementBrightness(float Increment);
void IncrementContrast(float Increment);
};
/
// ShadowFormat wrapper class


class ShadowFormat : public COleDispatchDriver
{
public:
ShadowFormat() {} // Calls COleDispatchDriver default constructor
ShadowFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ShadowFormat(const ShadowFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetForeColor();
long GetObscured();
void SetObscured(long nNewValue);
float GetOffsetX();
void SetOffsetX(float newValue);
float GetOffsetY();
void SetOffsetY(float newValue);
float GetTransparency();
void SetTransparency(float newValue);
long GetType();
void SetType(long nNewValue);
long GetVisible();
void SetVisible(long nNewValue);
void IncrementOffsetX(float Increment);
void IncrementOffsetY(float Increment);
};
/
// ShapeNode wrapper class


class ShapeNode : public COleDispatchDriver
{
public:
ShapeNode() {} // Calls COleDispatchDriver default constructor
ShapeNode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ShapeNode(const ShapeNode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetEditingType();
VARIANT GetPoints();
long GetSegmentType();
};
/
// ShapeNodes wrapper class


class ShapeNodes : public COleDispatchDriver
{
public:
ShapeNodes() {} // Calls COleDispatchDriver default constructor
ShapeNodes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ShapeNodes(const ShapeNodes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
void Delete(long Index);
LPDISPATCH Item(VARIANT* Index);
void SetEditingType(long Index, long EditingType);
void SetPosition(long Index, float X1, float Y1);
void SetSegmentType(long Index, long SegmentType);
void Insert(long Index, long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3);
};
/
// TextEffectFormat wrapper class


class TextEffectFormat : public COleDispatchDriver
{
public:
TextEffectFormat() {} // Calls COleDispatchDriver default constructor
TextEffectFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TextEffectFormat(const TextEffectFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetAlignment();
void SetAlignment(long nNewValue);
long GetFontBold();
void SetFontBold(long nNewValue);
long GetFontItalic();
void SetFontItalic(long nNewValue);
CString GetFontName();
void SetFontName(LPCTSTR lpszNewValue);
float GetFontSize();
void SetFontSize(float newValue);
long GetKernedPairs();
void SetKernedPairs(long nNewValue);
long GetNormalizedHeight();
void SetNormalizedHeight(long nNewValue);
long GetPresetShape();
void SetPresetShape(long nNewValue);
long GetPresetTextEffect();
void SetPresetTextEffect(long nNewValue);
long GetRotatedChars();
void SetRotatedChars(long nNewValue);
CString GetText();
void SetText(LPCTSTR lpszNewValue);
float GetTracking();
void SetTracking(float newValue);
void ToggleVerticalText();
};
/
// ThreeDFormat wrapper class


class ThreeDFormat : public COleDispatchDriver
{
public:
ThreeDFormat() {} // Calls COleDispatchDriver default constructor
ThreeDFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ThreeDFormat(const ThreeDFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetDepth();
void SetDepth(float newValue);
LPDISPATCH GetExtrusionColor();
long GetExtrusionColorType();
void SetExtrusionColorType(long nNewValue);
long GetPerspective();
void SetPerspective(long nNewValue);
long GetPresetExtrusionDirection();
long GetPresetLightingDirection();
void SetPresetLightingDirection(long nNewValue);
long GetPresetLightingSoftness();
void SetPresetLightingSoftness(long nNewValue);
long GetPresetMaterial();
void SetPresetMaterial(long nNewValue);
long GetPresetThreeDFormat();
float GetRotationX();
void SetRotationX(float newValue);
float GetRotationY();
void SetRotationY(float newValue);
long GetVisible();
void SetVisible(long nNewValue);
void IncrementRotationX(float Increment);
void IncrementRotationY(float Increment);
void ResetRotation();
void SetExtrusionDirection(long PresetExtrusionDirection);
void SetThreeDFormat(long PresetThreeDFormat);
};
/
// ApplicationEvents wrapper class


class ApplicationEvents : public COleDispatchDriver
{
public:
ApplicationEvents() {} // Calls COleDispatchDriver default constructor
ApplicationEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ApplicationEvents(const ApplicationEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
};
/
// DocumentEvents wrapper class


class DocumentEvents : public COleDispatchDriver
{
public:
DocumentEvents() {} // Calls COleDispatchDriver default constructor
DocumentEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DocumentEvents(const DocumentEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void New();
void Open();
void Close();
};
/
// OCXEvents wrapper class


class OCXEvents : public COleDispatchDriver
{
public:
OCXEvents() {} // Calls COleDispatchDriver default constructor
OCXEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
OCXEvents(const OCXEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void GotFocus();
void LostFocus();
};
/
// IApplicationEvents wrapper class


class IApplicationEvents : public COleDispatchDriver
{
public:
IApplicationEvents() {} // Calls COleDispatchDriver default constructor
IApplicationEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
IApplicationEvents(const IApplicationEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
};
/
// IApplicationEvents2 wrapper class


class IApplicationEvents2 : public COleDispatchDriver
{
public:
IApplicationEvents2() {} // Calls COleDispatchDriver default constructor
IApplicationEvents2(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
IApplicationEvents2(const IApplicationEvents2& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
};
/
// ApplicationEvents2 wrapper class


class ApplicationEvents2 : public COleDispatchDriver
{
public:
ApplicationEvents2() {} // Calls COleDispatchDriver default constructor
ApplicationEvents2(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ApplicationEvents2(const ApplicationEvents2& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
};
/
// EmailAuthor wrapper class


class EmailAuthor : public COleDispatchDriver
{
public:
EmailAuthor() {} // Calls COleDispatchDriver default constructor
EmailAuthor(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EmailAuthor(const EmailAuthor& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetStyle();
};
/
// EmailOptions wrapper class


class EmailOptions : public COleDispatchDriver
{
public:
EmailOptions() {} // Calls COleDispatchDriver default constructor
EmailOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EmailOptions(const EmailOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetUseThemeStyle();
void SetUseThemeStyle(BOOL bNewValue);
CString GetMarkCommentsWith();
void SetMarkCommentsWith(LPCTSTR lpszNewValue);
BOOL GetMarkComments();
void SetMarkComments(BOOL bNewValue);
LPDISPATCH GetEmailSignature();
LPDISPATCH GetComposeStyle();
LPDISPATCH GetReplyStyle();
CString GetThemeName();
void SetThemeName(LPCTSTR lpszNewValue);
BOOL GetNewColorOnReply();
void SetNewColorOnReply(BOOL bNewValue);
LPDISPATCH GetPlainTextStyle();
BOOL GetUseThemeStyleOnReply();
void SetUseThemeStyleOnReply(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyHeadings();
void SetAutoFormatAsYouTypeApplyHeadings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyBorders();
void SetAutoFormatAsYouTypeApplyBorders(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyBulletedLists();
void SetAutoFormatAsYouTypeApplyBulletedLists(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyNumberedLists();
void SetAutoFormatAsYouTypeApplyNumberedLists(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceQuotes();
void SetAutoFormatAsYouTypeReplaceQuotes(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceSymbols();
void SetAutoFormatAsYouTypeReplaceSymbols(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceOrdinals();
void SetAutoFormatAsYouTypeReplaceOrdinals(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceFractions();
void SetAutoFormatAsYouTypeReplaceFractions(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplacePlainTextEmphasis();
void SetAutoFormatAsYouTypeReplacePlainTextEmphasis(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeFormatListItemBeginning();
void SetAutoFormatAsYouTypeFormatListItemBeginning(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeDefineStyles();
void SetAutoFormatAsYouTypeDefineStyles(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceHyperlinks();
void SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyTables();
void SetAutoFormatAsYouTypeApplyTables(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyFirstIndents();
void SetAutoFormatAsYouTypeApplyFirstIndents(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyDates();
void SetAutoFormatAsYouTypeApplyDates(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeApplyClosings();
void SetAutoFormatAsYouTypeApplyClosings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeMatchParentheses();
void SetAutoFormatAsYouTypeMatchParentheses(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeReplaceFarEastDashes();
void SetAutoFormatAsYouTypeReplaceFarEastDashes(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeDeleteAutoSpaces();
void SetAutoFormatAsYouTypeDeleteAutoSpaces(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeInsertClosings();
void SetAutoFormatAsYouTypeInsertClosings(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeAutoLetterWizard();
void SetAutoFormatAsYouTypeAutoLetterWizard(BOOL bNewValue);
BOOL GetAutoFormatAsYouTypeInsertOvers();
void SetAutoFormatAsYouTypeInsertOvers(BOOL bNewValue);
BOOL GetRelyOnCSS();
void SetRelyOnCSS(BOOL bNewValue);
long GetHTMLFidelity();
void SetHTMLFidelity(long nNewValue);
BOOL GetEmbedSmartTag();
void SetEmbedSmartTag(BOOL bNewValue);
BOOL GetTabIndentKey();
void SetTabIndentKey(BOOL bNewValue);
};
/
// EmailSignature wrapper class


class EmailSignature : public COleDispatchDriver
{
public:
EmailSignature() {} // Calls COleDispatchDriver default constructor
EmailSignature(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EmailSignature(const EmailSignature& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetNewMessageSignature();
void SetNewMessageSignature(LPCTSTR lpszNewValue);
CString GetReplyMessageSignature();
void SetReplyMessageSignature(LPCTSTR lpszNewValue);
LPDISPATCH GetEmailSignatureEntries();
};
/
// Email wrapper class


class Email : public COleDispatchDriver
{
public:
Email() {} // Calls COleDispatchDriver default constructor
Email(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Email(const Email& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetCurrentEmailAuthor();
};
/
// HorizontalLineFormat wrapper class


class HorizontalLineFormat : public COleDispatchDriver
{
public:
HorizontalLineFormat() {} // Calls COleDispatchDriver default constructor
HorizontalLineFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HorizontalLineFormat(const HorizontalLineFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
float GetPercentWidth();
void SetPercentWidth(float newValue);
BOOL GetNoShade();
void SetNoShade(BOOL bNewValue);
long GetAlignment();
void SetAlignment(long nNewValue);
long GetWidthType();
void SetWidthType(long nNewValue);
};
/
// Frameset wrapper class


class Frameset : public COleDispatchDriver
{
public:
Frameset() {} // Calls COleDispatchDriver default constructor
Frameset(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Frameset(const Frameset& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
LPDISPATCH GetParentFrameset();
long GetType();
long GetWidthType();
void SetWidthType(long nNewValue);
long GetHeightType();
void SetHeightType(long nNewValue);
long GetWidth();
void SetWidth(long nNewValue);
long GetHeight();
void SetHeight(long nNewValue);
long GetChildFramesetCount();
LPDISPATCH GetChildFramesetItem(long Index);
float GetFramesetBorderWidth();
void SetFramesetBorderWidth(float newValue);
long GetFramesetBorderColor();
void SetFramesetBorderColor(long nNewValue);
long GetFrameScrollbarType();
void SetFrameScrollbarType(long nNewValue);
BOOL GetFrameResizable();
void SetFrameResizable(BOOL bNewValue);
CString GetFrameName();
void SetFrameName(LPCTSTR lpszNewValue);
BOOL GetFrameDisplayBorders();
void SetFrameDisplayBorders(BOOL bNewValue);
CString GetFrameDefaultURL();
void SetFrameDefaultURL(LPCTSTR lpszNewValue);
BOOL GetFrameLinkToFile();
void SetFrameLinkToFile(BOOL bNewValue);
LPDISPATCH AddNewFrame(long Where);
void Delete();
};
/
// DefaultWebOptions wrapper class


class DefaultWebOptions : public COleDispatchDriver
{
public:
DefaultWebOptions() {} // Calls COleDispatchDriver default constructor
DefaultWebOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DefaultWebOptions(const DefaultWebOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetOptimizeForBrowser();
void SetOptimizeForBrowser(BOOL bNewValue);
long GetBrowserLevel();
void SetBrowserLevel(long nNewValue);
BOOL GetRelyOnCSS();
void SetRelyOnCSS(BOOL bNewValue);
BOOL GetOrganizeInFolder();
void SetOrganizeInFolder(BOOL bNewValue);
BOOL GetUpdateLinksOnSave();
void SetUpdateLinksOnSave(BOOL bNewValue);
BOOL GetUseLongFileNames();
void SetUseLongFileNames(BOOL bNewValue);
BOOL GetCheckIfOfficeIsHTMLEditor();
void SetCheckIfOfficeIsHTMLEditor(BOOL bNewValue);
BOOL GetCheckIfWordIsDefaultHTMLEditor();
void SetCheckIfWordIsDefaultHTMLEditor(BOOL bNewValue);
BOOL GetRelyOnVML();
void SetRelyOnVML(BOOL bNewValue);
BOOL GetAllowPNG();
void SetAllowPNG(BOOL bNewValue);
long GetScreenSize();
void SetScreenSize(long nNewValue);
long GetPixelsPerInch();
void SetPixelsPerInch(long nNewValue);
long GetEncoding();
void SetEncoding(long nNewValue);
BOOL GetAlwaysSaveInDefaultEncoding();
void SetAlwaysSaveInDefaultEncoding(BOOL bNewValue);
LPDISPATCH GetFonts();
CString GetFolderSuffix();
long GetTargetBrowser();
void SetTargetBrowser(long nNewValue);
BOOL GetSaveNewWebPagesAsWebArchives();
void SetSaveNewWebPagesAsWebArchives(BOOL bNewValue);
};
/
// WebOptions wrapper class


class WebOptions : public COleDispatchDriver
{
public:
WebOptions() {} // Calls COleDispatchDriver default constructor
WebOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
WebOptions(const WebOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetOptimizeForBrowser();
void SetOptimizeForBrowser(BOOL bNewValue);
long GetBrowserLevel();
void SetBrowserLevel(long nNewValue);
BOOL GetRelyOnCSS();
void SetRelyOnCSS(BOOL bNewValue);
BOOL GetOrganizeInFolder();
void SetOrganizeInFolder(BOOL bNewValue);
BOOL GetUseLongFileNames();
void SetUseLongFileNames(BOOL bNewValue);
BOOL GetRelyOnVML();
void SetRelyOnVML(BOOL bNewValue);
BOOL GetAllowPNG();
void SetAllowPNG(BOOL bNewValue);
long GetScreenSize();
void SetScreenSize(long nNewValue);
long GetPixelsPerInch();
void SetPixelsPerInch(long nNewValue);
long GetEncoding();
void SetEncoding(long nNewValue);
CString GetFolderSuffix();
void UseDefaultFolderSuffix();
long GetTargetBrowser();
void SetTargetBrowser(long nNewValue);
};
/
// OtherCorrectionsExceptions wrapper class


class OtherCorrectionsExceptions : public COleDispatchDriver
{
public:
OtherCorrectionsExceptions() {} // Calls COleDispatchDriver default constructor
OtherCorrectionsExceptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
OtherCorrectionsExceptions(const OtherCorrectionsExceptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name);
};
/
// OtherCorrectionsException wrapper class


class OtherCorrectionsException : public COleDispatchDriver
{
public:
OtherCorrectionsException() {} // Calls COleDispatchDriver default constructor
OtherCorrectionsException(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
OtherCorrectionsException(const OtherCorrectionsException& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void Delete();
};
/
// EmailSignatureEntries wrapper class


class EmailSignatureEntries : public COleDispatchDriver
{
public:
EmailSignatureEntries() {} // Calls COleDispatchDriver default constructor
EmailSignatureEntries(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EmailSignatureEntries(const EmailSignatureEntries& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, LPDISPATCH Range);
};
/
// EmailSignatureEntry wrapper class


class EmailSignatureEntry : public COleDispatchDriver
{
public:
EmailSignatureEntry() {} // Calls COleDispatchDriver default constructor
EmailSignatureEntry(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EmailSignatureEntry(const EmailSignatureEntry& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
void Delete();
};
/
// HTMLDivision wrapper class


class HTMLDivision : public COleDispatchDriver
{
public:
HTMLDivision() {} // Calls COleDispatchDriver default constructor
HTMLDivision(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HTMLDivision(const HTMLDivision& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
LPDISPATCH GetBorders();
float GetLeftIndent();
void SetLeftIndent(float newValue);
float GetRightIndent();
void SetRightIndent(float newValue);
float GetSpaceBefore();
void SetSpaceBefore(float newValue);
float GetSpaceAfter();
void SetSpaceAfter(float newValue);
LPDISPATCH GetHTMLDivisions();
LPDISPATCH HTMLDivisionParent(VARIANT* LevelsUp);
void Delete();
};
/
// HTMLDivisions wrapper class


class HTMLDivisions : public COleDispatchDriver
{
public:
HTMLDivisions() {} // Calls COleDispatchDriver default constructor
HTMLDivisions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
HTMLDivisions(const HTMLDivisions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
long GetNestingLevel();
LPDISPATCH Add(VARIANT* Range);
LPDISPATCH Item(long Index);
};
/
// DiagramNode wrapper class


class DiagramNode : public COleDispatchDriver
{
public:
DiagramNode() {} // Calls COleDispatchDriver default constructor
DiagramNode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DiagramNode(const DiagramNode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetChildren();
LPDISPATCH GetShape();
LPDISPATCH GetRoot();
LPDISPATCH GetDiagram();
long GetLayout();
void SetLayout(long nNewValue);
LPDISPATCH GetTextShape();
LPDISPATCH AddNode(long Pos, long NodeType);
void Delete();
void MoveNode(LPDISPATCH* TargetNode, long Pos);
void ReplaceNode(LPDISPATCH* TargetNode);
void SwapNode(LPDISPATCH* TargetNode, long Pos);
LPDISPATCH CloneNode(BOOL copyChildren, LPDISPATCH* TargetNode, long Pos);
void TransferChildren(LPDISPATCH* ReceivingNode);
LPDISPATCH NextNode();
LPDISPATCH PrevNode();
};
/
// DiagramNodeChildren wrapper class


class DiagramNodeChildren : public COleDispatchDriver
{
public:
DiagramNodeChildren() {} // Calls COleDispatchDriver default constructor
DiagramNodeChildren(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DiagramNodeChildren(const DiagramNodeChildren& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPUNKNOWN Get_NewEnum();
LPDISPATCH GetParent();
long GetCount();
LPDISPATCH GetFirstChild();
LPDISPATCH GetLastChild();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH AddNode(VARIANT* Index, long NodeType);
void SelectAll();
};
/
// DiagramNodes wrapper class


class DiagramNodes : public COleDispatchDriver
{
public:
DiagramNodes() {} // Calls COleDispatchDriver default constructor
DiagramNodes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DiagramNodes(const DiagramNodes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPUNKNOWN Get_NewEnum();
LPDISPATCH GetParent();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
void SelectAll();
};
/
// Diagram wrapper class


class Diagram : public COleDispatchDriver
{
public:
Diagram() {} // Calls COleDispatchDriver default constructor
Diagram(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Diagram(const Diagram& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetNodes();
long GetType();
long GetAutoLayout();
void SetAutoLayout(long nNewValue);
long GetReverse();
void SetReverse(long nNewValue);
long GetAutoFormat();
void SetAutoFormat(long nNewValue);
void Convert(long Type);
void FitText();
};
/
// CustomProperty wrapper class


class CustomProperty : public COleDispatchDriver
{
public:
CustomProperty() {} // Calls COleDispatchDriver default constructor
CustomProperty(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CustomProperty(const CustomProperty& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
CString GetValue();
void SetValue(LPCTSTR lpszNewValue);
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void Delete();
};
/
// CustomProperties wrapper class


class CustomProperties : public COleDispatchDriver
{
public:
CustomProperties() {} // Calls COleDispatchDriver default constructor
CustomProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CustomProperties(const CustomProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, LPCTSTR Value);
};
/
// SmartTag wrapper class


class SmartTag : public COleDispatchDriver
{
public:
SmartTag() {} // Calls COleDispatchDriver default constructor
SmartTag(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTag(const SmartTag& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
CString GetXml();
LPDISPATCH GetRange();
CString GetDownloadURL();
LPDISPATCH GetProperties();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void Select();
void Delete();
LPDISPATCH GetSmartTagActions();
LPDISPATCH GetXMLNode();
};
/
// SmartTags wrapper class


class SmartTags : public COleDispatchDriver
{
public:
SmartTags() {} // Calls COleDispatchDriver default constructor
SmartTags(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTags(const SmartTags& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Name, VARIANT* Range, VARIANT* Properties);
LPDISPATCH SmartTagsByType(LPCTSTR Name);
};
/
// StyleSheet wrapper class


class StyleSheet : public COleDispatchDriver
{
public:
StyleSheet() {} // Calls COleDispatchDriver default constructor
StyleSheet(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
StyleSheet(const StyleSheet& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetFullName();
long GetIndex();
CString GetName();
CString GetPath();
long GetType();
void SetType(long nNewValue);
CString GetTitle();
void SetTitle(LPCTSTR lpszNewValue);
void Move(long Precedence);
void Delete();
};
/
// StyleSheets wrapper class


class StyleSheets : public COleDispatchDriver
{
public:
StyleSheets() {} // Calls COleDispatchDriver default constructor
StyleSheets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
StyleSheets(const StyleSheets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR FileName, long LinkType, LPCTSTR Title, long Precedence);
};
/
// MappedDataField wrapper class


class MappedDataField : public COleDispatchDriver
{
public:
MappedDataField() {} // Calls COleDispatchDriver default constructor
MappedDataField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MappedDataField(const MappedDataField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetIndex();
CString GetDataFieldName();
CString GetName();
CString GetValue();
long GetDataFieldIndex();
void SetDataFieldIndex(long nNewValue);
};
/
// MappedDataFields wrapper class


class MappedDataFields : public COleDispatchDriver
{
public:
MappedDataFields() {} // Calls COleDispatchDriver default constructor
MappedDataFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
MappedDataFields(const MappedDataFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(long Index);
};
/
// CanvasShapes wrapper class


class CanvasShapes : public COleDispatchDriver
{
public:
CanvasShapes() {} // Calls COleDispatchDriver default constructor
CanvasShapes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CanvasShapes(const CanvasShapes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPUNKNOWN Get_NewEnum();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH AddCallout(long Type, float Left, float Top, float Width, float Height);
LPDISPATCH AddConnector(long Type, float BeginX, float BeginY, float EndX, float EndY);
LPDISPATCH AddCurve(VARIANT* SafeArrayOfPoints);
LPDISPATCH AddLabel(long Orientation, float Left, float Top, float Width, float Height);
LPDISPATCH AddLine(float BeginX, float BeginY, float EndX, float EndY);
LPDISPATCH AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height);
LPDISPATCH AddPolyline(VARIANT* SafeArrayOfPoints);
LPDISPATCH AddShape(long Type, float Left, float Top, float Width, float Height);
LPDISPATCH AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top);
LPDISPATCH AddTextbox(long Orientation, float Left, float Top, float Width, float Height);
LPDISPATCH BuildFreeform(long EditingType, float X1, float Y1);
LPDISPATCH Range(VARIANT* Index);
void SelectAll();
};
/
// TableStyle wrapper class


class TableStyle : public COleDispatchDriver
{
public:
TableStyle() {} // Calls COleDispatchDriver default constructor
TableStyle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TableStyle(const TableStyle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetAllowPageBreaks();
void SetAllowPageBreaks(BOOL bNewValue);
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
float GetBottomPadding();
void SetBottomPadding(float newValue);
float GetLeftPadding();
void SetLeftPadding(float newValue);
float GetTopPadding();
void SetTopPadding(float newValue);
float GetRightPadding();
void SetRightPadding(float newValue);
long GetAlignment();
void SetAlignment(long nNewValue);
float GetSpacing();
void SetSpacing(float newValue);
LPDISPATCH Condition(long ConditionCode);
long GetTableDirection();
void SetTableDirection(long nNewValue);
long GetAllowBreakAcrossPage();
void SetAllowBreakAcrossPage(long nNewValue);
float GetLeftIndent();
void SetLeftIndent(float newValue);
LPDISPATCH GetShading();
long GetRowStripe();
void SetRowStripe(long nNewValue);
long GetColumnStripe();
void SetColumnStripe(long nNewValue);
};
/
// ConditionalStyle wrapper class


class ConditionalStyle : public COleDispatchDriver
{
public:
ConditionalStyle() {} // Calls COleDispatchDriver default constructor
ConditionalStyle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ConditionalStyle(const ConditionalStyle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetShading();
LPDISPATCH GetBorders();
void SetBorders(LPDISPATCH newValue);
float GetBottomPadding();
void SetBottomPadding(float newValue);
float GetTopPadding();
void SetTopPadding(float newValue);
float GetLeftPadding();
void SetLeftPadding(float newValue);
float GetRightPadding();
void SetRightPadding(float newValue);
LPDISPATCH GetParagraphFormat();
void SetParagraphFormat(LPDISPATCH newValue);
LPDISPATCH GetFont();
void SetFont(LPDISPATCH newValue);
};
/
// FootnoteOptions wrapper class


class FootnoteOptions : public COleDispatchDriver
{
public:
FootnoteOptions() {} // Calls COleDispatchDriver default constructor
FootnoteOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
FootnoteOptions(const FootnoteOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLocation();
void SetLocation(long nNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
long GetNumberingRule();
void SetNumberingRule(long nNewValue);
};
/
// EndnoteOptions wrapper class


class EndnoteOptions : public COleDispatchDriver
{
public:
EndnoteOptions() {} // Calls COleDispatchDriver default constructor
EndnoteOptions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
EndnoteOptions(const EndnoteOptions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLocation();
void SetLocation(long nNewValue);
long GetNumberStyle();
void SetNumberStyle(long nNewValue);
long GetStartingNumber();
void SetStartingNumber(long nNewValue);
long GetNumberingRule();
void SetNumberingRule(long nNewValue);
};
/
// Reviewers wrapper class


class Reviewers : public COleDispatchDriver
{
public:
Reviewers() {} // Calls COleDispatchDriver default constructor
Reviewers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Reviewers(const Reviewers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
};
/
// Reviewer wrapper class


class Reviewer : public COleDispatchDriver
{
public:
Reviewer() {} // Calls COleDispatchDriver default constructor
Reviewer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Reviewer(const Reviewer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
};
/
// TaskPane wrapper class


class TaskPane : public COleDispatchDriver
{
public:
TaskPane() {} // Calls COleDispatchDriver default constructor
TaskPane(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TaskPane(const TaskPane& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetVisible();
void SetVisible(BOOL bNewValue);
};
/
// TaskPanes wrapper class


class TaskPanes : public COleDispatchDriver
{
public:
TaskPanes() {} // Calls COleDispatchDriver default constructor
TaskPanes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
TaskPanes(const TaskPanes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// IApplicationEvents3 wrapper class


class IApplicationEvents3 : public COleDispatchDriver
{
public:
IApplicationEvents3() {} // Calls COleDispatchDriver default constructor
IApplicationEvents3(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
IApplicationEvents3(const IApplicationEvents3& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
void EPostagePropertyDialog(LPDISPATCH Doc);
void EPostageInsert(LPDISPATCH Doc);
void MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult);
void MailMergeAfterRecordMerge(LPDISPATCH Doc);
void MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel);
void MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel);
void MailMergeDataSourceLoad(LPDISPATCH Doc);
void MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled);
void MailMergeWizardSendToCustom(LPDISPATCH Doc);
void MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled);
void WindowSize(LPDISPATCH Doc, LPDISPATCH Wn);
};
/
// ApplicationEvents3 wrapper class


class ApplicationEvents3 : public COleDispatchDriver
{
public:
ApplicationEvents3() {} // Calls COleDispatchDriver default constructor
ApplicationEvents3(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ApplicationEvents3(const ApplicationEvents3& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
void EPostagePropertyDialog(LPDISPATCH Doc);
void EPostageInsert(LPDISPATCH Doc);
void MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult);
void MailMergeAfterRecordMerge(LPDISPATCH Doc);
void MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel);
void MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel);
void MailMergeDataSourceLoad(LPDISPATCH Doc);
void MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled);
void MailMergeWizardSendToCustom(LPDISPATCH Doc);
void MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled);
void WindowSize(LPDISPATCH Doc, LPDISPATCH Wn);
};
/
// SmartTagAction wrapper class


class SmartTagAction : public COleDispatchDriver
{
public:
SmartTagAction() {} // Calls COleDispatchDriver default constructor
SmartTagAction(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagAction(const SmartTagAction& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void Execute();
long GetType();
BOOL GetPresentInPane();
BOOL GetExpandHelp();
void SetExpandHelp(BOOL bNewValue);
BOOL GetCheckboxState();
void SetCheckboxState(BOOL bNewValue);
CString GetTextboxText();
void SetTextboxText(LPCTSTR lpszNewValue);
long GetListSelection();
void SetListSelection(long nNewValue);
long GetRadioGroupSelection();
void SetRadioGroupSelection(long nNewValue);
BOOL GetExpandDocumentFragment();
void SetExpandDocumentFragment(BOOL bNewValue);
LPDISPATCH GetActiveXControl();
};
/
// SmartTagActions wrapper class


class SmartTagActions : public COleDispatchDriver
{
public:
SmartTagActions() {} // Calls COleDispatchDriver default constructor
SmartTagActions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagActions(const SmartTagActions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
void ReloadActions();
};
/
// SmartTagRecognizer wrapper class


class SmartTagRecognizer : public COleDispatchDriver
{
public:
SmartTagRecognizer() {} // Calls COleDispatchDriver default constructor
SmartTagRecognizer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagRecognizer(const SmartTagRecognizer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetFullName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetEnabled();
void SetEnabled(BOOL bNewValue);
CString GetProgID();
CString GetCaption();
};
/
// SmartTagRecognizers wrapper class


class SmartTagRecognizers : public COleDispatchDriver
{
public:
SmartTagRecognizers() {} // Calls COleDispatchDriver default constructor
SmartTagRecognizers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagRecognizers(const SmartTagRecognizers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
void ReloadRecognizers();
};
/
// SmartTagType wrapper class


class SmartTagType : public COleDispatchDriver
{
public:
SmartTagType() {} // Calls COleDispatchDriver default constructor
SmartTagType(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagType(const SmartTagType& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetSmartTagActions();
LPDISPATCH GetSmartTagRecognizers();
CString GetFriendlyName();
};
/
// SmartTagTypes wrapper class


class SmartTagTypes : public COleDispatchDriver
{
public:
SmartTagTypes() {} // Calls COleDispatchDriver default constructor
SmartTagTypes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
SmartTagTypes(const SmartTagTypes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
void ReloadAll();
};
/
// Line wrapper class


class Line : public COleDispatchDriver
{
public:
Line() {} // Calls COleDispatchDriver default constructor
Line(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Line(const Line& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLineType();
long GetLeft();
long GetTop();
long GetWidth();
long GetHeight();
LPDISPATCH GetRange();
LPDISPATCH GetRectangles();
};
/
// Lines wrapper class


class Lines : public COleDispatchDriver
{
public:
Lines() {} // Calls COleDispatchDriver default constructor
Lines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Lines(const Lines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Rectangle wrapper class


class Rectangle : public COleDispatchDriver
{
public:
Rectangle() {} // Calls COleDispatchDriver default constructor
Rectangle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Rectangle(const Rectangle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetRectangleType();
long GetLeft();
long GetTop();
long GetWidth();
long GetHeight();
LPDISPATCH GetRange();
LPDISPATCH GetLines();
};
/
// Rectangles wrapper class


class Rectangles : public COleDispatchDriver
{
public:
Rectangles() {} // Calls COleDispatchDriver default constructor
Rectangles(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Rectangles(const Rectangles& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Break wrapper class


class Break : public COleDispatchDriver
{
public:
Break() {} // Calls COleDispatchDriver default constructor
Break(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Break(const Break& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
long GetPageIndex();
};
/
// Breaks wrapper class


class Breaks : public COleDispatchDriver
{
public:
Breaks() {} // Calls COleDispatchDriver default constructor
Breaks(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Breaks(const Breaks& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// Page wrapper class


class Page : public COleDispatchDriver
{
public:
Page() {} // Calls COleDispatchDriver default constructor
Page(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Page(const Page& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetLeft();
long GetTop();
long GetWidth();
long GetHeight();
LPDISPATCH GetRectangles();
LPDISPATCH GetBreaks();
};
/
// Pages wrapper class


class Pages : public COleDispatchDriver
{
public:
Pages() {} // Calls COleDispatchDriver default constructor
Pages(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Pages(const Pages& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
};
/
// XMLNode wrapper class


class XMLNode : public COleDispatchDriver
{
public:
XMLNode() {} // Calls COleDispatchDriver default constructor
XMLNode(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLNode(const XMLNode& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetBaseName();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH GetRange();
CString GetText();
void SetText(LPCTSTR lpszNewValue);
CString GetNamespaceURI();
CString GetXml(BOOL DataOnly);
LPDISPATCH GetNextSibling();
LPDISPATCH GetPreviousSibling();
LPDISPATCH GetParentNode();
LPDISPATCH GetFirstChild();
LPDISPATCH GetLastChild();
LPDISPATCH GetOwnerDocument();
long GetNodeType();
LPDISPATCH GetChildNodes();
LPDISPATCH GetAttributes();
CString GetNodeValue();
void SetNodeValue(LPCTSTR lpszNewValue);
BOOL GetHasChildNodes();
LPDISPATCH SelectSingleNode(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes);
LPDISPATCH SelectNodes(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes);
LPDISPATCH GetChildNodeSuggestions();
long GetLevel();
long GetValidationStatus();
LPDISPATCH GetSmartTag();
CString GetValidationErrorText(BOOL Advanced);
CString GetPlaceholderText();
void SetPlaceholderText(LPCTSTR lpszNewValue);
void Delete();
void Copy();
void RemoveChild(LPDISPATCH ChildElement);
void Cut();
void Validate();
void SetValidationError(long Status, VARIANT* ErrorText, BOOL ClearedAutomatically);
};
/
// XMLNodes wrapper class


class XMLNodes : public COleDispatchDriver
{
public:
XMLNodes() {} // Calls COleDispatchDriver default constructor
XMLNodes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLNodes(const XMLNodes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(long Index);
LPDISPATCH Add(LPCTSTR Name, LPCTSTR Namespace, VARIANT* Range);
};
/
// XMLSchemaReference wrapper class


class XMLSchemaReference : public COleDispatchDriver
{
public:
XMLSchemaReference() {} // Calls COleDispatchDriver default constructor
XMLSchemaReference(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLSchemaReference(const XMLSchemaReference& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetNamespaceURI();
CString GetLocation();
void Delete();
void Reload();
};
/
// XMLSchemaReferences wrapper class


class XMLSchemaReferences : public COleDispatchDriver
{
public:
XMLSchemaReferences() {} // Calls COleDispatchDriver default constructor
XMLSchemaReferences(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLSchemaReferences(const XMLSchemaReferences& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
BOOL GetAutomaticValidation();
void SetAutomaticValidation(BOOL bNewValue);
BOOL GetAllowSaveAsXMLWithoutValidation();
void SetAllowSaveAsXMLWithoutValidation(BOOL bNewValue);
BOOL GetHideValidationErrors();
void SetHideValidationErrors(BOOL bNewValue);
BOOL GetIgnoreMixedContent();
void SetIgnoreMixedContent(BOOL bNewValue);
BOOL GetShowPlaceholderText();
void SetShowPlaceholderText(BOOL bNewValue);
LPDISPATCH Item(VARIANT* Index);
void Validate();
LPDISPATCH Add(VARIANT* NamespaceURI, VARIANT* Alias, VARIANT* FileName, BOOL InstallForAllUsers);
};
/
// XMLChildNodeSuggestion wrapper class


class XMLChildNodeSuggestion : public COleDispatchDriver
{
public:
XMLChildNodeSuggestion() {} // Calls COleDispatchDriver default constructor
XMLChildNodeSuggestion(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLChildNodeSuggestion(const XMLChildNodeSuggestion& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetBaseName();
CString GetNamespaceURI();
LPDISPATCH GetXMLSchemaReference();
LPDISPATCH Insert(VARIANT* Range);
};
/
// XMLChildNodeSuggestions wrapper class


class XMLChildNodeSuggestions : public COleDispatchDriver
{
public:
XMLChildNodeSuggestions() {} // Calls COleDispatchDriver default constructor
XMLChildNodeSuggestions(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLChildNodeSuggestions(const XMLChildNodeSuggestions& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
};
/
// XMLNamespace wrapper class


class XMLNamespace : public COleDispatchDriver
{
public:
XMLNamespace() {} // Calls COleDispatchDriver default constructor
XMLNamespace(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLNamespace(const XMLNamespace& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetUri();
CString GetLocation(BOOL AllUsers);
void SetLocation(BOOL AllUsers, LPCTSTR lpszNewValue);
CString GetAlias(BOOL AllUsers);
void SetAlias(BOOL AllUsers, LPCTSTR lpszNewValue);
LPDISPATCH GetXSLTransforms();
LPDISPATCH GetDefaultTransform(BOOL AllUsers);
void SetDefaultTransform(BOOL AllUsers, LPDISPATCH newValue);
void AttachToDocument(VARIANT* Document);
void Delete();
};
/
// XMLNamespaces wrapper class


class XMLNamespaces : public COleDispatchDriver
{
public:
XMLNamespaces() {} // Calls COleDispatchDriver default constructor
XMLNamespaces(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XMLNamespaces(const XMLNamespaces& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Path, VARIANT* NamespaceURI, VARIANT* Alias, BOOL InstallForAllUsers);
void InstallManifest(LPCTSTR Path, BOOL InstallForAllUsers);
};
/
// XSLTransform wrapper class


class XSLTransform : public COleDispatchDriver
{
public:
XSLTransform() {} // Calls COleDispatchDriver default constructor
XSLTransform(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XSLTransform(const XSLTransform& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
CString GetAlias(BOOL AllUsers);
void SetAlias(BOOL AllUsers, LPCTSTR lpszNewValue);
CString GetLocation(BOOL AllUsers);
void SetLocation(BOOL AllUsers, LPCTSTR lpszNewValue);
void Delete();
};
/
// XSLTransforms wrapper class


class XSLTransforms : public COleDispatchDriver
{
public:
XSLTransforms() {} // Calls COleDispatchDriver default constructor
XSLTransforms(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
XSLTransforms(const XSLTransforms& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPUNKNOWN Get_NewEnum();
long GetCount();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(LPCTSTR Location, VARIANT* Alias, BOOL InstallForAllUsers);
};
/
// Editors wrapper class


class Editors : public COleDispatchDriver
{
public:
Editors() {} // Calls COleDispatchDriver default constructor
Editors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Editors(const Editors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
long GetCount();
LPDISPATCH Item(VARIANT* Index);
LPDISPATCH Add(VARIANT* EditorID);
};
/
// Editor wrapper class


class Editor : public COleDispatchDriver
{
public:
Editor() {} // Calls COleDispatchDriver default constructor
Editor(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
Editor(const Editor& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
CString GetId();
CString GetName();
LPDISPATCH GetRange();
LPDISPATCH GetNextRange();
LPDISPATCH GetApplication();
long GetCreator();
LPDISPATCH GetParent();
void Delete();
void DeleteAll();
void SelectAll();
};
/
// IApplicationEvents4 wrapper class


class IApplicationEvents4 : public COleDispatchDriver
{
public:
IApplicationEvents4() {} // Calls COleDispatchDriver default constructor
IApplicationEvents4(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
IApplicationEvents4(const IApplicationEvents4& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
void EPostagePropertyDialog(LPDISPATCH Doc);
void EPostageInsert(LPDISPATCH Doc);
void MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult);
void MailMergeAfterRecordMerge(LPDISPATCH Doc);
void MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel);
void MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel);
void MailMergeDataSourceLoad(LPDISPATCH Doc);
void MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled);
void MailMergeWizardSendToCustom(LPDISPATCH Doc);
void MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled);
void WindowSize(LPDISPATCH Doc, LPDISPATCH Wn);
void XMLSelectionChange(LPDISPATCH Sel, LPDISPATCH OldXMLNode, LPDISPATCH NewXMLNode, long* Reason);
void XMLValidationError(LPDISPATCH XMLNode);
void DocumentSync(LPDISPATCH Doc, long SyncEventType);
void EPostageInsertEx(LPDISPATCH Doc, long cpDeliveryAddrStart, long cpDeliveryAddrEnd, long cpReturnAddrStart, long cpReturnAddrEnd, long xaWidth, long yaHeight, LPCTSTR bstrPrinterName, LPCTSTR bstrPaperFeed, BOOL fPrint, BOOL* fCancel);
};
/
// ApplicationEvents4 wrapper class


class ApplicationEvents4 : public COleDispatchDriver
{
public:
ApplicationEvents4() {} // Calls COleDispatchDriver default constructor
ApplicationEvents4(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
ApplicationEvents4(const ApplicationEvents4& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void Quit();
void DocumentChange();
void DocumentOpen(LPDISPATCH Doc);
void DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel);
void DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel);
void NewDocument(LPDISPATCH Doc);
void WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn);
void WindowSelectionChange(LPDISPATCH Sel);
void WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel);
void WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel);
void EPostagePropertyDialog(LPDISPATCH Doc);
void EPostageInsert(LPDISPATCH Doc);
void MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult);
void MailMergeAfterRecordMerge(LPDISPATCH Doc);
void MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel);
void MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel);
void MailMergeDataSourceLoad(LPDISPATCH Doc);
void MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled);
void MailMergeWizardSendToCustom(LPDISPATCH Doc);
void MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled);
void WindowSize(LPDISPATCH Doc, LPDISPATCH Wn);
void XMLSelectionChange(LPDISPATCH Sel, LPDISPATCH OldXMLNode, LPDISPATCH NewXMLNode, long* Reason);
void XMLValidationError(LPDISPATCH XMLNode);
void DocumentSync(LPDISPATCH Doc, long SyncEventType);
void EPostageInsertEx(LPDISPATCH Doc, long cpDeliveryAddrStart, long cpDeliveryAddrEnd, long cpReturnAddrStart, long cpReturnAddrEnd, long xaWidth, long yaHeight, LPCTSTR bstrPrinterName, LPCTSTR bstrPaperFeed, BOOL fPrint, BOOL* fCancel);
};
/
// DocumentEvents2 wrapper class


class DocumentEvents2 : public COleDispatchDriver
{
public:
DocumentEvents2() {} // Calls COleDispatchDriver default constructor
DocumentEvents2(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
DocumentEvents2(const DocumentEvents2& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}


// Attributes
public:


// Operations
public:
void New();
void Open();
void Close();
void Sync(long SyncEventType);
void XMLAfterInsert(LPDISPATCH NewXMLNode, BOOL InUndoRedo);
void XMLBeforeDelete(LPDISPATCH DeletedRange, LPDISPATCH OldXMLNode, BOOL InUndoRedo);
};

// Machine generated IDispatch wrapper class(es) created with ClassWizard


#include "stdafx.h"
#include "msword.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif






/
// _Application properties


/
// _Application operations


LPDISPATCH _Application::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Application::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Application::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetDocuments()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetWindows()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetActiveDocument()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetActiveWindow()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetSelection()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetWordBasic()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetRecentFiles()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetNormalTemplate()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetSystem()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetAutoCorrect()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetFontNames()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetLandscapeFontNames()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetPortraitFontNames()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetLanguages()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetAssistant()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetBrowser()
{
LPDISPATCH result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetFileConverters()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetMailingLabel()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetDialogs()
{
LPDISPATCH result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetCaptionLabels()
{
LPDISPATCH result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetAutoCaptions()
{
LPDISPATCH result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetAddIns()
{
LPDISPATCH result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetVisible()
{
BOOL result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _Application::GetVersion()
{
CString result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL _Application::GetScreenUpdating()
{
BOOL result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetScreenUpdating(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Application::GetPrintPreview()
{
BOOL result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetPrintPreview(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetTasks()
{
LPDISPATCH result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetDisplayStatusBar()
{
BOOL result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayStatusBar(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Application::GetSpecialMode()
{
BOOL result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long _Application::GetUsableWidth()
{
long result;
InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long _Application::GetUsableHeight()
{
long result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL _Application::GetMathCoprocessorAvailable()
{
BOOL result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL _Application::GetMouseAvailable()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


VARIANT _Application::GetInternational(long Index)
{
VARIANT result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
Index);
return result;
}


CString _Application::GetBuild()
{
CString result;
InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL _Application::GetCapsLock()
{
BOOL result;
InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL _Application::GetNumLock()
{
BOOL result;
InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString _Application::GetUserName_()
{
CString result;
InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetUserName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Application::GetUserInitials()
{
CString result;
InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetUserInitials(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Application::GetUserAddress()
{
CString result;
InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetUserAddress(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x36, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Application::GetMacroContainer()
{
LPDISPATCH result;
InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetDisplayRecentFiles()
{
BOOL result;
InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayRecentFiles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x38, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetCommandBars()
{
LPDISPATCH result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetSynonymInfo(LPCTSTR Word, VARIANT* LanguageID)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
Word, LanguageID);
return result;
}


LPDISPATCH _Application::GetVbe()
{
LPDISPATCH result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Application::GetDefaultSaveFormat()
{
CString result;
InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetDefaultSaveFormat(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Application::GetListGalleries()
{
LPDISPATCH result;
InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Application::GetActivePrinter()
{
CString result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetActivePrinter(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Application::GetTemplates()
{
LPDISPATCH result;
InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetCustomizationContext()
{
LPDISPATCH result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Application::SetCustomizationContext(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Application::GetKeyBindings()
{
LPDISPATCH result;
InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetKeysBoundTo(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 _Application::GetFindKey(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 _Application::GetCaption()
{
CString result;
InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetCaption(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Application::GetPath()
{
CString result;
InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL _Application::GetDisplayScrollBars()
{
BOOL result;
InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayScrollBars(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _Application::GetStartupPath()
{
CString result;
InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetStartupPath(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _Application::GetBackgroundSavingStatus()
{
long result;
InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long _Application::GetBackgroundPrintingStatus()
{
long result;
InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long _Application::GetLeft()
{
long result;
InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetLeft(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x57, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Application::GetTop()
{
long result;
InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetTop(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x58, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Application::GetWidth()
{
long result;
InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x59, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Application::GetHeight()
{
long result;
InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetHeight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Application::GetWindowState()
{
long result;
InvokeHelper(0x5b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetWindowState(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Application::GetDisplayAutoCompleteTips()
{
BOOL result;
InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayAutoCompleteTips(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetOptions()
{
LPDISPATCH result;
InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Application::GetDisplayAlerts()
{
long result;
InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayAlerts(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _Application::GetCustomDictionaries()
{
LPDISPATCH result;
InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Application::GetPathSeparator()
{
CString result;
InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetStatusBar(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Application::GetMAPIAvailable()
{
BOOL result;
InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL _Application::GetDisplayScreenTips()
{
BOOL result;
InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDisplayScreenTips(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Application::GetEnableCancelKey()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetEnableCancelKey(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Application::GetUserControl()
{
BOOL result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetFileSearch()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Application::GetMailSystem()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString _Application::GetDefaultTableSeparator()
{
CString result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetDefaultTableSeparator(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Application::GetShowVisualBasicEditor()
{
BOOL result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetShowVisualBasicEditor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _Application::GetBrowseExtraFileTypes()
{
CString result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetBrowseExtraFileTypes(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Application::GetIsObjectValid(LPDISPATCH Object)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
Object);
return result;
}


LPDISPATCH _Application::GetHangulHanjaDictionaries()
{
LPDISPATCH result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetMailMessage()
{
LPDISPATCH result;
InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetFocusInMailHeader()
{
BOOL result;
InvokeHelper(0x182, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::Quit(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SaveChanges, OriginalFormat, RouteDocument);
}


void _Application::ScreenRefresh()
{
InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::LookupNameProperties(LPCTSTR Name)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name);
}


void _Application::SubstituteFont(LPCTSTR UnavailableFont, LPCTSTR SubstituteFont)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
UnavailableFont, SubstituteFont);
}


BOOL _Application::Repeat(VARIANT* Times)
{
BOOL result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x131, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Times);
return result;
}


void _Application::DDEExecute(long Channel, LPCTSTR Command)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR;
InvokeHelper(0x136, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel, Command);
}


long _Application::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 _Application::DDEPoke(long Channel, LPCTSTR Item, LPCTSTR Data)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_BSTR;
InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel, Item, Data);
}


CString _Application::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 _Application::DDETerminate(long Channel)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel);
}


void _Application::DDETerminateAll()
{
InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long _Application::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 _Application::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 _Application::OrganizerCopy(LPCTSTR Source, LPCTSTR Destination, LPCTSTR Name, long Object)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4;
InvokeHelper(0x13e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Source, Destination, Name, Object);
}


void _Application::OrganizerDelete(LPCTSTR Source, LPCTSTR Name, long Object)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_I4;
InvokeHelper(0x13f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Source, Name, Object);
}


void _Application::OrganizerRename(LPCTSTR Source, LPCTSTR Name, LPCTSTR NewName, long Object)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4;
InvokeHelper(0x140, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Source, Name, NewName, Object);
}


CString _Application::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 _Application::CheckGrammar(LPCTSTR String)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x143, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
String);
return result;
}


BOOL _Application::CheckSpelling(LPCTSTR Word, 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,
Word, CustomDictionary, IgnoreUppercase, MainDictionary, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10);
return result;
}


void _Application::ResetIgnoreAll()
{
InvokeHelper(0x146, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Application::GetSpellingSuggestions(LPCTSTR Word, 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,
Word, CustomDictionary, IgnoreUppercase, MainDictionary, SuggestionMode, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, 
CustomDictionary10);
return result;
}


void _Application::GoBack()
{
InvokeHelper(0x148, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::Help(VARIANT* HelpType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x149, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
HelpType);
}


void _Application::AutomaticChange()
{
InvokeHelper(0x14a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::ShowMe()
{
InvokeHelper(0x14b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::HelpTool()
{
InvokeHelper(0x14c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Application::NewWindow()
{
LPDISPATCH result;
InvokeHelper(0x159, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Application::ListCommands(BOOL ListAllCommands)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ListAllCommands);
}


void _Application::ShowClipboard()
{
InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::OnTime(VARIANT* When, LPCTSTR Name, VARIANT* Tolerance)
{
static BYTE parms[] =
VTS_PVARIANT VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x15e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
When, Name, Tolerance);
}


void _Application::NextLetter()
{
InvokeHelper(0x15f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


short _Application::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 _Application::CleanString(LPCTSTR String)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x162, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
String);
return result;
}


void _Application::SendFax()
{
InvokeHelper(0x164, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::ChangeFileOpenDirectory(LPCTSTR Path)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x165, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Path);
}


void _Application::GoForward()
{
InvokeHelper(0x167, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::Move(long Left, long Top)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x168, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Left, Top);
}


void _Application::Resize(long Width, long Height)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x169, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Width, Height);
}


float _Application::InchesToPoints(float Inches)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x172, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Inches);
return result;
}


float _Application::CentimetersToPoints(float Centimeters)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x173, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Centimeters);
return result;
}


float _Application::MillimetersToPoints(float Millimeters)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x174, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Millimeters);
return result;
}


float _Application::PicasToPoints(float Picas)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x175, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Picas);
return result;
}


float _Application::LinesToPoints(float Lines)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x176, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Lines);
return result;
}


float _Application::PointsToInches(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17c, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Application::PointsToCentimeters(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17d, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Application::PointsToMillimeters(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17e, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Application::PointsToPicas(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17f, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Application::PointsToLines(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x180, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


void _Application::Activate()
{
InvokeHelper(0x181, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


float _Application::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 _Application::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 _Application::KeyboardLatin()
{
InvokeHelper(0x190, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::KeyboardBidi()
{
InvokeHelper(0x191, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Application::ToggleKeyboard()
{
InvokeHelper(0x192, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long _Application::Keyboard(long LangId)
{
long result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1be, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
LangId);
return result;
}


CString _Application::ProductCode()
{
CString result;
InvokeHelper(0x194, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::DefaultWebOptions()
{
LPDISPATCH result;
InvokeHelper(0x195, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Application::SetDefaultTheme(LPCTSTR Name, long DocumentType)
{
static BYTE parms[] =
VTS_BSTR VTS_I4;
InvokeHelper(0x19e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, DocumentType);
}


CString _Application::GetDefaultTheme(long DocumentType)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1a0, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
DocumentType);
return result;
}


LPDISPATCH _Application::GetEmailOptions()
{
LPDISPATCH result;
InvokeHelper(0x185, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Application::GetLanguage()
{
long result;
InvokeHelper(0x187, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetCOMAddIns()
{
LPDISPATCH result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetCheckLanguage()
{
BOOL result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetCheckLanguage(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetLanguageSettings()
{
LPDISPATCH result;
InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetAnswerWizard()
{
LPDISPATCH result;
InvokeHelper(0x199, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Application::GetFeatureInstall()
{
long result;
InvokeHelper(0x1bf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetFeatureInstall(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1bf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


VARIANT _Application::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 _Application::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, NULL, parms,
Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, FileName, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight);
}


long _Application::GetAutomationSecurity()
{
long result;
InvokeHelper(0x1c1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Application::SetAutomationSecurity(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _Application::GetFileDialog(long FileDialogType)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
FileDialogType);
return result;
}


CString _Application::GetEmailTemplate()
{
CString result;
InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Application::SetEmailTemplate(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Application::GetShowWindowsInTaskbar()
{
BOOL result;
InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetShowWindowsInTaskbar(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetNewDocument()
{
LPDISPATCH result;
InvokeHelper(0x1c6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetShowStartupDialog()
{
BOOL result;
InvokeHelper(0x1c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetShowStartupDialog(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetAutoCorrectEmail()
{
LPDISPATCH result;
InvokeHelper(0x1c8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetTaskPanes()
{
LPDISPATCH result;
InvokeHelper(0x1c9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Application::GetDefaultLegalBlackline()
{
BOOL result;
InvokeHelper(0x1cb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Application::SetDefaultLegalBlackline(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1cb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Application::GetSmartTagRecognizers()
{
LPDISPATCH result;
InvokeHelper(0x1cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetSmartTagTypes()
{
LPDISPATCH result;
InvokeHelper(0x1cd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Application::GetXMLNamespaces()
{
LPDISPATCH result;
InvokeHelper(0x1cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Application::PutFocusInMailHeader()
{
InvokeHelper(0x1d0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL _Application::GetArbitraryXMLSupportAvailable()
{
BOOL result;
InvokeHelper(0x1d1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}




/
// _Global properties


/
// _Global operations


LPDISPATCH _Global::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Global::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Global::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetDocuments()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetWindows()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetActiveDocument()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetActiveWindow()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetSelection()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetWordBasic()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Global::GetPrintPreview()
{
BOOL result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Global::SetPrintPreview(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Global::GetRecentFiles()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetNormalTemplate()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetSystem()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAutoCorrect()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetFontNames()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetLandscapeFontNames()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetPortraitFontNames()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetLanguages()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAssistant()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetFileConverters()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetDialogs()
{
LPDISPATCH result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetCaptionLabels()
{
LPDISPATCH result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAutoCaptions()
{
LPDISPATCH result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAddIns()
{
LPDISPATCH result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetTasks()
{
LPDISPATCH result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetMacroContainer()
{
LPDISPATCH result;
InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetCommandBars()
{
LPDISPATCH result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetSynonymInfo(LPCTSTR Word, VARIANT* LanguageID)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
Word, LanguageID);
return result;
}


LPDISPATCH _Global::GetVbe()
{
LPDISPATCH result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetListGalleries()
{
LPDISPATCH result;
InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Global::GetActivePrinter()
{
CString result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Global::SetActivePrinter(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Global::GetTemplates()
{
LPDISPATCH result;
InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetCustomizationContext()
{
LPDISPATCH result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Global::SetCustomizationContext(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Global::GetKeyBindings()
{
LPDISPATCH result;
InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetKeysBoundTo(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 _Global::GetFindKey(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;
}


LPDISPATCH _Global::GetOptions()
{
LPDISPATCH result;
InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetCustomDictionaries()
{
LPDISPATCH result;
InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Global::SetStatusBar(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Global::GetShowVisualBasicEditor()
{
BOOL result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Global::SetShowVisualBasicEditor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Global::GetIsObjectValid(LPDISPATCH Object)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
Object);
return result;
}


LPDISPATCH _Global::GetHangulHanjaDictionaries()
{
LPDISPATCH result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Global::Repeat(VARIANT* Times)
{
BOOL result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x131, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Times);
return result;
}


void _Global::DDEExecute(long Channel, LPCTSTR Command)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR;
InvokeHelper(0x136, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel, Command);
}


long _Global::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 _Global::DDEPoke(long Channel, LPCTSTR Item, LPCTSTR Data)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_BSTR;
InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel, Item, Data);
}


CString _Global::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 _Global::DDETerminate(long Channel)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Channel);
}


void _Global::DDETerminateAll()
{
InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long _Global::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 _Global::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;
}


BOOL _Global::CheckSpelling(LPCTSTR Word, 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,
Word, CustomDictionary, IgnoreUppercase, MainDictionary, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10);
return result;
}


LPDISPATCH _Global::GetSpellingSuggestions(LPCTSTR Word, 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,
Word, CustomDictionary, IgnoreUppercase, MainDictionary, SuggestionMode, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, 
CustomDictionary10);
return result;
}


void _Global::Help(VARIANT* HelpType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x149, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
HelpType);
}


LPDISPATCH _Global::NewWindow()
{
LPDISPATCH result;
InvokeHelper(0x159, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Global::CleanString(LPCTSTR String)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x162, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
String);
return result;
}


void _Global::ChangeFileOpenDirectory(LPCTSTR Path)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x163, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Path);
}


float _Global::InchesToPoints(float Inches)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x172, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Inches);
return result;
}


float _Global::CentimetersToPoints(float Centimeters)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x173, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Centimeters);
return result;
}


float _Global::MillimetersToPoints(float Millimeters)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x174, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Millimeters);
return result;
}


float _Global::PicasToPoints(float Picas)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x175, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Picas);
return result;
}


float _Global::LinesToPoints(float Lines)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x176, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Lines);
return result;
}


float _Global::PointsToInches(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17c, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Global::PointsToCentimeters(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17d, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Global::PointsToMillimeters(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17e, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Global::PointsToPicas(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17f, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Global::PointsToLines(float Points)
{
float result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x180, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points);
return result;
}


float _Global::PointsToPixels(float Points, VARIANT* fVertical)
{
float result;
static BYTE parms[] =
VTS_R4 VTS_PVARIANT;
InvokeHelper(0x181, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Points, fVertical);
return result;
}


float _Global::PixelsToPoints(float Pixels, VARIANT* fVertical)
{
float result;
static BYTE parms[] =
VTS_R4 VTS_PVARIANT;
InvokeHelper(0x182, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
Pixels, fVertical);
return result;
}


LPDISPATCH _Global::GetLanguageSettings()
{
LPDISPATCH result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAnswerWizard()
{
LPDISPATCH result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Global::GetAutoCorrectEmail()
{
LPDISPATCH result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// FontNames properties


/
// FontNames operations


LPUNKNOWN FontNames::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long FontNames::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FontNames::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FontNames::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FontNames::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString FontNames::Item(long Index)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
Index);
return result;
}




/
// Languages properties


/
// Languages operations


LPUNKNOWN Languages::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Languages::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Languages::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Languages::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Languages::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Languages::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Language properties


/
// Language operations


LPDISPATCH Language::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Language::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Language::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Language::GetId()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString Language::GetNameLocal()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Language::GetName()
{
CString result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Language::GetActiveGrammarDictionary()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Language::GetActiveHyphenationDictionary()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Language::GetActiveSpellingDictionary()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Language::GetActiveThesaurusDictionary()
{
LPDISPATCH result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Language::GetDefaultWritingStyle()
{
CString result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Language::SetDefaultWritingStyle(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


VARIANT Language::GetWritingStyleList()
{
VARIANT result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


long Language::GetSpellingDictionaryType()
{
long result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Language::SetSpellingDictionaryType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Documents properties


/
// Documents operations


LPUNKNOWN Documents::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Documents::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Documents::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Documents::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Documents::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Documents::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Documents::Close(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SaveChanges, OriginalFormat, RouteDocument);
}


void Documents::Save(VARIANT* NoPrompt, VARIANT* OriginalFormat)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NoPrompt, OriginalFormat);
}


LPDISPATCH Documents::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;
}


void Documents::CheckOut(LPCTSTR FileName)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FileName);
}


BOOL Documents::CanCheckOut(LPCTSTR FileName)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
FileName);
return result;
}


LPDISPATCH Documents::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;
}




/
// _Document properties


/
// _Document operations


CString _Document::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetBuiltInDocumentProperties()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetCustomDocumentProperties()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Document::GetPath()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetBookmarks()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetTables()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetFootnotes()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetEndnotes()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetComments()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetType()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL _Document::GetAutoHyphenation()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetAutoHyphenation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetHyphenateCaps()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetHyphenateCaps(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetHyphenationZone()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetHyphenationZone(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetConsecutiveHyphensLimit()
{
long result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetConsecutiveHyphensLimit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _Document::GetSections()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetWords()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSentences()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetCharacters()
{
LPDISPATCH result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetFields()
{
LPDISPATCH result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetFormFields()
{
LPDISPATCH result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetStyles()
{
LPDISPATCH result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetFrames()
{
LPDISPATCH result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetTablesOfFigures()
{
LPDISPATCH result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetVariables()
{
LPDISPATCH result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetMailMerge()
{
LPDISPATCH result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetEnvelope()
{
LPDISPATCH result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Document::GetFullName()
{
CString result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetRevisions()
{
LPDISPATCH result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetTablesOfContents()
{
LPDISPATCH result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetTablesOfAuthorities()
{
LPDISPATCH result;
InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetPageSetup()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Document::SetPageSetup(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Document::GetWindows()
{
LPDISPATCH result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetHasRoutingSlip()
{
BOOL result;
InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetHasRoutingSlip(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetRoutingSlip()
{
LPDISPATCH result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetRouted()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetTablesOfAuthoritiesCategories()
{
LPDISPATCH result;
InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetIndexes()
{
LPDISPATCH result;
InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetSaved()
{
BOOL result;
InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSaved(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetContent()
{
LPDISPATCH result;
InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetActiveWindow()
{
LPDISPATCH result;
InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetKind()
{
long result;
InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetKind(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Document::GetReadOnly()
{
BOOL result;
InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSubdocuments()
{
LPDISPATCH result;
InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetIsMasterDocument()
{
BOOL result;
InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


float _Document::GetDefaultTabStop()
{
float result;
InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Document::SetDefaultTabStop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL _Document::GetEmbedTrueTypeFonts()
{
BOOL result;
InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetEmbedTrueTypeFonts(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetSaveFormsData()
{
BOOL result;
InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSaveFormsData(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetReadOnlyRecommended()
{
BOOL result;
InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetReadOnlyRecommended(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetSaveSubsetFonts()
{
BOOL result;
InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSaveSubsetFonts(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetCompatibility(long Type)
{
BOOL result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
Type);
return result;
}


void _Document::SetCompatibility(long Type, BOOL bNewValue)
{
static BYTE parms[] =
VTS_I4 VTS_BOOL;
InvokeHelper(0x37, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
Type, bNewValue);
}


LPDISPATCH _Document::GetStoryRanges()
{
LPDISPATCH result;
InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetCommandBars()
{
LPDISPATCH result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetIsSubdocument()
{
BOOL result;
InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long _Document::GetSaveFormat()
{
long result;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long _Document::GetProtectionType()
{
long result;
InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetHyperlinks()
{
LPDISPATCH result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetShapes()
{
LPDISPATCH result;
InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetListTemplates()
{
LPDISPATCH result;
InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetLists()
{
LPDISPATCH result;
InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetUpdateStylesOnOpen()
{
BOOL result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetUpdateStylesOnOpen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


VARIANT _Document::GetAttachedTemplate()
{
VARIANT result;
InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void _Document::SetAttachedTemplate(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x43, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Document::GetInlineShapes()
{
LPDISPATCH result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetBackground()
{
LPDISPATCH result;
InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Document::SetBackground(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x45, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL _Document::GetGrammarChecked()
{
BOOL result;
InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetGrammarChecked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x46, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetSpellingChecked()
{
BOOL result;
InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSpellingChecked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x47, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetShowGrammaticalErrors()
{
BOOL result;
InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetShowGrammaticalErrors(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetShowSpellingErrors()
{
BOOL result;
InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetShowSpellingErrors(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetVersions()
{
LPDISPATCH result;
InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetShowSummary()
{
BOOL result;
InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetShowSummary(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetSummaryViewMode()
{
long result;
InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetSummaryViewMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetSummaryLength()
{
long result;
InvokeHelper(0x4e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetSummaryLength(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Document::GetPrintFractionalWidths()
{
BOOL result;
InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetPrintFractionalWidths(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetPrintPostScriptOverText()
{
BOOL result;
InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetPrintPostScriptOverText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetContainer()
{
LPDISPATCH result;
InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetPrintFormsData()
{
BOOL result;
InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetPrintFormsData(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetListParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Document::SetPassword(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x55, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void _Document::SetWritePassword(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x56, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Document::GetHasPassword()
{
BOOL result;
InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL _Document::GetWriteReserved()
{
BOOL result;
InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString _Document::GetActiveWritingStyle(VARIANT* LanguageID)
{
CString result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
LanguageID);
return result;
}


void _Document::SetActiveWritingStyle(VARIANT* LanguageID, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_PVARIANT VTS_BSTR;
InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
LanguageID, lpszNewValue);
}


BOOL _Document::GetUserControl()
{
BOOL result;
InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetUserControl(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetHasMailer()
{
BOOL result;
InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetHasMailer(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetMailer()
{
LPDISPATCH result;
InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetReadabilityStatistics()
{
LPDISPATCH result;
InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetGrammaticalErrors()
{
LPDISPATCH result;
InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSpellingErrors()
{
LPDISPATCH result;
InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetVBProject()
{
LPDISPATCH result;
InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetFormsDesign()
{
BOOL result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString _Document::Get_CodeName()
{
CString result;
InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Document::Set_CodeName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Document::GetCodeName()
{
CString result;
InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL _Document::GetSnapToGrid()
{
BOOL result;
InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSnapToGrid(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetSnapToShapes()
{
BOOL result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSnapToShapes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float _Document::GetGridDistanceHorizontal()
{
float result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Document::SetGridDistanceHorizontal(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _Document::GetGridDistanceVertical()
{
float result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Document::SetGridDistanceVertical(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x12f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _Document::GetGridOriginHorizontal()
{
float result;
InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Document::SetGridOriginHorizontal(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x130, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _Document::GetGridOriginVertical()
{
float result;
InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Document::SetGridOriginVertical(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x131, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _Document::GetGridSpaceBetweenHorizontalLines()
{
long result;
InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetGridSpaceBetweenHorizontalLines(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetGridSpaceBetweenVerticalLines()
{
long result;
InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetGridSpaceBetweenVerticalLines(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x133, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Document::GetGridOriginFromMargin()
{
BOOL result;
InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetGridOriginFromMargin(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x134, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetKerningByAlgorithm()
{
BOOL result;
InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetKerningByAlgorithm(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x135, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetJustificationMode()
{
long result;
InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetJustificationMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetFarEastLineBreakLevel()
{
long result;
InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetFarEastLineBreakLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString _Document::GetNoLineBreakBefore()
{
CString result;
InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Document::SetNoLineBreakBefore(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Document::GetNoLineBreakAfter()
{
CString result;
InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Document::SetNoLineBreakAfter(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x139, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _Document::GetTrackRevisions()
{
BOOL result;
InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetTrackRevisions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetPrintRevisions()
{
BOOL result;
InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetPrintRevisions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetShowRevisions()
{
BOOL result;
InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetShowRevisions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void _Document::Close(VARIANT* SaveChanges, VARIANT* OriginalFormat, VARIANT* RouteDocument)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x451, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SaveChanges, OriginalFormat, RouteDocument);
}


void _Document::Repaginate()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::FitToPages()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ManualHyphenation()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::DataForm()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Route()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Save()
{
InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::SendMail()
{
InvokeHelper(0x6e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::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 _Document::RunAutoMacro(long Which)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x70, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Which);
}


void _Document::Activate()
{
InvokeHelper(0x71, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::PrintPreview()
{
InvokeHelper(0x72, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::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 _Document::Undo(VARIANT* Times)
{
BOOL result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x74, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Times);
return result;
}


BOOL _Document::Redo(VARIANT* Times)
{
BOOL result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x75, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Times);
return result;
}


long _Document::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 _Document::MakeCompatibilityDefault()
{
InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Unprotect(VARIANT* Password)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Password);
}


void _Document::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, NULL, parms,
Type, Option, Name, Format);
}


void _Document::RunLetterWizard(VARIANT* LetterContent, VARIANT* WizardMode)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x7b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LetterContent, WizardMode);
}


LPDISPATCH _Document::GetLetterContent()
{
LPDISPATCH result;
InvokeHelper(0x7c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Document::SetLetterContent(VARIANT* LetterContent)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x7d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LetterContent);
}


void _Document::CopyStylesFromTemplate(LPCTSTR Template)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Template);
}


void _Document::UpdateStyles()
{
InvokeHelper(0x7f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::CheckGrammar()
{
InvokeHelper(0x83, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::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, NULL, parms,
CustomDictionary, IgnoreUppercase, AlwaysSuggest, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10);
}


void _Document::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, NULL, parms,
Address, SubAddress, NewWindow, AddHistory, ExtraInfo, Method, HeaderInfo);
}


void _Document::AddToFavorites()
{
InvokeHelper(0x88, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Reload()
{
InvokeHelper(0x89, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::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 _Document::RemoveNumbers(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x8c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


void _Document::ConvertNumbersToText(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x8d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


long _Document::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 _Document::Post()
{
InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ToggleFormsDesign()
{
InvokeHelper(0x90, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::UpdateSummaryProperties()
{
InvokeHelper(0x92, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


VARIANT _Document::GetCrossReferenceItems(VARIANT* ReferenceType)
{
VARIANT result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x93, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
ReferenceType);
return result;
}


void _Document::AutoFormat()
{
InvokeHelper(0x94, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ViewCode()
{
InvokeHelper(0x95, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ViewPropertyBrowser()
{
InvokeHelper(0x96, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ForwardMailer()
{
InvokeHelper(0xfa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::Reply()
{
InvokeHelper(0xfb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ReplyAll()
{
InvokeHelper(0xfc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::SendMailer(VARIANT* FileFormat, VARIANT* Priority)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xfd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FileFormat, Priority);
}


void _Document::UndoClear()
{
InvokeHelper(0xfe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::PresentIt()
{
InvokeHelper(0xff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::SendFax(LPCTSTR Address, VARIANT* Subject)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x100, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Address, Subject);
}


void _Document::ClosePrintPreview()
{
InvokeHelper(0x102, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::CheckConsistency()
{
InvokeHelper(0x103, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::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 _Document::AcceptAllRevisions()
{
InvokeHelper(0x13d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::RejectAllRevisions()
{
InvokeHelper(0x13e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::DetectLanguage()
{
InvokeHelper(0x97, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ApplyTheme(LPCTSTR Name)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x142, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name);
}


void _Document::RemoveTheme()
{
InvokeHelper(0x143, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::WebPagePreview()
{
InvokeHelper(0x145, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ReloadAs(long Encoding)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x14b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Encoding);
}


CString _Document::GetActiveTheme()
{
CString result;
InvokeHelper(0x21c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString _Document::GetActiveThemeDisplayName()
{
CString result;
InvokeHelper(0x21d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetEmail()
{
LPDISPATCH result;
InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetScripts()
{
LPDISPATCH result;
InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetLanguageDetected()
{
BOOL result;
InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetLanguageDetected(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x141, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetFarEastLineBreakLanguage()
{
long result;
InvokeHelper(0x146, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetFarEastLineBreakLanguage(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x146, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _Document::GetFrameset()
{
LPDISPATCH result;
InvokeHelper(0x147, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT _Document::GetClickAndTypeParagraphStyle()
{
VARIANT result;
InvokeHelper(0x148, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void _Document::SetClickAndTypeParagraphStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x148, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Document::GetHTMLProject()
{
LPDISPATCH result;
InvokeHelper(0x149, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetWebOptions()
{
LPDISPATCH result;
InvokeHelper(0x14a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetOpenEncoding()
{
long result;
InvokeHelper(0x14c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long _Document::GetSaveEncoding()
{
long result;
InvokeHelper(0x14d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetSaveEncoding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x14d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Document::GetOptimizeForWord97()
{
BOOL result;
InvokeHelper(0x14e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetOptimizeForWord97(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetVBASigned()
{
BOOL result;
InvokeHelper(0x14f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::ConvertVietDoc(long CodePageOrigin)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1bf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
CodePageOrigin);
}


void _Document::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, NULL, parms,
Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight);
}


LPDISPATCH _Document::GetMailEnvelope()
{
LPDISPATCH result;
InvokeHelper(0x150, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetDisableFeatures()
{
BOOL result;
InvokeHelper(0x151, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetDisableFeatures(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x151, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetDoNotEmbedSystemFonts()
{
BOOL result;
InvokeHelper(0x152, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetDoNotEmbedSystemFonts(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x152, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetSignatures()
{
LPDISPATCH result;
InvokeHelper(0x153, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _Document::GetDefaultTargetFrame()
{
CString result;
InvokeHelper(0x154, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Document::SetDefaultTargetFrame(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x154, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Document::GetHTMLDivisions()
{
LPDISPATCH result;
InvokeHelper(0x156, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetDisableFeaturesIntroducedAfter()
{
long result;
InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetDisableFeaturesIntroducedAfter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x157, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Document::GetRemovePersonalInformation()
{
BOOL result;
InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetRemovePersonalInformation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x158, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH _Document::GetSmartTags()
{
LPDISPATCH result;
InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Document::CheckIn(BOOL SaveChanges, VARIANT* Comments, BOOL MakePublic)
{
static BYTE parms[] =
VTS_BOOL VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x15d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SaveChanges, Comments, MakePublic);
}


BOOL _Document::CanCheckin()
{
BOOL result;
InvokeHelper(0x15f, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::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, NULL, parms,
FileName, MergeTarget, DetectFormatChanges, UseFormattingFrom, AddToRecentFiles);
}


BOOL _Document::GetEmbedSmartTags()
{
BOOL result;
InvokeHelper(0x15b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetEmbedSmartTags(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetSmartTagsAsXMLProps()
{
BOOL result;
InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetSmartTagsAsXMLProps(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetTextEncoding()
{
long result;
InvokeHelper(0x165, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetTextEncoding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x165, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetTextLineEnding()
{
long result;
InvokeHelper(0x166, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetTextLineEnding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x166, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void _Document::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, NULL, parms,
Recipients, Subject, ShowMessage, IncludeAttachment);
}


void _Document::ReplyWithChanges(VARIANT* ShowMessage)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x162, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShowMessage);
}


void _Document::EndReview()
{
InvokeHelper(0x164, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::GetStyleSheets()
{
LPDISPATCH result;
InvokeHelper(0x168, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT _Document::GetDefaultTableStyle()
{
VARIANT result;
InvokeHelper(0x16d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


CString _Document::GetPasswordEncryptionProvider()
{
CString result;
InvokeHelper(0x16f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString _Document::GetPasswordEncryptionAlgorithm()
{
CString result;
InvokeHelper(0x170, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long _Document::GetPasswordEncryptionKeyLength()
{
long result;
InvokeHelper(0x171, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL _Document::GetPasswordEncryptionFileProperties()
{
BOOL result;
InvokeHelper(0x172, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::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, NULL, parms,
PasswordEncryptionProvider, PasswordEncryptionAlgorithm, PasswordEncryptionKeyLength, PasswordEncryptionFileProperties);
}


void _Document::RecheckSmartTags()
{
InvokeHelper(0x16b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::RemoveSmartTags()
{
InvokeHelper(0x16c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::SetDefaultTableStyle(VARIANT* Style, BOOL SetInTemplate)
{
static BYTE parms[] =
VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x16e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Style, SetInTemplate);
}


void _Document::DeleteAllComments()
{
InvokeHelper(0x173, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::AcceptAllRevisionsShown()
{
InvokeHelper(0x174, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::RejectAllRevisionsShown()
{
InvokeHelper(0x175, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::DeleteAllCommentsShown()
{
InvokeHelper(0x176, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::ResetFormFields()
{
InvokeHelper(0x177, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::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, NULL, parms,
FileName, FileFormat, LockComments, Password, AddToRecentFiles, WritePassword, ReadOnlyRecommended, EmbedTrueTypeFonts, SaveNativePictureFormat, SaveFormsData, SaveAsAOCELetter, Encoding, InsertLineBreaks, AllowSubstitutions, LineEnding, 
AddBiDiMarks);
}


BOOL _Document::GetEmbedLinguisticData()
{
BOOL result;
InvokeHelper(0x179, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetEmbedLinguisticData(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x179, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetFormattingShowFont()
{
BOOL result;
InvokeHelper(0x1c0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetFormattingShowFont(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetFormattingShowClear()
{
BOOL result;
InvokeHelper(0x1c1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetFormattingShowClear(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetFormattingShowParagraph()
{
BOOL result;
InvokeHelper(0x1c2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetFormattingShowParagraph(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetFormattingShowNumbering()
{
BOOL result;
InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetFormattingShowNumbering(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _Document::GetFormattingShowFilter()
{
long result;
InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetFormattingShowFilter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void _Document::CheckNewSmartTags()
{
InvokeHelper(0x17a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::GetPermission()
{
LPDISPATCH result;
InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetXMLNodes()
{
LPDISPATCH result;
InvokeHelper(0x1cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetXMLSchemaReferences()
{
LPDISPATCH result;
InvokeHelper(0x1cd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSmartDocument()
{
LPDISPATCH result;
InvokeHelper(0x1ce, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSharedWorkspace()
{
LPDISPATCH result;
InvokeHelper(0x1cf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::GetSync()
{
LPDISPATCH result;
InvokeHelper(0x1d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetEnforceStyle()
{
BOOL result;
InvokeHelper(0x1d7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetEnforceStyle(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1d7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetAutoFormatOverride()
{
BOOL result;
InvokeHelper(0x1d8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetAutoFormatOverride(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1d8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetXMLSaveDataOnly()
{
BOOL result;
InvokeHelper(0x1d9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetXMLSaveDataOnly(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1d9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetXMLHideNamespaces()
{
BOOL result;
InvokeHelper(0x1dd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetXMLHideNamespaces(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1dd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetXMLShowAdvancedErrors()
{
BOOL result;
InvokeHelper(0x1de, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetXMLShowAdvancedErrors(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1de, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetXMLUseXSLTWhenSaving()
{
BOOL result;
InvokeHelper(0x1da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetXMLUseXSLTWhenSaving(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1da, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _Document::GetXMLSaveThroughXSLT()
{
CString result;
InvokeHelper(0x1db, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Document::SetXMLSaveThroughXSLT(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1db, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _Document::GetDocumentLibraryVersions()
{
LPDISPATCH result;
InvokeHelper(0x1dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL _Document::GetReadingModeLayoutFrozen()
{
BOOL result;
InvokeHelper(0x1e1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetReadingModeLayoutFrozen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1e1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL _Document::GetRemoveDateAndTime()
{
BOOL result;
InvokeHelper(0x1e4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Document::SetRemoveDateAndTime(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1e4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void _Document::SendFaxOverInternet(VARIANT* Recipients, VARIANT* Subject, VARIANT* ShowMessage)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1d0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Recipients, Subject, ShowMessage);
}


void _Document::TransformDocument(LPCTSTR Path, BOOL DataOnly)
{
static BYTE parms[] =
VTS_BSTR VTS_BOOL;
InvokeHelper(0x1f4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Path, DataOnly);
}


void _Document::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, NULL, parms,
Type, NoReset, Password, UseIRM, EnforceStyleLock);
}


void _Document::SelectAllEditableRanges(VARIANT* EditorID)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x1d4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
EditorID);
}


void _Document::DeleteAllEditableRanges(VARIANT* EditorID)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
EditorID);
}


void _Document::DeleteAllInkAnnotations()
{
InvokeHelper(0x1df, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Document::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, NULL, parms,
Name, AuthorName, CompareTarget, DetectFormatChanges, IgnoreAllComparisonWarnings, AddToRecentFiles, RemovePersonalInformation, RemoveDateAndTime);
}


void _Document::RemoveLockedStyles()
{
InvokeHelper(0x1e7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH _Document::GetChildNodeSuggestions()
{
LPDISPATCH result;
InvokeHelper(0x1e6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Document::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 _Document::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 _Document::GetXMLSchemaViolations()
{
LPDISPATCH result;
InvokeHelper(0x1ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Document::GetReadingLayoutSizeX()
{
long result;
InvokeHelper(0x1eb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetReadingLayoutSizeX(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Document::GetReadingLayoutSizeY()
{
long result;
InvokeHelper(0x1ec, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Document::SetReadingLayoutSizeY(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1ec, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Template properties


/
// Template operations


CString Template::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Template::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Template::GetPath()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetAutoTextEntries()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Template::GetLanguageID()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Template::GetSaved()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Template::SetSaved(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Template::GetType()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString Template::GetFullName()
{
CString result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetBuiltInDocumentProperties()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetCustomDocumentProperties()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Template::GetListTemplates()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Template::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Template::GetVBProject()
{
LPDISPATCH result;
InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Template::GetKerningByAlgorithm()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Template::SetKerningByAlgorithm(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Template::GetJustificationMode()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetJustificationMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Template::GetFarEastLineBreakLevel()
{
long result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetFarEastLineBreakLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Template::GetNoLineBreakBefore()
{
CString result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Template::SetNoLineBreakBefore(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Template::GetNoLineBreakAfter()
{
CString result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Template::SetNoLineBreakAfter(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Template::OpenAsDocument()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Template::Save()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Template::GetNoProofing()
{
long result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Template::GetFarEastLineBreakLanguage()
{
long result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Template::SetFarEastLineBreakLanguage(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Templates properties


/
// Templates operations


LPDISPATCH Templates::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Templates::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Templates::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Templates::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN Templates::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Templates::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// RoutingSlip properties


/
// RoutingSlip operations


LPDISPATCH RoutingSlip::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long RoutingSlip::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH RoutingSlip::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString RoutingSlip::GetSubject()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetSubject(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString RoutingSlip::GetMessage()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetMessage(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long RoutingSlip::GetDelivery()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetDelivery(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL RoutingSlip::GetTrackStatus()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetTrackStatus(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long RoutingSlip::GetProtect()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetProtect(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL RoutingSlip::GetReturnWhenDone()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void RoutingSlip::SetReturnWhenDone(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long RoutingSlip::GetStatus()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT RoutingSlip::GetRecipients(VARIANT* Index)
{
VARIANT result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
Index);
return result;
}


void RoutingSlip::Reset()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void RoutingSlip::AddRecipient(LPCTSTR Recipient)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Recipient);
}




/
// Bookmark properties


/
// Bookmark operations


CString Bookmark::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Bookmark::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Bookmark::GetEmpty()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Bookmark::GetStart()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Bookmark::SetStart(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Bookmark::GetEnd()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Bookmark::SetEnd(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Bookmark::GetColumn()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Bookmark::GetStoryType()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Bookmark::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Bookmark::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Bookmark::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Bookmark::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Bookmark::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Bookmark::Copy(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// Bookmarks properties


/
// Bookmarks operations


LPUNKNOWN Bookmarks::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Bookmarks::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Bookmarks::GetDefaultSorting()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Bookmarks::SetDefaultSorting(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Bookmarks::GetShowHidden()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Bookmarks::SetShowHidden(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Bookmarks::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Bookmarks::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Bookmarks::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Bookmarks::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Bookmarks::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 Bookmarks::Exists(LPCTSTR Name)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Name);
return result;
}




/
// Variable properties


/
// Variable operations


LPDISPATCH Variable::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Variable::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Variable::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Variable::GetName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Variable::GetValue()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Variable::SetValue(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Variable::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Variable::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Variables properties


/
// Variables operations


LPUNKNOWN Variables::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Variables::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Variables::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Variables::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Variables::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Variables::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Variables::Add(LPCTSTR Name, VARIANT* Value)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Value);
return result;
}




/
// RecentFile properties


/
// RecentFile operations


LPDISPATCH RecentFile::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long RecentFile::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH RecentFile::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString RecentFile::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long RecentFile::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL RecentFile::GetReadOnly()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void RecentFile::SetReadOnly(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString RecentFile::GetPath()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH RecentFile::Open()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void RecentFile::Delete()
{
InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// RecentFiles properties


/
// RecentFiles operations


LPDISPATCH RecentFiles::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long RecentFiles::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH RecentFiles::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN RecentFiles::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long RecentFiles::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long RecentFiles::GetMaximum()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void RecentFiles::SetMaximum(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH RecentFiles::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH RecentFiles::Add(VARIANT* Document, VARIANT* ReadOnly)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Document, ReadOnly);
return result;
}




/
// Window properties


/
// Window operations


LPDISPATCH Window::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Window::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetActivePane()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetDocument()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetPanes()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetSelection()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Window::GetLeft()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetLeft(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Window::GetTop()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetTop(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Window::GetWidth()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Window::GetHeight()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetHeight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Window::GetSplit()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetSplit(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Window::GetSplitVertical()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetSplitVertical(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Window::GetCaption()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Window::SetCaption(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Window::GetWindowState()
{
long result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetWindowState(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Window::GetDisplayRulers()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayRulers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetDisplayVerticalRuler()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayVerticalRuler(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Window::GetView()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Window::GetType()
{
long result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Window::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Window::GetWindowNumber()
{
long result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Window::GetDisplayVerticalScrollBar()
{
BOOL result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayVerticalScrollBar(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetDisplayHorizontalScrollBar()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayHorizontalScrollBar(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Window::GetStyleAreaWidth()
{
float result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Window::SetStyleAreaWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Window::GetDisplayScreenTips()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayScreenTips(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Window::GetHorizontalPercentScrolled()
{
long result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetHorizontalPercentScrolled(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Window::GetVerticalPercentScrolled()
{
long result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetVerticalPercentScrolled(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Window::GetDocumentMap()
{
BOOL result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDocumentMap(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetActive()
{
BOOL result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Window::GetDocumentMapPercentWidth()
{
long result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetDocumentMapPercentWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Window::GetIndex()
{
long result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Window::GetIMEMode()
{
long result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Window::SetIMEMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Window::Activate()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Window::Close(VARIANT* SaveChanges, VARIANT* RouteDocument)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SaveChanges, RouteDocument);
}


void Window::LargeScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up, ToRight, ToLeft);
}


void Window::SmallScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up, ToRight, ToLeft);
}


LPDISPATCH Window::NewWindow()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Window::PageScroll(VARIANT* Down, VARIANT* Up)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up);
}


void Window::SetFocus()
{
InvokeHelper(0x6d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Window::RangeFromPoint(long x, long y)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
x, y);
return result;
}


void Window::ScrollIntoView(LPDISPATCH obj, VARIANT* Start)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT;
InvokeHelper(0x6f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
obj, Start);
}


void Window::GetPoint(long* ScreenPixelsLeft, long* ScreenPixelsTop, long* ScreenPixelsWidth, long* ScreenPixelsHeight, LPDISPATCH obj)
{
static BYTE parms[] =
VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4 VTS_DISPATCH;
InvokeHelper(0x70, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ScreenPixelsLeft, ScreenPixelsTop, ScreenPixelsWidth, ScreenPixelsHeight, obj);
}


long Window::GetUsableWidth()
{
long result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Window::GetUsableHeight()
{
long result;
InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Window::GetEnvelopeVisible()
{
BOOL result;
InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetEnvelopeVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetDisplayRightRuler()
{
BOOL result;
InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayRightRuler(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetDisplayLeftScrollBar()
{
BOOL result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetDisplayLeftScrollBar(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Window::GetVisible()
{
BOOL result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Window::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(0x1bd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Background, Append, Range, OutputFileName, From, To, Item, Copies, Pages, PageType, PrintToFile, Collate, ActivePrinterMacGX, ManualDuplexPrint, PrintZoomColumn, PrintZoomRow, PrintZoomPaperWidth, PrintZoomPaperHeight);
}


void Window::ToggleShowAllReviewers()
{
InvokeHelper(0x1be, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Window::GetThumbnails()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Window::SetThumbnails(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Windows properties


/
// Windows operations


LPUNKNOWN Windows::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Windows::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Windows::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Windows::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Windows::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Windows::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Windows::Add(VARIANT* Window)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Window);
return result;
}


void Windows::Arrange(VARIANT* ArrangeStyle)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ArrangeStyle);
}


BOOL Windows::CompareSideBySideWith(VARIANT* Document)
{
BOOL result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Document);
return result;
}


BOOL Windows::BreakSideBySide()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
return result;
}


void Windows::ResetPositionsSideBySide()
{
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Windows::GetSyncScrollingSideBySide()
{
BOOL result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Windows::SetSyncScrollingSideBySide(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Pane properties


/
// Pane operations


LPDISPATCH Pane::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Pane::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetDocument()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetSelection()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Pane::GetDisplayRulers()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Pane::SetDisplayRulers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Pane::GetDisplayVerticalRuler()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Pane::SetDisplayVerticalRuler(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Pane::GetZooms()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Pane::GetIndex()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetView()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetNext()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Pane::GetHorizontalPercentScrolled()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Pane::SetHorizontalPercentScrolled(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Pane::GetVerticalPercentScrolled()
{
long result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Pane::SetVerticalPercentScrolled(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Pane::GetMinimumFontSize()
{
long result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Pane::SetMinimumFontSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Pane::GetBrowseWidth()
{
long result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Pane::Activate()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Pane::Close()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Pane::LargeScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up, ToRight, ToLeft);
}


void Pane::SmallScroll(VARIANT* Down, VARIANT* Up, VARIANT* ToRight, VARIANT* ToLeft)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up, ToRight, ToLeft);
}


void Pane::AutoScroll(long Velocity)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Velocity);
}


void Pane::PageScroll(VARIANT* Down, VARIANT* Up)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Down, Up);
}


void Pane::NewFrameset()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Pane::TOCInFrameset()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Pane::GetFrameset()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pane::GetPages()
{
LPDISPATCH result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Panes properties


/
// Panes operations


LPUNKNOWN Panes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Panes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Panes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Panes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Panes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Panes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Panes::Add(VARIANT* SplitVertical)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
SplitVertical);
return result;
}




/
// Range properties


/
// Range operations


CString Range::GetText()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Range::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Range::GetFormattedText()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetFormattedText(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Range::GetStart()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetStart(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetEnd()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetEnd(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Range::GetFont()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Range::GetDuplicate()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetStoryType()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetTables()
{
LPDISPATCH result;
InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetWords()
{
LPDISPATCH result;
InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetSentences()
{
LPDISPATCH result;
InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetCharacters()
{
LPDISPATCH result;
InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetFootnotes()
{
LPDISPATCH result;
InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetEndnotes()
{
LPDISPATCH result;
InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetComments()
{
LPDISPATCH result;
InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetCells()
{
LPDISPATCH result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetSections()
{
LPDISPATCH result;
InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Range::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetTextRetrievalMode()
{
LPDISPATCH result;
InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetTextRetrievalMode(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Range::GetFields()
{
LPDISPATCH result;
InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetFormFields()
{
LPDISPATCH result;
InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetFrames()
{
LPDISPATCH result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Range::GetListFormat()
{
LPDISPATCH result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetBookmarks()
{
LPDISPATCH result;
InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetBold()
{
long result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetBold(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetItalic()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetItalic(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetUnderline()
{
long result;
InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetUnderline(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetEmphasisMark()
{
long result;
InvokeHelper(0x8c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetEmphasisMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Range::GetDisableCharacterSpaceGrid()
{
BOOL result;
InvokeHelper(0x8d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetDisableCharacterSpaceGrid(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Range::GetRevisions()
{
LPDISPATCH result;
InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT Range::GetStyle()
{
VARIANT result;
InvokeHelper(0x97, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Range::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x97, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Range::GetStoryLength()
{
long result;
InvokeHelper(0x98, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Range::GetLanguageID()
{
long result;
InvokeHelper(0x99, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x99, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Range::GetSynonymInfo()
{
LPDISPATCH result;
InvokeHelper(0x9b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetHyperlinks()
{
LPDISPATCH result;
InvokeHelper(0x9c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetListParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x9d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetSubdocuments()
{
LPDISPATCH result;
InvokeHelper(0x9f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Range::GetGrammarChecked()
{
BOOL result;
InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetGrammarChecked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Range::GetSpellingChecked()
{
BOOL result;
InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetSpellingChecked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Range::GetHighlightColorIndex()
{
long result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetHighlightColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Range::GetColumns()
{
LPDISPATCH result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetRows()
{
LPDISPATCH result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Range::GetIsEndOfRowMark()
{
BOOL result;
InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Range::GetBookmarkID()
{
long result;
InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Range::GetPreviousBookmarkID()
{
long result;
InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetFind()
{
LPDISPATCH result;
InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetPageSetup()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::SetPageSetup(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Range::GetShapeRange()
{
LPDISPATCH result;
InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetCase()
{
long result;
InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetCase(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


VARIANT Range::GetInformation(long Type)
{
VARIANT result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
Type);
return result;
}


LPDISPATCH Range::GetReadabilityStatistics()
{
LPDISPATCH result;
InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetGrammaticalErrors()
{
LPDISPATCH result;
InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetSpellingErrors()
{
LPDISPATCH result;
InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetOrientation()
{
long result;
InvokeHelper(0x13d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Range::GetInlineShapes()
{
LPDISPATCH result;
InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetNextStoryRange()
{
LPDISPATCH result;
InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x141, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetLanguageIDOther()
{
long result;
InvokeHelper(0x142, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetLanguageIDOther(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x142, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Range::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::SetRange(long Start, long End)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Start, End);
}


void Range::Collapse(VARIANT* Direction)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Direction);
}


void Range::InsertBefore(LPCTSTR Text)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Text);
}


void Range::InsertAfter(LPCTSTR Text)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Text);
}


LPDISPATCH Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::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 Range::Cut()
{
InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::Copy()
{
InvokeHelper(0x78, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::Paste()
{
InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::InsertBreak(VARIANT* Type)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x7a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type);
}


void Range::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, NULL, parms,
FileName, Range, ConfirmConversions, Link, Attachment);
}


BOOL Range::InStory(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x7d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


BOOL Range::InRange(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x7e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


long Range::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 Range::WholeStory()
{
InvokeHelper(0x80, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Range::Expand(VARIANT* Unit)
{
long result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x81, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit);
return result;
}


void Range::InsertParagraph()
{
InvokeHelper(0xa0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::InsertParagraphAfter()
{
InvokeHelper(0xa1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::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, NULL, parms,
CharacterNumber, Font, Unicode, Bias);
}


void Range::CopyAsPicture()
{
InvokeHelper(0xa7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::SortAscending()
{
InvokeHelper(0xa9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::SortDescending()
{
InvokeHelper(0xaa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Range::IsEqual(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xab, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


float Range::Calculate()
{
float result;
InvokeHelper(0xac, DISPATCH_METHOD, VT_R4, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::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 Range::GoToNext(long What)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xae, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
What);
return result;
}


LPDISPATCH Range::GoToPrevious(long What)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xaf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
What);
return result;
}


void Range::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, NULL, parms,
IconIndex, Link, Placement, DisplayAsIcon, DataType, IconFileName, IconLabel);
}


void Range::LookupNameProperties()
{
InvokeHelper(0xb1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Range::ComputeStatistics(long Statistic)
{
long result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb2, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Statistic);
return result;
}


void Range::Relocate(long Direction)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Direction);
}


void Range::CheckSynonyms()
{
InvokeHelper(0xb4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::SubscribeTo(LPCTSTR Edition, VARIANT* Format)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Edition, Format);
}


void Range::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, NULL, parms,
Edition, ContainsPICT, ContainsRTF, ContainsText);
}


void Range::InsertAutoText()
{
InvokeHelper(0xb7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::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, NULL, parms,
Format, Style, LinkToSource, Connection, SQLStatement, SQLStatement1, PasswordDocument, PasswordTemplate, WritePasswordDocument, WritePasswordTemplate, DataSource, From, To, IncludeFields);
}


void Range::AutoFormat()
{
InvokeHelper(0xc3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::CheckGrammar()
{
InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::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, NULL, parms,
CustomDictionary, IgnoreUppercase, AlwaysSuggest, CustomDictionary2, CustomDictionary3, CustomDictionary4, CustomDictionary5, CustomDictionary6, CustomDictionary7, CustomDictionary8, CustomDictionary9, CustomDictionary10);
}


LPDISPATCH Range::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 Range::InsertParagraphBefore()
{
InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::NextSubdocument()
{
InvokeHelper(0xdb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::PreviousSubdocument()
{
InvokeHelper(0xdc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::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, NULL, parms,
ConversionsMode, FastConversion, CheckHangulEnding, EnableRecentOrdering, CustomDictionary);
}


void Range::PasteAsNestedTable()
{
InvokeHelper(0xde, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Range::ModifyEnclosure(VARIANT* Style, VARIANT* Symbol, VARIANT* EnclosedText)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xdf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Style, Symbol, EnclosedText);
}


void Range::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, NULL, parms,
Text, Alignment, Raise, FontSize, FontName);
}


void Range::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, NULL, parms,
DateTimeFormat, InsertAsField, InsertAsFullWidth, DateLanguage, CalendarType);
}


void Range::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, NULL, parms,
ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, SortColumn, Separator, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, 
IgnoreHe, LanguageID);
}


void Range::DetectLanguage()
{
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Range::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 Range::TCSCConverter(long WdTCSCConverterDirection, BOOL CommonTerms, BOOL UseVariants)
{
static BYTE parms[] =
VTS_I4 VTS_BOOL VTS_BOOL;
InvokeHelper(0x1f3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
WdTCSCConverterDirection, CommonTerms, UseVariants);
}


BOOL Range::GetLanguageDetected()
{
BOOL result;
InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetLanguageDetected(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Range::GetFitTextWidth()
{
float result;
InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Range::SetFitTextWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Range::GetHorizontalInVertical()
{
long result;
InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetHorizontalInVertical(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetTwoLinesInOne()
{
long result;
InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetTwoLinesInOne(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x10a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Range::GetCombineCharacters()
{
BOOL result;
InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetCombineCharacters(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Range::GetNoProofing()
{
long result;
InvokeHelper(0x143, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x143, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Range::GetTopLevelTables()
{
LPDISPATCH result;
InvokeHelper(0x144, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetScripts()
{
LPDISPATCH result;
InvokeHelper(0x145, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Range::GetCharacterWidth()
{
long result;
InvokeHelper(0x146, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetCharacterWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x146, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetKana()
{
long result;
InvokeHelper(0x147, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetKana(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x147, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetBoldBi()
{
long result;
InvokeHelper(0x190, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetBoldBi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x190, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Range::GetItalicBi()
{
long result;
InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Range::SetItalicBi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Range::GetId()
{
CString result;
InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Range::SetId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Range::GetHTMLDivisions()
{
LPDISPATCH result;
InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetSmartTags()
{
LPDISPATCH result;
InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Range::GetShowAll()
{
BOOL result;
InvokeHelper(0x198, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Range::SetShowAll(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x198, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Range::GetDocument()
{
LPDISPATCH result;
InvokeHelper(0x199, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetFootnoteOptions()
{
LPDISPATCH result;
InvokeHelper(0x19a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetEndnoteOptions()
{
LPDISPATCH result;
InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Range::PasteAndFormat(long Type)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x19c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type);
}


void Range::PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF)
{
static BYTE parms[] =
VTS_BOOL VTS_BOOL VTS_BOOL;
InvokeHelper(0x19d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LinkedToExcel, WordFormatting, RTF);
}


void Range::PasteAppendTable()
{
InvokeHelper(0x19e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Range::GetXMLNodes()
{
LPDISPATCH result;
InvokeHelper(0x154, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetXMLParentNode()
{
LPDISPATCH result;
InvokeHelper(0x155, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GetEditors()
{
LPDISPATCH result;
InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Range::GetXml(BOOL DataOnly)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
DataOnly);
return result;
}


VARIANT Range::GetEnhMetaFileBits()
{
VARIANT result;
InvokeHelper(0x159, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


LPDISPATCH Range::GoToEditableRange(VARIANT* EditorID)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x19f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
EditorID);
return result;
}


void Range::InsertXML(LPCTSTR XML, VARIANT* Transform)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x1a0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
XML, Transform);
}


void Range::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, NULL, parms,
Label, Title, TitleAutoText, Position, ExcludeLabel);
}


void Range::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, NULL, parms,
ReferenceType, ReferenceKind, ReferenceItem, InsertAsHyperlink, IncludePosition, SeparateNumbers, SeparatorString);
}




/
// ListFormat properties


/
// ListFormat operations


long ListFormat::GetListLevelNumber()
{
long result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListFormat::SetListLevelNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH ListFormat::GetList()
{
LPDISPATCH result;
InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListFormat::GetListTemplate()
{
LPDISPATCH result;
InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListFormat::GetListValue()
{
long result;
InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL ListFormat::GetSingleList()
{
BOOL result;
InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL ListFormat::GetSingleListTemplate()
{
BOOL result;
InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long ListFormat::GetListType()
{
long result;
InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString ListFormat::GetListString()
{
CString result;
InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH ListFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListFormat::CanContinuePreviousList(LPDISPATCH ListTemplate)
{
long result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xb8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
ListTemplate);
return result;
}


void ListFormat::RemoveNumbers(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xb9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


void ListFormat::ConvertNumbersToText(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xba, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


long ListFormat::CountNumberedItems(VARIANT* NumberType, VARIANT* Level)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xbb, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
NumberType, Level);
return result;
}


void ListFormat::ListOutdent()
{
InvokeHelper(0xd2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ListFormat::ListIndent()
{
InvokeHelper(0xd3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ListFormat::ApplyBulletDefault(VARIANT* DefaultListBehavior)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
DefaultListBehavior);
}


void ListFormat::ApplyNumberDefault(VARIANT* DefaultListBehavior)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xd5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
DefaultListBehavior);
}


void ListFormat::ApplyOutlineNumberDefault(VARIANT* DefaultListBehavior)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xd6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
DefaultListBehavior);
}


void ListFormat::ApplyListTemplate(LPDISPATCH ListTemplate, VARIANT* ContinuePreviousList, VARIANT* ApplyTo, VARIANT* DefaultListBehavior)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xd7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ListTemplate, ContinuePreviousList, ApplyTo, DefaultListBehavior);
}


LPDISPATCH ListFormat::GetListPictureBullet()
{
LPDISPATCH result;
InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Find properties


/
// Find operations


LPDISPATCH Find::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Find::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Find::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Find::GetForward()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetForward(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Find::GetFont()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Find::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Find::GetFound()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Find::GetMatchAllWordForms()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchAllWordForms(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchCase()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchCase(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchWildcards()
{
BOOL result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchWildcards(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchSoundsLike()
{
BOOL result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchSoundsLike(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchWholeWord()
{
BOOL result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchWholeWord(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchFuzzy()
{
BOOL result;
InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchFuzzy(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchByte()
{
BOOL result;
InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchByte(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Find::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Find::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Find::GetStyle()
{
VARIANT result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Find::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Find::GetText()
{
CString result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Find::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Find::GetLanguageID()
{
long result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Find::GetHighlight()
{
long result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetHighlight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Find::GetReplacement()
{
LPDISPATCH result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Find::GetFrame()
{
LPDISPATCH result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Find::GetWrap()
{
long result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetWrap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Find::GetFormat()
{
BOOL result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetFormat(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Find::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Find::GetLanguageIDOther()
{
long result;
InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetLanguageIDOther(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Find::GetCorrectHangulEndings()
{
BOOL result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetCorrectHangulEndings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Find::ClearFormatting()
{
InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Find::SetAllFuzzyOptions()
{
InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Find::ClearAllFuzzyOptions()
{
InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Find::Execute(VARIANT* FindText, VARIANT* MatchCase, VARIANT* MatchWholeWord, VARIANT* MatchWildcards, VARIANT* MatchSoundsLike, VARIANT* MatchAllWordForms, VARIANT* Forward, VARIANT* Wrap, VARIANT* Format, VARIANT* ReplaceWith, 
VARIANT* Replace, VARIANT* MatchKashida, VARIANT* MatchDiacritics, VARIANT* MatchAlefHamza, VARIANT* MatchControl)
{
BOOL 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(0x1bc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
FindText, MatchCase, MatchWholeWord, MatchWildcards, MatchSoundsLike, MatchAllWordForms, Forward, Wrap, Format, ReplaceWith, Replace, MatchKashida, MatchDiacritics, MatchAlefHamza, MatchControl);
return result;
}


long Find::GetNoProofing()
{
long result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Find::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Find::GetMatchKashida()
{
BOOL result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchKashida(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchDiacritics()
{
BOOL result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchDiacritics(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchAlefHamza()
{
BOOL result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchAlefHamza(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Find::GetMatchControl()
{
BOOL result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Find::SetMatchControl(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Replacement properties


/
// Replacement operations


LPDISPATCH Replacement::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Replacement::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Replacement::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Replacement::GetFont()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Replacement::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Replacement::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Replacement::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Replacement::GetStyle()
{
VARIANT result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Replacement::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Replacement::GetText()
{
CString result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Replacement::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Replacement::GetLanguageID()
{
long result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Replacement::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Replacement::GetHighlight()
{
long result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Replacement::SetHighlight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Replacement::GetFrame()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Replacement::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Replacement::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Replacement::ClearFormatting()
{
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Replacement::GetNoProofing()
{
long result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Replacement::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Characters properties


/
// Characters operations


LPUNKNOWN Characters::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Characters::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Characters::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Characters::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Characters::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Characters::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Characters::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Characters::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Words properties


/
// Words operations


LPUNKNOWN Words::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Words::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Words::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Words::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Words::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Words::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Words::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Words::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Sentences properties


/
// Sentences operations


LPUNKNOWN Sentences::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Sentences::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Sentences::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sentences::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sentences::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Sentences::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Sentences::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sentences::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Sections properties


/
// Sections operations


LPUNKNOWN Sections::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Sections::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Sections::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sections::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sections::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Sections::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Sections::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Sections::GetPageSetup()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Sections::SetPageSetup(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Sections::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Sections::Add(VARIANT* Range, VARIANT* Start)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Start);
return result;
}




/
// Section properties


/
// Section operations


LPDISPATCH Section::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Section::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Section::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Section::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Section::GetPageSetup()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Section::SetPageSetup(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Section::GetHeaders()
{
LPDISPATCH result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Section::GetFooters()
{
LPDISPATCH result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Section::GetProtectedForForms()
{
BOOL result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Section::SetProtectedForForms(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Section::GetIndex()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Section::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Section::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}




/
// Paragraphs properties


/
// Paragraphs operations


LPUNKNOWN Paragraphs::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Paragraphs::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraphs::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraphs::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraphs::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Paragraphs::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraphs::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraphs::GetFormat()
{
LPDISPATCH result;
InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraphs::SetFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Paragraphs::GetTabStops()
{
LPDISPATCH result;
InvokeHelper(0x44f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraphs::SetTabStops(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Paragraphs::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraphs::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Paragraphs::GetStyle()
{
VARIANT result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Paragraphs::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraphs::GetAlignment()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetKeepTogether()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetKeepTogether(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetKeepWithNext()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetKeepWithNext(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetPageBreakBefore()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetPageBreakBefore(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetNoLineNumber()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetNoLineNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Paragraphs::GetRightIndent()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetLeftIndent()
{
float result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetFirstLineIndent()
{
float result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetLineSpacing()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetLineSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraphs::GetLineSpacingRule()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetLineSpacingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Paragraphs::GetSpaceBefore()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetSpaceBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetSpaceAfter()
{
float result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetSpaceAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraphs::GetHyphenation()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetHyphenation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetWidowControl()
{
long result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetWidowControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Paragraphs::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Paragraphs::GetFarEastLineBreakControl()
{
long result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetFarEastLineBreakControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetWordWrap()
{
long result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetWordWrap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetHangingPunctuation()
{
long result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetHangingPunctuation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetHalfWidthPunctuationOnTopOfLine()
{
long result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetHalfWidthPunctuationOnTopOfLine(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetAddSpaceBetweenFarEastAndAlpha()
{
long result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetAddSpaceBetweenFarEastAndAlpha(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetAddSpaceBetweenFarEastAndDigit()
{
long result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetAddSpaceBetweenFarEastAndDigit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetBaseLineAlignment()
{
long result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetBaseLineAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetAutoAdjustRightIndent()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetAutoAdjustRightIndent(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetDisableLineHeightGrid()
{
long result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetDisableLineHeightGrid(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetOutlineLevel()
{
long result;
InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetOutlineLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Paragraphs::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Paragraphs::Add(VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


void Paragraphs::CloseUp()
{
InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::OpenUp()
{
InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::OpenOrCloseUp()
{
InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::TabHangingIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraphs::TabIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x132, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraphs::Reset()
{
InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::Space1()
{
InvokeHelper(0x139, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::Space15()
{
InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::Space2()
{
InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::IndentCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x140, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraphs::IndentFirstLineCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x142, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraphs::OutlinePromote()
{
InvokeHelper(0x144, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::OutlineDemote()
{
InvokeHelper(0x145, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::OutlineDemoteToBody()
{
InvokeHelper(0x146, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::Indent()
{
InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::Outdent()
{
InvokeHelper(0x14e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


float Paragraphs::GetCharacterUnitRightIndent()
{
float result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetCharacterUnitRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetCharacterUnitLeftIndent()
{
float result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetCharacterUnitLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetCharacterUnitFirstLineIndent()
{
float result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetCharacterUnitFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetLineUnitBefore()
{
float result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetLineUnitBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraphs::GetLineUnitAfter()
{
float result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetLineUnitAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraphs::GetReadingOrder()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetReadingOrder(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetSpaceBeforeAuto()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetSpaceBeforeAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraphs::GetSpaceAfterAuto()
{
long result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraphs::SetSpaceAfterAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Paragraphs::IncreaseSpacing()
{
InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraphs::DecreaseSpacing()
{
InvokeHelper(0x150, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Paragraph properties


/
// Paragraph operations


LPDISPATCH Paragraph::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraph::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Paragraph::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraph::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Paragraph::GetFormat()
{
LPDISPATCH result;
InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraph::SetFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Paragraph::GetTabStops()
{
LPDISPATCH result;
InvokeHelper(0x44f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraph::SetTabStops(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Paragraph::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Paragraph::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Paragraph::GetDropCap()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT Paragraph::GetStyle()
{
VARIANT result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Paragraph::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraph::GetAlignment()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetKeepTogether()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetKeepTogether(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetKeepWithNext()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetKeepWithNext(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetPageBreakBefore()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetPageBreakBefore(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetNoLineNumber()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetNoLineNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Paragraph::GetRightIndent()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetLeftIndent()
{
float result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetFirstLineIndent()
{
float result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetLineSpacing()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetLineSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraph::GetLineSpacingRule()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetLineSpacingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Paragraph::GetSpaceBefore()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetSpaceBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetSpaceAfter()
{
float result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetSpaceAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraph::GetHyphenation()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetHyphenation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetWidowControl()
{
long result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetWidowControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Paragraph::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Paragraph::GetFarEastLineBreakControl()
{
long result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetFarEastLineBreakControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetWordWrap()
{
long result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetWordWrap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetHangingPunctuation()
{
long result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetHangingPunctuation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetHalfWidthPunctuationOnTopOfLine()
{
long result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetHalfWidthPunctuationOnTopOfLine(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetAddSpaceBetweenFarEastAndAlpha()
{
long result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetAddSpaceBetweenFarEastAndAlpha(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetAddSpaceBetweenFarEastAndDigit()
{
long result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetAddSpaceBetweenFarEastAndDigit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetBaseLineAlignment()
{
long result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetBaseLineAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetAutoAdjustRightIndent()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetAutoAdjustRightIndent(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetDisableLineHeightGrid()
{
long result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetDisableLineHeightGrid(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetOutlineLevel()
{
long result;
InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetOutlineLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Paragraph::CloseUp()
{
InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::OpenUp()
{
InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::OpenOrCloseUp()
{
InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::TabHangingIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraph::TabIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x132, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraph::Reset()
{
InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::Space1()
{
InvokeHelper(0x139, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::Space15()
{
InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::Space2()
{
InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::IndentCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x140, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void Paragraph::IndentFirstLineCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x142, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


LPDISPATCH Paragraph::Next(VARIANT* Count)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x144, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Count);
return result;
}


LPDISPATCH Paragraph::Previous(VARIANT* Count)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x145, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Count);
return result;
}


void Paragraph::OutlinePromote()
{
InvokeHelper(0x146, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::OutlineDemote()
{
InvokeHelper(0x147, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::OutlineDemoteToBody()
{
InvokeHelper(0x148, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::Indent()
{
InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Paragraph::Outdent()
{
InvokeHelper(0x14e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


float Paragraph::GetCharacterUnitRightIndent()
{
float result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetCharacterUnitRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetCharacterUnitLeftIndent()
{
float result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetCharacterUnitLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetCharacterUnitFirstLineIndent()
{
float result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetCharacterUnitFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetLineUnitBefore()
{
float result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetLineUnitBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Paragraph::GetLineUnitAfter()
{
float result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Paragraph::SetLineUnitAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Paragraph::GetReadingOrder()
{
long result;
InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetReadingOrder(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Paragraph::GetId()
{
CString result;
InvokeHelper(0xcc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Paragraph::SetId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xcc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Paragraph::GetSpaceBeforeAuto()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetSpaceBeforeAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Paragraph::GetSpaceAfterAuto()
{
long result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Paragraph::SetSpaceAfterAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Paragraph::GetIsStyleSeparator()
{
BOOL result;
InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Paragraph::SelectNumber()
{
InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// DropCap properties


/
// DropCap operations


LPDISPATCH DropCap::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DropCap::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DropCap::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DropCap::GetPosition()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DropCap::SetPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString DropCap::GetFontName()
{
CString result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void DropCap::SetFontName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long DropCap::GetLinesToDrop()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DropCap::SetLinesToDrop(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float DropCap::GetDistanceFromText()
{
float result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void DropCap::SetDistanceFromText(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void DropCap::Clear()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DropCap::Enable()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TabStops properties


/
// TabStops operations


LPUNKNOWN TabStops::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TabStops::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStops::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TabStops::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStops::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStops::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TabStops::Add(float Position, VARIANT* Alignment, VARIANT* Leader)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4 VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Position, Alignment, Leader);
return result;
}


void TabStops::ClearAll()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH TabStops::Before(float Position)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Position);
return result;
}


LPDISPATCH TabStops::After(float Position)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Position);
return result;
}




/
// TabStop properties


/
// TabStop operations


LPDISPATCH TabStop::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TabStop::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStop::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TabStop::GetAlignment()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TabStop::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TabStop::GetLeader()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TabStop::SetLeader(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float TabStop::GetPosition()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TabStop::SetPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL TabStop::GetCustomTab()
{
BOOL result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStop::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH TabStop::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void TabStop::Clear()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// _ParagraphFormat properties


/
// _ParagraphFormat operations


LPDISPATCH _ParagraphFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _ParagraphFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _ParagraphFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _ParagraphFormat::GetDuplicate()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT _ParagraphFormat::GetStyle()
{
VARIANT result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _ParagraphFormat::GetAlignment()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetKeepTogether()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetKeepTogether(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetKeepWithNext()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetKeepWithNext(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetPageBreakBefore()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetPageBreakBefore(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetNoLineNumber()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetNoLineNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _ParagraphFormat::GetRightIndent()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetLeftIndent()
{
float result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetFirstLineIndent()
{
float result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetLineSpacing()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetLineSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _ParagraphFormat::GetLineSpacingRule()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetLineSpacingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _ParagraphFormat::GetSpaceBefore()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetSpaceBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetSpaceAfter()
{
float result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetSpaceAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _ParagraphFormat::GetHyphenation()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetHyphenation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetWidowControl()
{
long result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetWidowControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetFarEastLineBreakControl()
{
long result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetFarEastLineBreakControl(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetWordWrap()
{
long result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetWordWrap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetHangingPunctuation()
{
long result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetHangingPunctuation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetHalfWidthPunctuationOnTopOfLine()
{
long result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetHalfWidthPunctuationOnTopOfLine(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetAddSpaceBetweenFarEastAndAlpha()
{
long result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetAddSpaceBetweenFarEastAndAlpha(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetAddSpaceBetweenFarEastAndDigit()
{
long result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetAddSpaceBetweenFarEastAndDigit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetBaseLineAlignment()
{
long result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetBaseLineAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetAutoAdjustRightIndent()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetAutoAdjustRightIndent(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetDisableLineHeightGrid()
{
long result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetDisableLineHeightGrid(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _ParagraphFormat::GetTabStops()
{
LPDISPATCH result;
InvokeHelper(0x44f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetTabStops(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _ParagraphFormat::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _ParagraphFormat::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _ParagraphFormat::GetOutlineLevel()
{
long result;
InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetOutlineLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void _ParagraphFormat::CloseUp()
{
InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::OpenUp()
{
InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::OpenOrCloseUp()
{
InvokeHelper(0x12f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::TabHangingIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x130, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void _ParagraphFormat::TabIndent(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x132, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void _ParagraphFormat::Reset()
{
InvokeHelper(0x138, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::Space1()
{
InvokeHelper(0x139, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::Space15()
{
InvokeHelper(0x13a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::Space2()
{
InvokeHelper(0x13b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _ParagraphFormat::IndentCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x140, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


void _ParagraphFormat::IndentFirstLineCharWidth(short Count)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x142, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Count);
}


float _ParagraphFormat::GetCharacterUnitRightIndent()
{
float result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetCharacterUnitRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetCharacterUnitLeftIndent()
{
float result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetCharacterUnitLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetCharacterUnitFirstLineIndent()
{
float result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetCharacterUnitFirstLineIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetLineUnitBefore()
{
float result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetLineUnitBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _ParagraphFormat::GetLineUnitAfter()
{
float result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetLineUnitAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _ParagraphFormat::GetReadingOrder()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetReadingOrder(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetSpaceBeforeAuto()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetSpaceBeforeAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _ParagraphFormat::GetSpaceAfterAuto()
{
long result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _ParagraphFormat::SetSpaceAfterAuto(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// _Font properties


/
// _Font operations


LPDISPATCH _Font::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Font::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _Font::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _Font::GetDuplicate()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Font::GetBold()
{
long result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetBold(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetItalic()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetItalic(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetHidden()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetHidden(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetSmallCaps()
{
long result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetSmallCaps(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetAllCaps()
{
long result;
InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetAllCaps(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetStrikeThrough()
{
long result;
InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetStrikeThrough(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x87, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetDoubleStrikeThrough()
{
long result;
InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetDoubleStrikeThrough(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetColorIndex()
{
long result;
InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetSubscript()
{
long result;
InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetSubscript(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetSuperscript()
{
long result;
InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetSuperscript(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetUnderline()
{
long result;
InvokeHelper(0x8c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetUnderline(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _Font::GetSize()
{
float result;
InvokeHelper(0x8d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Font::SetSize(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString _Font::GetName()
{
CString result;
InvokeHelper(0x8e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Font::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x8e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _Font::GetPosition()
{
long result;
InvokeHelper(0x8f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _Font::GetSpacing()
{
float result;
InvokeHelper(0x90, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Font::SetSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x90, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _Font::GetScaling()
{
long result;
InvokeHelper(0x91, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetScaling(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x91, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetShadow()
{
long result;
InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetShadow(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x92, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetOutline()
{
long result;
InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetOutline(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x93, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetEmboss()
{
long result;
InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetEmboss(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x94, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _Font::GetKerning()
{
float result;
InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Font::SetKerning(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x95, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long _Font::GetEngrave()
{
long result;
InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetEngrave(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x96, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetAnimation()
{
long result;
InvokeHelper(0x97, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetAnimation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x97, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH _Font::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _Font::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH _Font::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x99, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _Font::GetEmphasisMark()
{
long result;
InvokeHelper(0x9a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetEmphasisMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _Font::GetDisableCharacterSpaceGrid()
{
BOOL result;
InvokeHelper(0x9b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _Font::SetDisableCharacterSpaceGrid(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _Font::GetNameFarEast()
{
CString result;
InvokeHelper(0x9c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Font::SetNameFarEast(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x9c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Font::GetNameAscii()
{
CString result;
InvokeHelper(0x9d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Font::SetNameAscii(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x9d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _Font::GetNameOther()
{
CString result;
InvokeHelper(0x9e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Font::SetNameOther(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x9e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void _Font::Grow()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Font::Shrink()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Font::Reset()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _Font::SetAsTemplateDefault()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long _Font::GetColor()
{
long result;
InvokeHelper(0x9f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetBoldBi()
{
long result;
InvokeHelper(0xa0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetBoldBi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetItalicBi()
{
long result;
InvokeHelper(0xa1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetItalicBi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _Font::GetSizeBi()
{
float result;
InvokeHelper(0xa2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _Font::SetSizeBi(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString _Font::GetNameBi()
{
CString result;
InvokeHelper(0xa3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _Font::SetNameBi(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _Font::GetColorIndexBi()
{
long result;
InvokeHelper(0xa4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetColorIndexBi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetDiacriticColor()
{
long result;
InvokeHelper(0xa5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetDiacriticColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long _Font::GetUnderlineColor()
{
long result;
InvokeHelper(0xa6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _Font::SetUnderlineColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Table properties


/
// Table operations


LPDISPATCH Table::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Table::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Table::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Table::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Table::GetColumns()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Table::GetRows()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Table::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Table::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Table::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Table::GetUniform()
{
BOOL result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Table::GetAutoFormatType()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Table::Select()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Table::Delete()
{
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Table::SortAscending()
{
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Table::SortDescending()
{
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Table::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, NULL, parms,
Format, ApplyBorders, ApplyShading, ApplyFont, ApplyColor, ApplyHeadingRows, ApplyLastRow, ApplyFirstColumn, ApplyLastColumn, AutoFit);
}


void Table::UpdateAutoFormat()
{
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Table::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 Table::Split(VARIANT* BeforeRow)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeforeRow);
return result;
}


LPDISPATCH Table::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 Table::AutoFitBehavior(long Behavior)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Behavior);
}


void Table::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, NULL, parms,
ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID);
}


LPDISPATCH Table::GetTables()
{
LPDISPATCH result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Table::GetNestingLevel()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Table::GetAllowPageBreaks()
{
BOOL result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetAllowPageBreaks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Table::GetAllowAutoFit()
{
BOOL result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetAllowAutoFit(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Table::GetPreferredWidth()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetPreferredWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Table::GetPreferredWidthType()
{
long result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Table::SetPreferredWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Table::GetTopPadding()
{
float result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetTopPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Table::GetBottomPadding()
{
float result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetBottomPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Table::GetLeftPadding()
{
float result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetLeftPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Table::GetRightPadding()
{
float result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetRightPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Table::GetSpacing()
{
float result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Table::SetSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Table::GetTableDirection()
{
long result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Table::SetTableDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Table::GetId()
{
CString result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Table::SetId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


VARIANT Table::GetStyle()
{
VARIANT result;
InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Table::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Table::GetApplyStyleHeadingRows()
{
BOOL result;
InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetApplyStyleHeadingRows(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Table::GetApplyStyleLastRow()
{
BOOL result;
InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetApplyStyleLastRow(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Table::GetApplyStyleFirstColumn()
{
BOOL result;
InvokeHelper(0xcc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetApplyStyleFirstColumn(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xcc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Table::GetApplyStyleLastColumn()
{
BOOL result;
InvokeHelper(0xcd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Table::SetApplyStyleLastColumn(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xcd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Row properties


/
// Row operations


LPDISPATCH Row::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Row::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Row::GetAllowBreakAcrossPages()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Row::SetAllowBreakAcrossPages(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Row::GetAlignment()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Row::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Row::GetHeadingFormat()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Row::SetHeadingFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Row::GetSpaceBetweenColumns()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Row::SetSpaceBetweenColumns(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Row::GetHeight()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Row::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Row::GetHeightRule()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Row::SetHeightRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Row::GetLeftIndent()
{
float result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Row::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Row::GetIsLast()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Row::GetIsFirst()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Row::GetIndex()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetCells()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Row::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Row::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Row::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Row::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Row::Delete()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Row::SetLeftIndent(float LeftIndent, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LeftIndent, RulerStyle);
}


void Row::SetHeight(float RowHeight, long HeightRule)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
RowHeight, HeightRule);
}


LPDISPATCH Row::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 Row::GetNestingLevel()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString Row::GetId()
{
CString result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Row::SetId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}




/
// Column properties


/
// Column operations


LPDISPATCH Column::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Column::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Column::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Column::GetWidth()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Column::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Column::GetIsFirst()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Column::GetIsLast()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Column::GetIndex()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Column::GetCells()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Column::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Column::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Column::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Column::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Column::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Column::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Column::Delete()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Column::SetWidth(float ColumnWidth, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ColumnWidth, RulerStyle);
}


void Column::AutoFit()
{
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Column::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, NULL, parms,
ExcludeHeader, SortFieldType, SortOrder, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, IgnoreHe, LanguageID);
}


long Column::GetNestingLevel()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Column::GetPreferredWidth()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Column::SetPreferredWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Column::GetPreferredWidthType()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Column::SetPreferredWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Cell properties


/
// Cell operations


LPDISPATCH Cell::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Cell::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Cell::GetRowIndex()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Cell::GetColumnIndex()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Cell::GetWidth()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Cell::GetHeight()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Cell::GetHeightRule()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cell::SetHeightRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Cell::GetVerticalAlignment()
{
long result;
InvokeHelper(0x450, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cell::SetVerticalAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x450, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Cell::GetColumn()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetRow()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cell::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Cell::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void Cell::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Cell::Delete(VARIANT* ShiftCells)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShiftCells);
}


void Cell::Formula(VARIANT* Formula, VARIANT* NumFormat)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Formula, NumFormat);
}


void Cell::SetWidth(float ColumnWidth, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ColumnWidth, RulerStyle);
}


void Cell::SetHeight(VARIANT* RowHeight, long HeightRule)
{
static BYTE parms[] =
VTS_PVARIANT VTS_I4;
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
RowHeight, HeightRule);
}


void Cell::Merge(LPDISPATCH MergeTo)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
MergeTo);
}


void Cell::Split(VARIANT* NumRows, VARIANT* NumColumns)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xcd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumRows, NumColumns);
}


void Cell::AutoSum()
{
InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Cell::GetTables()
{
LPDISPATCH result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Cell::GetNestingLevel()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Cell::GetWordWrap()
{
BOOL result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Cell::SetWordWrap(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Cell::GetPreferredWidth()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetPreferredWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Cell::GetFitText()
{
BOOL result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Cell::SetFitText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Cell::GetTopPadding()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetTopPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Cell::GetBottomPadding()
{
float result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetBottomPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Cell::GetLeftPadding()
{
float result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetLeftPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Cell::GetRightPadding()
{
float result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cell::SetRightPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Cell::GetId()
{
CString result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Cell::SetId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Cell::GetPreferredWidthType()
{
long result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cell::SetPreferredWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Tables properties


/
// Tables operations


LPUNKNOWN Tables::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Tables::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Tables::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Tables::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Tables::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Tables::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Tables::Add(LPDISPATCH 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, NumRows, NumColumns, DefaultTableBehavior, AutoFitBehavior);
return result;
}


long Tables::GetNestingLevel()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// Rows properties


/
// Rows operations


LPUNKNOWN Rows::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Rows::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rows::GetAllowBreakAcrossPages()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetAllowBreakAcrossPages(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Rows::GetAlignment()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Rows::GetHeadingFormat()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetHeadingFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Rows::GetSpaceBetweenColumns()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetSpaceBetweenColumns(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetHeight()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Rows::GetHeightRule()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetHeightRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Rows::GetLeftIndent()
{
float result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Rows::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rows::GetLast()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rows::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Rows::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Rows::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rows::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Rows::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Rows::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rows::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Rows::Add(VARIANT* BeforeRow)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeforeRow);
return result;
}


void Rows::Select()
{
InvokeHelper(0xc7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Rows::Delete()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Rows::SetLeftIndent(float LeftIndent, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LeftIndent, RulerStyle);
}


void Rows::SetHeight(float RowHeight, long HeightRule)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
RowHeight, HeightRule);
}


void Rows::DistributeHeight()
{
InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Rows::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 Rows::GetWrapAroundText()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetWrapAroundText(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Rows::GetDistanceTop()
{
float result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetDistanceTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetDistanceBottom()
{
float result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetDistanceBottom(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetDistanceLeft()
{
float result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetDistanceLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetDistanceRight()
{
float result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetDistanceRight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetHorizontalPosition()
{
float result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetHorizontalPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Rows::GetVerticalPosition()
{
float result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Rows::SetVerticalPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Rows::GetRelativeHorizontalPosition()
{
long result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetRelativeHorizontalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Rows::GetRelativeVerticalPosition()
{
long result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetRelativeVerticalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Rows::GetAllowOverlap()
{
long result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetAllowOverlap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Rows::GetNestingLevel()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rows::GetTableDirection()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Rows::SetTableDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Columns properties


/
// Columns operations


LPUNKNOWN Columns::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Columns::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Columns::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Columns::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Columns::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Columns::GetFirst()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Columns::GetLast()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Columns::GetWidth()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Columns::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Columns::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Columns::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Columns::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Columns::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Columns::Add(VARIANT* BeforeColumn)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeforeColumn);
return result;
}


void Columns::Select()
{
InvokeHelper(0xc7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Columns::Delete()
{
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Columns::SetWidth(float ColumnWidth, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ColumnWidth, RulerStyle);
}


void Columns::AutoFit()
{
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Columns::DistributeWidth()
{
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Columns::GetNestingLevel()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Columns::GetPreferredWidth()
{
float result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Columns::SetPreferredWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Columns::GetPreferredWidthType()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Columns::SetPreferredWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Cells properties


/
// Cells operations


LPUNKNOWN Cells::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Cells::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Cells::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Cells::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Cells::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Cells::GetWidth()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cells::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Cells::GetHeight()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cells::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Cells::GetHeightRule()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cells::SetHeightRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Cells::GetVerticalAlignment()
{
long result;
InvokeHelper(0x450, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cells::SetVerticalAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x450, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Cells::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Cells::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Cells::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Cells::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Cells::Add(VARIANT* BeforeCell)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeforeCell);
return result;
}


void Cells::Delete(VARIANT* ShiftCells)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShiftCells);
}


void Cells::SetWidth(float ColumnWidth, long RulerStyle)
{
static BYTE parms[] =
VTS_R4 VTS_I4;
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ColumnWidth, RulerStyle);
}


void Cells::SetHeight(VARIANT* RowHeight, long HeightRule)
{
static BYTE parms[] =
VTS_PVARIANT VTS_I4;
InvokeHelper(0xcb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
RowHeight, HeightRule);
}


void Cells::Merge()
{
InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Cells::Split(VARIANT* NumRows, VARIANT* NumColumns, VARIANT* MergeBeforeSplit)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xcd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumRows, NumColumns, MergeBeforeSplit);
}


void Cells::DistributeHeight()
{
InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Cells::DistributeWidth()
{
InvokeHelper(0xcf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Cells::AutoFit()
{
InvokeHelper(0xd0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Cells::GetNestingLevel()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Cells::GetPreferredWidth()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Cells::SetPreferredWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Cells::GetPreferredWidthType()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Cells::SetPreferredWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// AutoCorrect properties


/
// AutoCorrect operations


LPDISPATCH AutoCorrect::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCorrect::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCorrect::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL AutoCorrect::GetCorrectDays()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectDays(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetCorrectInitialCaps()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectInitialCaps(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetCorrectSentenceCaps()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectSentenceCaps(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetReplaceText()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetReplaceText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH AutoCorrect::GetEntries()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCorrect::GetFirstLetterExceptions()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL AutoCorrect::GetFirstLetterAutoAdd()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetFirstLetterAutoAdd(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH AutoCorrect::GetTwoInitialCapsExceptions()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL AutoCorrect::GetTwoInitialCapsAutoAdd()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetTwoInitialCapsAutoAdd(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetCorrectCapsLock()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectCapsLock(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetCorrectHangulAndAlphabet()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectHangulAndAlphabet(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH AutoCorrect::GetHangulAndAlphabetExceptions()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL AutoCorrect::GetHangulAndAlphabetAutoAdd()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetHangulAndAlphabetAutoAdd(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetReplaceTextFromSpellingChecker()
{
BOOL result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetReplaceTextFromSpellingChecker(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetOtherCorrectionsAutoAdd()
{
BOOL result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetOtherCorrectionsAutoAdd(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH AutoCorrect::GetOtherCorrectionsExceptions()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL AutoCorrect::GetCorrectKeyboardSetting()
{
BOOL result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectKeyboardSetting(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetCorrectTableCells()
{
BOOL result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetCorrectTableCells(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AutoCorrect::GetDisplayAutoCorrectOptions()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrect::SetDisplayAutoCorrectOptions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// AutoCorrectEntries properties


/
// AutoCorrectEntries operations


LPDISPATCH AutoCorrectEntries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCorrectEntries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCorrectEntries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN AutoCorrectEntries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long AutoCorrectEntries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCorrectEntries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH AutoCorrectEntries::Add(LPCTSTR Name, LPCTSTR Value)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Value);
return result;
}


LPDISPATCH AutoCorrectEntries::AddRichText(LPCTSTR Name, LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_DISPATCH;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Range);
return result;
}




/
// AutoCorrectEntry properties


/
// AutoCorrectEntry operations


LPDISPATCH AutoCorrectEntry::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCorrectEntry::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCorrectEntry::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCorrectEntry::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString AutoCorrectEntry::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void AutoCorrectEntry::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString AutoCorrectEntry::GetValue()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void AutoCorrectEntry::SetValue(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL AutoCorrectEntry::GetRichText()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCorrectEntry::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void AutoCorrectEntry::Apply(LPDISPATCH Range)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Range);
}




/
// FirstLetterExceptions properties


/
// FirstLetterExceptions operations


LPDISPATCH FirstLetterExceptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FirstLetterExceptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FirstLetterExceptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN FirstLetterExceptions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long FirstLetterExceptions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FirstLetterExceptions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH FirstLetterExceptions::Add(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// FirstLetterException properties


/
// FirstLetterException operations


LPDISPATCH FirstLetterException::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FirstLetterException::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FirstLetterException::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FirstLetterException::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString FirstLetterException::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FirstLetterException::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TwoInitialCapsExceptions properties


/
// TwoInitialCapsExceptions operations


LPDISPATCH TwoInitialCapsExceptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TwoInitialCapsExceptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TwoInitialCapsExceptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN TwoInitialCapsExceptions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TwoInitialCapsExceptions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TwoInitialCapsExceptions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TwoInitialCapsExceptions::Add(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// TwoInitialCapsException properties


/
// TwoInitialCapsException operations


LPDISPATCH TwoInitialCapsException::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TwoInitialCapsException::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TwoInitialCapsException::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TwoInitialCapsException::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString TwoInitialCapsException::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TwoInitialCapsException::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Footnotes properties


/
// Footnotes operations


LPUNKNOWN Footnotes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Footnotes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnotes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Footnotes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnotes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Footnotes::GetLocation()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Footnotes::SetLocation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Footnotes::GetNumberStyle()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Footnotes::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Footnotes::GetStartingNumber()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Footnotes::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Footnotes::GetNumberingRule()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Footnotes::SetNumberingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Footnotes::GetSeparator()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnotes::GetContinuationSeparator()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnotes::GetContinuationNotice()
{
LPDISPATCH result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnotes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Footnotes::Add(LPDISPATCH Range, VARIANT* Reference, VARIANT* Text)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Reference, Text);
return result;
}


void Footnotes::Convert()
{
InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Footnotes::SwapWithEndnotes()
{
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Footnotes::ResetSeparator()
{
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Footnotes::ResetContinuationSeparator()
{
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Footnotes::ResetContinuationNotice()
{
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Endnotes properties


/
// Endnotes operations


LPUNKNOWN Endnotes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Endnotes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnotes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Endnotes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnotes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Endnotes::GetLocation()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Endnotes::SetLocation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Endnotes::GetNumberStyle()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Endnotes::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Endnotes::GetStartingNumber()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Endnotes::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Endnotes::GetNumberingRule()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Endnotes::SetNumberingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Endnotes::GetSeparator()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnotes::GetContinuationSeparator()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnotes::GetContinuationNotice()
{
LPDISPATCH result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnotes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Endnotes::Add(LPDISPATCH Range, VARIANT* Reference, VARIANT* Text)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Reference, Text);
return result;
}


void Endnotes::Convert()
{
InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Endnotes::SwapWithFootnotes()
{
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Endnotes::ResetSeparator()
{
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Endnotes::ResetContinuationSeparator()
{
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Endnotes::ResetContinuationNotice()
{
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Comments properties


/
// Comments operations


LPUNKNOWN Comments::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Comments::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Comments::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Comments::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Comments::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Comments::GetShowBy()
{
CString result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Comments::SetShowBy(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Comments::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Comments::Add(LPDISPATCH Range, VARIANT* Text)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT;
InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Text);
return result;
}




/
// Footnote properties


/
// Footnote operations


LPDISPATCH Footnote::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Footnote::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnote::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnote::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Footnote::GetReference()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Footnote::GetIndex()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Footnote::Delete()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Endnote properties


/
// Endnote operations


LPDISPATCH Endnote::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Endnote::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnote::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnote::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Endnote::GetReference()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Endnote::GetIndex()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Endnote::Delete()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Comment properties


/
// Comment operations


LPDISPATCH Comment::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Comment::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Comment::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Comment::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Comment::GetReference()
{
LPDISPATCH result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Comment::GetScope()
{
LPDISPATCH result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Comment::GetIndex()
{
long result;
InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString Comment::GetAuthor()
{
CString result;
InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Comment::SetAuthor(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3ef, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Comment::GetInitial()
{
CString result;
InvokeHelper(0x3f0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Comment::SetInitial(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL Comment::GetShowTip()
{
BOOL result;
InvokeHelper(0x3f1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Comment::SetShowTip(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3f1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Comment::Delete()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Comment::Edit()
{
InvokeHelper(0x3f3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


DATE Comment::GetDate()
{
DATE result;
InvokeHelper(0x3f2, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
return result;
}


BOOL Comment::GetIsInk()
{
BOOL result;
InvokeHelper(0x3f4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}




/
// Borders properties


/
// Borders operations


LPDISPATCH Borders::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Borders::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Borders::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Borders::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Borders::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Borders::GetEnable()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetEnable(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetDistanceFromTop()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetDistanceFromTop(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Borders::GetShadow()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetShadow(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Borders::GetInsideLineStyle()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetInsideLineStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetOutsideLineStyle()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetOutsideLineStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetInsideLineWidth()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetInsideLineWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetOutsideLineWidth()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetOutsideLineWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetInsideColorIndex()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetInsideColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetOutsideColorIndex()
{
long result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetOutsideColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetDistanceFromLeft()
{
long result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetDistanceFromLeft(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetDistanceFromBottom()
{
long result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetDistanceFromBottom(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetDistanceFromRight()
{
long result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetDistanceFromRight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Borders::GetAlwaysInFront()
{
BOOL result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetAlwaysInFront(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Borders::GetSurroundHeader()
{
BOOL result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetSurroundHeader(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Borders::GetSurroundFooter()
{
BOOL result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetSurroundFooter(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Borders::GetJoinBorders()
{
BOOL result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetJoinBorders(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Borders::GetHasHorizontal()
{
BOOL result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Borders::GetHasVertical()
{
BOOL result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Borders::GetDistanceFrom()
{
long result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetDistanceFrom(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Borders::GetEnableFirstPageInSection()
{
BOOL result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetEnableFirstPageInSection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Borders::GetEnableOtherPagesInSection()
{
BOOL result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Borders::SetEnableOtherPagesInSection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Borders::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Borders::ApplyPageBordersToAllSections()
{
InvokeHelper(0x7d0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Borders::GetInsideColor()
{
long result;
InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetInsideColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Borders::GetOutsideColor()
{
long result;
InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Borders::SetOutsideColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Border properties


/
// Border operations


LPDISPATCH Border::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Border::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Border::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Border::GetVisible()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Border::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Border::GetColorIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Border::GetInside()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Border::GetLineStyle()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetLineStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Border::GetLineWidth()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetLineWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Border::GetArtStyle()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetArtStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Border::GetArtWidth()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetArtWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Border::GetColor()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Border::SetColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Shading properties


/
// Shading operations


LPDISPATCH Shading::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shading::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shading::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shading::GetForegroundPatternColorIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shading::SetForegroundPatternColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shading::GetBackgroundPatternColorIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shading::SetBackgroundPatternColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shading::GetTexture()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shading::SetTexture(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shading::GetForegroundPatternColor()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shading::SetForegroundPatternColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shading::GetBackgroundPatternColor()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shading::SetBackgroundPatternColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// TextRetrievalMode properties


/
// TextRetrievalMode operations


LPDISPATCH TextRetrievalMode::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextRetrievalMode::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextRetrievalMode::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextRetrievalMode::GetViewType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextRetrievalMode::SetViewType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH TextRetrievalMode::GetDuplicate()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TextRetrievalMode::GetIncludeHiddenText()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TextRetrievalMode::SetIncludeHiddenText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TextRetrievalMode::GetIncludeFieldCodes()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TextRetrievalMode::SetIncludeFieldCodes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// AutoTextEntries properties


/
// AutoTextEntries operations


LPDISPATCH AutoTextEntries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoTextEntries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoTextEntries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN AutoTextEntries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long AutoTextEntries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoTextEntries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH AutoTextEntries::Add(LPCTSTR Name, LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_DISPATCH;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Range);
return result;
}


LPDISPATCH AutoTextEntries::AppendToSpike(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}




/
// AutoTextEntry properties


/
// AutoTextEntry operations


LPDISPATCH AutoTextEntry::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoTextEntry::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoTextEntry::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoTextEntry::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString AutoTextEntry::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void AutoTextEntry::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString AutoTextEntry::GetStyleName()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString AutoTextEntry::GetValue()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void AutoTextEntry::SetValue(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void AutoTextEntry::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH AutoTextEntry::Insert(LPDISPATCH Where, VARIANT* RichText)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Where, RichText);
return result;
}




/
// System properties


/
// System operations


LPDISPATCH System::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long System::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH System::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString System::GetOperatingSystem()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString System::GetProcessorType()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString System::GetVersion()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long System::GetFreeDiskSpace()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString System::GetLanguageDesignation()
{
CString result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long System::GetHorizontalResolution()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long System::GetVerticalResolution()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString System::GetProfileString(LPCTSTR Section, LPCTSTR Key)
{
CString result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
Section, Key);
return result;
}


void System::SetProfileString(LPCTSTR Section, LPCTSTR Key, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BSTR;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
Section, Key, lpszNewValue);
}


CString System::GetPrivateProfileString(LPCTSTR FileName, LPCTSTR Section, LPCTSTR Key)
{
CString result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
FileName, Section, Key);
return result;
}


void System::SetPrivateProfileString(LPCTSTR FileName, LPCTSTR Section, LPCTSTR Key, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BSTR VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
FileName, Section, Key, lpszNewValue);
}


BOOL System::GetMathCoprocessorInstalled()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString System::GetComputerType()
{
CString result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString System::GetMacintoshName()
{
CString result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL System::GetQuickDrawInstalled()
{
BOOL result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long System::GetCursor()
{
long result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void System::SetCursor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void System::MSInfo()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void System::Connect(LPCTSTR Path, VARIANT* Drive, VARIANT* Password)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Path, Drive, Password);
}


long System::GetCountryRegion()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// OLEFormat properties


/
// OLEFormat operations


LPDISPATCH OLEFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long OLEFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH OLEFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString OLEFormat::GetClassType()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void OLEFormat::SetClassType(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL OLEFormat::GetDisplayAsIcon()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void OLEFormat::SetDisplayAsIcon(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString OLEFormat::GetIconName()
{
CString result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void OLEFormat::SetIconName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString OLEFormat::GetIconPath()
{
CString result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long OLEFormat::GetIconIndex()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void OLEFormat::SetIconIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString OLEFormat::GetIconLabel()
{
CString result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void OLEFormat::SetIconLabel(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString OLEFormat::GetLabel()
{
CString result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH OLEFormat::GetObject()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString OLEFormat::GetProgID()
{
CString result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void OLEFormat::Activate()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void OLEFormat::Edit()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void OLEFormat::Open()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void OLEFormat::DoVerb(VARIANT* VerbIndex)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x6d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
VerbIndex);
}


void OLEFormat::ConvertTo(VARIANT* ClassType, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ClassType, DisplayAsIcon, IconFileName, IconIndex, IconLabel);
}


void OLEFormat::ActivateAs(LPCTSTR ClassType)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ClassType);
}


BOOL OLEFormat::GetPreserveFormattingOnUpdate()
{
BOOL result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void OLEFormat::SetPreserveFormattingOnUpdate(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// LinkFormat properties


/
// LinkFormat operations


LPDISPATCH LinkFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LinkFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH LinkFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL LinkFormat::GetAutoUpdate()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void LinkFormat::SetAutoUpdate(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString LinkFormat::GetSourceName()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString LinkFormat::GetSourcePath()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL LinkFormat::GetLocked()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void LinkFormat::SetLocked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long LinkFormat::GetType()
{
long result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString LinkFormat::GetSourceFullName()
{
CString result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void LinkFormat::SetSourceFullName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL LinkFormat::GetSavePictureWithDocument()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void LinkFormat::SetSavePictureWithDocument(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void LinkFormat::BreakLink()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void LinkFormat::Update()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// _OLEControl properties


/
// _OLEControl operations


float _OLEControl::GetLeft()
{
float result;
InvokeHelper(0x80010103, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _OLEControl::SetLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80010103, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _OLEControl::GetTop()
{
float result;
InvokeHelper(0x80010104, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _OLEControl::SetTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80010104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _OLEControl::GetHeight()
{
float result;
InvokeHelper(0x80010105, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _OLEControl::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80010105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float _OLEControl::GetWidth()
{
float result;
InvokeHelper(0x80010106, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _OLEControl::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80010106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString _OLEControl::GetName()
{
CString result;
InvokeHelper(0x80010000, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _OLEControl::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x80010000, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH _OLEControl::GetAutomation()
{
LPDISPATCH result;
InvokeHelper(0x80010107, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void _OLEControl::Select()
{
InvokeHelper(0x80010220, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _OLEControl::Copy()
{
InvokeHelper(0x80010228, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _OLEControl::Cut()
{
InvokeHelper(0x80010229, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _OLEControl::Delete()
{
InvokeHelper(0x80010250, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void _OLEControl::Activate()
{
InvokeHelper(0x80010251, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Fields properties


/
// Fields operations


LPDISPATCH Fields::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Fields::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Fields::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Fields::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Fields::GetLocked()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Fields::SetLocked(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPUNKNOWN Fields::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Fields::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Fields::ToggleShowCodes()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Fields::Update()
{
long result;
InvokeHelper(0x65, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
return result;
}


void Fields::Unlink()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Fields::UpdateSource()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Fields::Add(LPDISPATCH Range, VARIANT* Type, VARIANT* Text, VARIANT* PreserveFormatting)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Type, Text, PreserveFormatting);
return result;
}




/
// Field properties


/
// Field operations


LPDISPATCH Field::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Field::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetCode()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Field::SetCode(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Field::GetType()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Field::GetLocked()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Field::SetLocked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Field::GetKind()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetResult()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Field::SetResult(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Field::GetData()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Field::SetData(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Field::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Field::GetIndex()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Field::GetShowCodes()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Field::SetShowCodes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Field::GetLinkFormat()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetOLEFormat()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Field::GetInlineShape()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Field::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Field::Update()
{
BOOL result;
InvokeHelper(0x65, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
return result;
}


void Field::Unlink()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Field::UpdateSource()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Field::DoClick()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Field::Copy()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Field::Cut()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Field::Delete()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Browser properties


/
// Browser operations


LPDISPATCH Browser::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Browser::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Browser::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Browser::GetTarget()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Browser::SetTarget(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Browser::Next()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Browser::Previous()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Styles properties


/
// Styles operations


LPDISPATCH Styles::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Styles::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Styles::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Styles::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Styles::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Styles::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Styles::Add(LPCTSTR Name, VARIANT* Type)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Type);
return result;
}




/
// Style properties


/
// Style operations


LPDISPATCH Style::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Style::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Style::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Style::GetNameLocal()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Style::SetNameLocal(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


VARIANT Style::GetBaseStyle()
{
VARIANT result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Style::SetBaseStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Style::GetDescription()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long Style::GetType()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Style::GetBuiltIn()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


VARIANT Style::GetNextParagraphStyle()
{
VARIANT result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Style::SetNextParagraphStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Style::GetInUse()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH Style::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Style::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Style::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Style::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Style::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Style::GetFont()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Style::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Style::GetFrame()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Style::GetLanguageID()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Style::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Style::GetAutomaticallyUpdate()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Style::SetAutomaticallyUpdate(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Style::GetListTemplate()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Style::GetListLevelNumber()
{
long result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Style::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Style::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Style::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Style::LinkToListTemplate(LPDISPATCH ListTemplate, VARIANT* ListLevelNumber)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ListTemplate, ListLevelNumber);
}


long Style::GetNoProofing()
{
long result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Style::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


VARIANT Style::GetLinkStyle()
{
VARIANT result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Style::SetLinkStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Style::GetNoSpaceBetweenParagraphsOfSameStyle()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Style::SetNoSpaceBetweenParagraphsOfSameStyle(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Style::GetTable()
{
LPDISPATCH result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Style::GetLocked()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Style::SetLocked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Frames properties


/
// Frames operations


LPDISPATCH Frames::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Frames::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Frames::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Frames::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Frames::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Frames::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Frames::Add(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


void Frames::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Frame properties


/
// Frame operations


LPDISPATCH Frame::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Frame::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Frame::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Frame::GetHeightRule()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frame::SetHeightRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frame::GetWidthRule()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frame::SetWidthRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Frame::GetHorizontalDistanceFromText()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetHorizontalDistanceFromText(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Frame::GetHeight()
{
float result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Frame::GetHorizontalPosition()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetHorizontalPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Frame::GetLockAnchor()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Frame::SetLockAnchor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Frame::GetRelativeHorizontalPosition()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frame::SetRelativeHorizontalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frame::GetRelativeVerticalPosition()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frame::SetRelativeVerticalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Frame::GetVerticalDistanceFromText()
{
float result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetVerticalDistanceFromText(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Frame::GetVerticalPosition()
{
float result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetVerticalPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Frame::GetWidth()
{
float result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frame::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Frame::GetTextWrap()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Frame::SetTextWrap(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Frame::GetShading()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Frame::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Frame::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Frame::GetRange()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Frame::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Frame::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Frame::Copy()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Frame::Cut()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// FormFields properties


/
// FormFields operations


LPDISPATCH FormFields::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FormFields::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FormFields::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FormFields::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL FormFields::GetShaded()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void FormFields::SetShaded(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPUNKNOWN FormFields::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH FormFields::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH FormFields::Add(LPDISPATCH Range, long Type)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_I4;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Type);
return result;
}




/
// FormField properties


/
// FormField operations


LPDISPATCH FormField::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FormField::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FormField::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FormField::GetType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString FormField::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString FormField::GetEntryMacro()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetEntryMacro(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString FormField::GetExitMacro()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetExitMacro(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL FormField::GetOwnHelp()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void FormField::SetOwnHelp(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL FormField::GetOwnStatus()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void FormField::SetOwnStatus(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString FormField::GetHelpText()
{
CString result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetHelpText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString FormField::GetStatusText()
{
CString result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetStatusText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL FormField::GetEnabled()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void FormField::SetEnabled(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString FormField::GetResult()
{
CString result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void FormField::SetResult(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH FormField::GetTextInput()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FormField::GetCheckBox()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FormField::GetDropDown()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FormField::GetNext()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FormField::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL FormField::GetCalculateOnExit()
{
BOOL result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void FormField::SetCalculateOnExit(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH FormField::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void FormField::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void FormField::Copy()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void FormField::Cut()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void FormField::Delete()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TextInput properties


/
// TextInput operations


LPDISPATCH TextInput::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextInput::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextInput::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TextInput::GetValid()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString TextInput::GetDefault()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TextInput::SetDefault(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long TextInput::GetType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString TextInput::GetFormat()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long TextInput::GetWidth()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextInput::SetWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void TextInput::Clear()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TextInput::EditType(long Type, VARIANT* Default, VARIANT* Format, VARIANT* Enabled)
{
static BYTE parms[] =
VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type, Default, Format, Enabled);
}




/
// CheckBox properties


/
// CheckBox operations


LPDISPATCH CheckBox::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CheckBox::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CheckBox::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL CheckBox::GetValid()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL CheckBox::GetAutoSize()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void CheckBox::SetAutoSize(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float CheckBox::GetSize()
{
float result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CheckBox::SetSize(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL CheckBox::GetDefault()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void CheckBox::SetDefault(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL CheckBox::GetValue()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void CheckBox::SetValue(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// DropDown properties


/
// DropDown operations


LPDISPATCH DropDown::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DropDown::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DropDown::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL DropDown::GetValid()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long DropDown::GetDefault()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DropDown::SetDefault(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long DropDown::GetValue()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DropDown::SetValue(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH DropDown::GetListEntries()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// ListEntries properties


/
// ListEntries operations


LPDISPATCH ListEntries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListEntries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListEntries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN ListEntries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ListEntries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListEntries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH ListEntries::Add(LPCTSTR Name, VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Index);
return result;
}


void ListEntries::Clear()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// ListEntry properties


/
// ListEntry operations


LPDISPATCH ListEntry::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListEntry::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListEntry::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListEntry::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString ListEntry::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ListEntry::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void ListEntry::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TablesOfFigures properties


/
// TablesOfFigures operations


LPDISPATCH TablesOfFigures::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TablesOfFigures::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TablesOfFigures::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN TablesOfFigures::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TablesOfFigures::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long TablesOfFigures::GetFormat()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TablesOfFigures::SetFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH TablesOfFigures::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TablesOfFigures::MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* TableID, VARIANT* Level)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Entry, EntryAutoText, TableID, Level);
return result;
}


LPDISPATCH TablesOfFigures::Add(LPDISPATCH Range, VARIANT* Caption, VARIANT* IncludeLabel, VARIANT* UseHeadingStyles, VARIANT* UpperHeadingLevel, VARIANT* LowerHeadingLevel, VARIANT* UseFields, VARIANT* TableID, VARIANT* RightAlignPageNumbers, 
VARIANT* IncludePageNumbers, VARIANT* AddedStyles, VARIANT* UseHyperlinks, VARIANT* HidePageNumbersInWeb)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH 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_DISPATCH, (void*)&result, parms,
Range, Caption, IncludeLabel, UseHeadingStyles, UpperHeadingLevel, LowerHeadingLevel, UseFields, TableID, RightAlignPageNumbers, IncludePageNumbers, AddedStyles, UseHyperlinks, HidePageNumbersInWeb);
return result;
}




/
// TableOfFigures properties


/
// TableOfFigures operations


LPDISPATCH TableOfFigures::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfFigures::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TableOfFigures::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString TableOfFigures::GetCaption()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetCaption(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL TableOfFigures::GetIncludeLabel()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetIncludeLabel(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfFigures::GetRightAlignPageNumbers()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetRightAlignPageNumbers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfFigures::GetUseHeadingStyles()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetUseHeadingStyles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long TableOfFigures::GetLowerHeadingLevel()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetLowerHeadingLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TableOfFigures::GetUpperHeadingLevel()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetUpperHeadingLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL TableOfFigures::GetIncludePageNumbers()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetIncludePageNumbers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH TableOfFigures::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TableOfFigures::GetUseFields()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetUseFields(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString TableOfFigures::GetTableID()
{
CString result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetTableID(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH TableOfFigures::GetHeadingStyles()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfFigures::GetTabLeader()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetTabLeader(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void TableOfFigures::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TableOfFigures::UpdatePageNumbers()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TableOfFigures::Update()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL TableOfFigures::GetUseHyperlinks()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetUseHyperlinks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfFigures::GetHidePageNumbersInWeb()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfFigures::SetHidePageNumbersInWeb(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// MailMerge properties


/
// MailMerge operations


LPDISPATCH MailMerge::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMerge::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMerge::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMerge::GetMainDocumentType()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMerge::SetMainDocumentType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long MailMerge::GetState()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long MailMerge::GetDestination()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMerge::SetDestination(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH MailMerge::GetDataSource()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMerge::GetFields()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMerge::GetViewMailMergeFieldCodes()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMerge::SetViewMailMergeFieldCodes(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL MailMerge::GetSuppressBlankLines()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMerge::SetSuppressBlankLines(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL MailMerge::GetMailAsAttachment()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMerge::SetMailAsAttachment(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString MailMerge::GetMailAddressFieldName()
{
CString result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailMerge::SetMailAddressFieldName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString MailMerge::GetMailSubject()
{
CString result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailMerge::SetMailSubject(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void MailMerge::CreateDataSource(VARIANT* Name, VARIANT* PasswordDocument, VARIANT* WritePasswordDocument, VARIANT* HeaderRecord, VARIANT* MSQuery, VARIANT* SQLStatement, VARIANT* SQLStatement1, VARIANT* Connection, VARIANT* LinkToSource)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, PasswordDocument, WritePasswordDocument, HeaderRecord, MSQuery, SQLStatement, SQLStatement1, Connection, LinkToSource);
}


void MailMerge::CreateHeaderSource(LPCTSTR Name, VARIANT* PasswordDocument, VARIANT* WritePasswordDocument, VARIANT* HeaderRecord)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, PasswordDocument, WritePasswordDocument, HeaderRecord);
}


void MailMerge::Execute(VARIANT* Pause)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Pause);
}


void MailMerge::Check()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMerge::EditDataSource()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMerge::EditHeaderSource()
{
InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMerge::EditMainDocument()
{
InvokeHelper(0x6d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL MailMerge::GetHighlightMergeFields()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMerge::SetHighlightMergeFields(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long MailMerge::GetMailFormat()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMerge::SetMailFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString MailMerge::GetShowSendToCustom()
{
CString result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailMerge::SetShowSendToCustom(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long MailMerge::GetWizardState()
{
long result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMerge::SetWizardState(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void MailMerge::OpenDataSource(LPCTSTR Name, VARIANT* Format, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* LinkToSource, VARIANT* AddToRecentFiles, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, 
VARIANT* WritePasswordDocument, VARIANT* WritePasswordTemplate, VARIANT* Connection, VARIANT* SQLStatement, VARIANT* SQLStatement1, VARIANT* OpenExclusive, VARIANT* SubType)
{
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;
InvokeHelper(0x70, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, Format, ConfirmConversions, ReadOnly, LinkToSource, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, Connection, SQLStatement, SQLStatement1, OpenExclusive, SubType);
}


void MailMerge::OpenHeaderSource(LPCTSTR Name, VARIANT* Format, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* AddToRecentFiles, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, VARIANT* WritePasswordDocument, 
VARIANT* WritePasswordTemplate, VARIANT* OpenExclusive)
{
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;
InvokeHelper(0x71, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, Format, ConfirmConversions, ReadOnly, AddToRecentFiles, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate, OpenExclusive);
}


void MailMerge::ShowWizard(VARIANT* InitialState, VARIANT* ShowDocumentStep, VARIANT* ShowTemplateStep, VARIANT* ShowDataStep, VARIANT* ShowWriteStep, VARIANT* ShowPreviewStep, VARIANT* ShowMergeStep)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x72, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
InitialState, ShowDocumentStep, ShowTemplateStep, ShowDataStep, ShowWriteStep, ShowPreviewStep, ShowMergeStep);
}




/
// MailMergeFields properties


/
// MailMergeFields operations


LPDISPATCH MailMergeFields::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeFields::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeFields::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN MailMergeFields::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long MailMergeFields::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeFields::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH MailMergeFields::Add(LPDISPATCH Range, LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Name);
return result;
}


LPDISPATCH MailMergeFields::AddAsk(LPDISPATCH Range, LPCTSTR Name, VARIANT* Prompt, VARIANT* DefaultAskText, VARIANT* AskOnce)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Name, Prompt, DefaultAskText, AskOnce);
return result;
}


LPDISPATCH MailMergeFields::AddFillIn(LPDISPATCH Range, VARIANT* Prompt, VARIANT* DefaultFillInText, VARIANT* AskOnce)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Prompt, DefaultFillInText, AskOnce);
return result;
}


LPDISPATCH MailMergeFields::AddIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo, VARIANT* TrueAutoText, VARIANT* TrueText, VARIANT* FalseAutoText, VARIANT* FalseText)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, MergeField, Comparison, CompareTo, TrueAutoText, TrueText, FalseAutoText, FalseText);
return result;
}


LPDISPATCH MailMergeFields::AddMergeRec(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH MailMergeFields::AddMergeSeq(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x6a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH MailMergeFields::AddNext(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x6b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH MailMergeFields::AddNextIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_I4 VTS_PVARIANT;
InvokeHelper(0x6c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, MergeField, Comparison, CompareTo);
return result;
}


LPDISPATCH MailMergeFields::AddSet(LPDISPATCH Range, LPCTSTR Name, VARIANT* ValueText, VARIANT* ValueAutoText)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x6d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Name, ValueText, ValueAutoText);
return result;
}


LPDISPATCH MailMergeFields::AddSkipIf(LPDISPATCH Range, LPCTSTR MergeField, long Comparison, VARIANT* CompareTo)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_I4 VTS_PVARIANT;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, MergeField, Comparison, CompareTo);
return result;
}




/
// MailMergeField properties


/
// MailMergeField operations


LPDISPATCH MailMergeField::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeField::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeField::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeField::GetType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL MailMergeField::GetLocked()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMergeField::SetLocked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH MailMergeField::GetCode()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void MailMergeField::SetCode(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH MailMergeField::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeField::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void MailMergeField::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMergeField::Copy()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMergeField::Cut()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMergeField::Delete()
{
InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// MailMergeDataSource properties


/
// MailMergeDataSource operations


LPDISPATCH MailMergeDataSource::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeDataSource::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeDataSource::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString MailMergeDataSource::GetName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString MailMergeDataSource::GetHeaderSourceName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long MailMergeDataSource::GetType()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long MailMergeDataSource::GetHeaderSourceType()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString MailMergeDataSource::GetConnectString()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString MailMergeDataSource::GetQueryString()
{
CString result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetQueryString(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long MailMergeDataSource::GetActiveRecord()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetActiveRecord(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long MailMergeDataSource::GetFirstRecord()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetFirstRecord(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long MailMergeDataSource::GetLastRecord()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetLastRecord(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH MailMergeDataSource::GetFieldNames()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeDataSource::GetDataFields()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeDataSource::GetRecordCount()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL MailMergeDataSource::GetIncluded()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetIncluded(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL MailMergeDataSource::GetInvalidAddress()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetInvalidAddress(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString MailMergeDataSource::GetInvalidComments()
{
CString result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailMergeDataSource::SetInvalidComments(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH MailMergeDataSource::GetMappedDataFields()
{
LPDISPATCH result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString MailMergeDataSource::GetTableName()
{
CString result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL MailMergeDataSource::FindRecord(LPCTSTR FindText, VARIANT* Field)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
FindText, Field);
return result;
}


void MailMergeDataSource::SetAllIncludedFlags(BOOL Included)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Included);
}


void MailMergeDataSource::SetAllErrorFlags(BOOL Invalid, LPCTSTR InvalidComment)
{
static BYTE parms[] =
VTS_BOOL VTS_BSTR;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Invalid, InvalidComment);
}


void MailMergeDataSource::Close()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// MailMergeFieldNames properties


/
// MailMergeFieldNames operations


LPDISPATCH MailMergeFieldNames::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeFieldNames::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeFieldNames::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN MailMergeFieldNames::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long MailMergeFieldNames::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeFieldNames::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// MailMergeFieldName properties


/
// MailMergeFieldName operations


LPDISPATCH MailMergeFieldName::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeFieldName::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeFieldName::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString MailMergeFieldName::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long MailMergeFieldName::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// MailMergeDataFields properties


/
// MailMergeDataFields operations


LPDISPATCH MailMergeDataFields::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeDataFields::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeDataFields::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN MailMergeDataFields::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long MailMergeDataFields::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeDataFields::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// MailMergeDataField properties


/
// MailMergeDataField operations


LPDISPATCH MailMergeDataField::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMergeDataField::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMergeDataField::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString MailMergeDataField::GetValue()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString MailMergeDataField::GetName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long MailMergeDataField::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// Envelope properties


/
// Envelope operations


LPDISPATCH Envelope::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Envelope::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Envelope::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Envelope::GetAddress()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Envelope::GetReturnAddress()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Envelope::GetDefaultPrintBarCode()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultPrintBarCode(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Envelope::GetDefaultPrintFIMA()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultPrintFIMA(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Envelope::GetDefaultHeight()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetDefaultWidth()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Envelope::GetDefaultSize()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultSize(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL Envelope::GetDefaultOmitReturnAddress()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultOmitReturnAddress(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Envelope::GetFeedSource()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Envelope::SetFeedSource(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Envelope::GetAddressFromLeft()
{
float result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetAddressFromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetAddressFromTop()
{
float result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetAddressFromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetReturnAddressFromLeft()
{
float result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetReturnAddressFromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetReturnAddressFromTop()
{
float result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetReturnAddressFromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Envelope::GetAddressStyle()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Envelope::GetReturnAddressStyle()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Envelope::GetDefaultOrientation()
{
long result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Envelope::GetDefaultFaceUp()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Envelope::SetDefaultFaceUp(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Envelope::UpdateDocument()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Envelope::Options()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Envelope::GetVertical()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Envelope::SetVertical(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Envelope::GetRecipientNamefromLeft()
{
float result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetRecipientNamefromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetRecipientNamefromTop()
{
float result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetRecipientNamefromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetRecipientPostalfromLeft()
{
float result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetRecipientPostalfromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetRecipientPostalfromTop()
{
float result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetRecipientPostalfromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetSenderNamefromLeft()
{
float result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetSenderNamefromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetSenderNamefromTop()
{
float result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetSenderNamefromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetSenderPostalfromLeft()
{
float result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetSenderPostalfromLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Envelope::GetSenderPostalfromTop()
{
float result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Envelope::SetSenderPostalfromTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void Envelope::Insert(VARIANT* ExtractAddress, VARIANT* Address, VARIANT* AutoText, VARIANT* OmitReturnAddress, VARIANT* ReturnAddress, VARIANT* ReturnAutoText, VARIANT* PrintBarCode, VARIANT* PrintFIMA, VARIANT* Size, VARIANT* Height, VARIANT* Width, 
VARIANT* FeedSource, VARIANT* AddressFromLeft, VARIANT* AddressFromTop, VARIANT* ReturnAddressFromLeft, VARIANT* ReturnAddressFromTop, VARIANT* DefaultFaceUp, VARIANT* DefaultOrientation, VARIANT* PrintEPostage, VARIANT* Vertical, 
VARIANT* RecipientNamefromLeft, VARIANT* RecipientNamefromTop, VARIANT* RecipientPostalfromLeft, VARIANT* RecipientPostalfromTop, VARIANT* SenderNamefromLeft, VARIANT* SenderNamefromTop, VARIANT* SenderPostalfromLeft, 
VARIANT* SenderPostalfromTop)
{
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 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ExtractAddress, Address, AutoText, OmitReturnAddress, ReturnAddress, ReturnAutoText, PrintBarCode, PrintFIMA, Size, Height, Width, FeedSource, AddressFromLeft, AddressFromTop, ReturnAddressFromLeft, ReturnAddressFromTop, DefaultFaceUp, 
DefaultOrientation, PrintEPostage, Vertical, RecipientNamefromLeft, RecipientNamefromTop, RecipientPostalfromLeft, RecipientPostalfromTop, SenderNamefromLeft, SenderNamefromTop, SenderPostalfromLeft, SenderPostalfromTop);
}


void Envelope::PrintOut(VARIANT* ExtractAddress, VARIANT* Address, VARIANT* AutoText, VARIANT* OmitReturnAddress, VARIANT* ReturnAddress, VARIANT* ReturnAutoText, VARIANT* PrintBarCode, VARIANT* PrintFIMA, VARIANT* Size, VARIANT* Height, 
VARIANT* Width, VARIANT* FeedSource, VARIANT* AddressFromLeft, VARIANT* AddressFromTop, VARIANT* ReturnAddressFromLeft, VARIANT* ReturnAddressFromTop, VARIANT* DefaultFaceUp, VARIANT* DefaultOrientation, VARIANT* PrintEPostage, 
VARIANT* Vertical, VARIANT* RecipientNamefromLeft, VARIANT* RecipientNamefromTop, VARIANT* RecipientPostalfromLeft, VARIANT* RecipientPostalfromTop, VARIANT* SenderNamefromLeft, VARIANT* SenderNamefromTop, VARIANT* SenderPostalfromLeft, 
VARIANT* SenderPostalfromTop)
{
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 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ExtractAddress, Address, AutoText, OmitReturnAddress, ReturnAddress, ReturnAutoText, PrintBarCode, PrintFIMA, Size, Height, Width, FeedSource, AddressFromLeft, AddressFromTop, ReturnAddressFromLeft, ReturnAddressFromTop, DefaultFaceUp, 
DefaultOrientation, PrintEPostage, Vertical, RecipientNamefromLeft, RecipientNamefromTop, RecipientPostalfromLeft, RecipientPostalfromTop, SenderNamefromLeft, SenderNamefromTop, SenderPostalfromLeft, SenderPostalfromTop);
}




/
// MailingLabel properties


/
// MailingLabel operations


LPDISPATCH MailingLabel::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailingLabel::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailingLabel::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL MailingLabel::GetDefaultPrintBarCode()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailingLabel::SetDefaultPrintBarCode(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long MailingLabel::GetDefaultLaserTray()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MailingLabel::SetDefaultLaserTray(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH MailingLabel::GetCustomLabels()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString MailingLabel::GetDefaultLabelName()
{
CString result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void MailingLabel::SetDefaultLabelName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void MailingLabel::LabelOptions()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH MailingLabel::CreateNewDocument(VARIANT* Name, VARIANT* Address, VARIANT* AutoText, VARIANT* ExtractAddress, VARIANT* LaserTray, VARIANT* PrintEPostageLabel, VARIANT* Vertical)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Address, AutoText, ExtractAddress, LaserTray, PrintEPostageLabel, Vertical);
return result;
}


void MailingLabel::PrintOut(VARIANT* Name, VARIANT* Address, VARIANT* ExtractAddress, VARIANT* LaserTray, VARIANT* SingleLabel, VARIANT* Row, VARIANT* Column, VARIANT* PrintEPostageLabel, VARIANT* Vertical)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Name, Address, ExtractAddress, LaserTray, SingleLabel, Row, Column, PrintEPostageLabel, Vertical);
}


BOOL MailingLabel::GetVertical()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void MailingLabel::SetVertical(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// CustomLabels properties


/
// CustomLabels operations


LPDISPATCH CustomLabels::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CustomLabels::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomLabels::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN CustomLabels::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long CustomLabels::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomLabels::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH CustomLabels::Add(LPCTSTR Name, VARIANT* DotMatrix)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, DotMatrix);
return result;
}




/
// CustomLabel properties


/
// CustomLabel operations


LPDISPATCH CustomLabel::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CustomLabel::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomLabel::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CustomLabel::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString CustomLabel::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void CustomLabel::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


float CustomLabel::GetTopMargin()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetTopMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CustomLabel::GetSideMargin()
{
float result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetSideMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CustomLabel::GetHeight()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CustomLabel::GetWidth()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CustomLabel::GetVerticalPitch()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetVerticalPitch(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CustomLabel::GetHorizontalPitch()
{
float result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetHorizontalPitch(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long CustomLabel::GetNumberAcross()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetNumberAcross(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CustomLabel::GetNumberDown()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetNumberDown(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL CustomLabel::GetDotMatrix()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long CustomLabel::GetPageSize()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CustomLabel::SetPageSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL CustomLabel::GetValid()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void CustomLabel::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TablesOfContents properties


/
// TablesOfContents operations


LPDISPATCH TablesOfContents::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TablesOfContents::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TablesOfContents::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN TablesOfContents::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TablesOfContents::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long TablesOfContents::GetFormat()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TablesOfContents::SetFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH TablesOfContents::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TablesOfContents::MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* TableID, VARIANT* Level)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Entry, EntryAutoText, TableID, Level);
return result;
}


LPDISPATCH TablesOfContents::Add(LPDISPATCH Range, VARIANT* UseHeadingStyles, VARIANT* UpperHeadingLevel, VARIANT* LowerHeadingLevel, VARIANT* UseFields, VARIANT* TableID, VARIANT* RightAlignPageNumbers, VARIANT* IncludePageNumbers, VARIANT* AddedStyles, 
VARIANT* UseHyperlinks, VARIANT* HidePageNumbersInWeb, VARIANT* UseOutlineLevels)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, UseHeadingStyles, UpperHeadingLevel, LowerHeadingLevel, UseFields, TableID, RightAlignPageNumbers, IncludePageNumbers, AddedStyles, UseHyperlinks, HidePageNumbersInWeb, UseOutlineLevels);
return result;
}




/
// TableOfContents properties


/
// TableOfContents operations


LPDISPATCH TableOfContents::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfContents::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TableOfContents::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TableOfContents::GetUseHeadingStyles()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetUseHeadingStyles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfContents::GetUseFields()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetUseFields(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long TableOfContents::GetUpperHeadingLevel()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfContents::SetUpperHeadingLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TableOfContents::GetLowerHeadingLevel()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfContents::SetLowerHeadingLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString TableOfContents::GetTableID()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfContents::SetTableID(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH TableOfContents::GetHeadingStyles()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TableOfContents::GetRightAlignPageNumbers()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetRightAlignPageNumbers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfContents::GetIncludePageNumbers()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetIncludePageNumbers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH TableOfContents::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfContents::GetTabLeader()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfContents::SetTabLeader(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void TableOfContents::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TableOfContents::UpdatePageNumbers()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TableOfContents::Update()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL TableOfContents::GetUseHyperlinks()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetUseHyperlinks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfContents::GetHidePageNumbersInWeb()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfContents::SetHidePageNumbersInWeb(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// TablesOfAuthorities properties


/
// TablesOfAuthorities operations


LPDISPATCH TablesOfAuthorities::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TablesOfAuthorities::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TablesOfAuthorities::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN TablesOfAuthorities::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TablesOfAuthorities::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long TablesOfAuthorities::GetFormat()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TablesOfAuthorities::SetFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH TablesOfAuthorities::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TablesOfAuthorities::Add(LPDISPATCH Range, VARIANT* Category, VARIANT* Bookmark, VARIANT* Passim, VARIANT* KeepEntryFormatting, VARIANT* Separator, VARIANT* IncludeSequenceName, VARIANT* EntrySeparator, VARIANT* PageRangeSeparator, 
VARIANT* IncludeCategoryHeader, VARIANT* PageNumberSeparator)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Category, Bookmark, Passim, KeepEntryFormatting, Separator, IncludeSequenceName, EntrySeparator, PageRangeSeparator, IncludeCategoryHeader, PageNumberSeparator);
return result;
}


void TablesOfAuthorities::NextCitation(LPCTSTR ShortCitation)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShortCitation);
}


LPDISPATCH TablesOfAuthorities::MarkCitation(LPDISPATCH Range, LPCTSTR ShortCitation, VARIANT* LongCitation, VARIANT* LongCitationAutoText, VARIANT* Category)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, ShortCitation, LongCitation, LongCitationAutoText, Category);
return result;
}


void TablesOfAuthorities::MarkAllCitations(LPCTSTR ShortCitation, VARIANT* LongCitation, VARIANT* LongCitationAutoText, VARIANT* Category)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShortCitation, LongCitation, LongCitationAutoText, Category);
}




/
// TableOfAuthorities properties


/
// TableOfAuthorities operations


LPDISPATCH TableOfAuthorities::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfAuthorities::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TableOfAuthorities::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TableOfAuthorities::GetPassim()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetPassim(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL TableOfAuthorities::GetKeepEntryFormatting()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetKeepEntryFormatting(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long TableOfAuthorities::GetCategory()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetCategory(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString TableOfAuthorities::GetBookmark()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetBookmark(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString TableOfAuthorities::GetSeparator()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetSeparator(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString TableOfAuthorities::GetIncludeSequenceName()
{
CString result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetIncludeSequenceName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString TableOfAuthorities::GetEntrySeparator()
{
CString result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetEntrySeparator(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString TableOfAuthorities::GetPageRangeSeparator()
{
CString result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetPageRangeSeparator(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL TableOfAuthorities::GetIncludeCategoryHeader()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetIncludeCategoryHeader(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString TableOfAuthorities::GetPageNumberSeparator()
{
CString result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetPageNumberSeparator(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH TableOfAuthorities::GetRange()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfAuthorities::GetTabLeader()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableOfAuthorities::SetTabLeader(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void TableOfAuthorities::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void TableOfAuthorities::Update()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Dialogs properties


/
// Dialogs operations


LPDISPATCH Dialogs::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Dialogs::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dialogs::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Dialogs::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Dialogs::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dialogs::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Dialog properties


/
// Dialog operations


LPDISPATCH Dialog::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x7d03, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Dialog::GetCreator()
{
long result;
InvokeHelper(0x7d04, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dialog::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x7d05, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Dialog::GetDefaultTab()
{
long result;
InvokeHelper(0x7d02, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Dialog::SetDefaultTab(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7d02, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Dialog::GetType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Dialog::Show(VARIANT* TimeOut)
{
long result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x150, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
TimeOut);
return result;
}


long Dialog::Display(VARIANT* TimeOut)
{
long result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x152, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
TimeOut);
return result;
}


void Dialog::Execute()
{
InvokeHelper(0x7d01, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Dialog::Update()
{
InvokeHelper(0x12e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


CString Dialog::GetCommandName()
{
CString result;
InvokeHelper(0x7d06, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// PageSetup properties


/
// PageSetup operations


LPDISPATCH PageSetup::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long PageSetup::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH PageSetup::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float PageSetup::GetTopMargin()
{
float result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetTopMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetBottomMargin()
{
float result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetBottomMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetLeftMargin()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetLeftMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetRightMargin()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetRightMargin(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetGutter()
{
float result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetGutter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetPageWidth()
{
float result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetPageWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetPageHeight()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetPageHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long PageSetup::GetOrientation()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetFirstPageTray()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetFirstPageTray(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetOtherPagesTray()
{
long result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetOtherPagesTray(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetVerticalAlignment()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetVerticalAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetMirrorMargins()
{
long result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetMirrorMargins(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float PageSetup::GetHeaderDistance()
{
float result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetHeaderDistance(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetFooterDistance()
{
float result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetFooterDistance(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long PageSetup::GetSectionStart()
{
long result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetSectionStart(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetOddAndEvenPagesHeaderFooter()
{
long result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetOddAndEvenPagesHeaderFooter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetDifferentFirstPageHeaderFooter()
{
long result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetDifferentFirstPageHeaderFooter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetSuppressEndnotes()
{
long result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetSuppressEndnotes(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH PageSetup::GetLineNumbering()
{
LPDISPATCH result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void PageSetup::SetLineNumbering(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH PageSetup::GetTextColumns()
{
LPDISPATCH result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void PageSetup::SetTextColumns(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long PageSetup::GetPaperSize()
{
long result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetPaperSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL PageSetup::GetTwoPagesOnOne()
{
BOOL result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageSetup::SetTwoPagesOnOne(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float PageSetup::GetCharsLine()
{
float result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetCharsLine(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PageSetup::GetLinesPage()
{
float result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PageSetup::SetLinesPage(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL PageSetup::GetShowGrid()
{
BOOL result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageSetup::SetShowGrid(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void PageSetup::TogglePortrait()
{
InvokeHelper(0xc9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void PageSetup::SetAsTemplateDefault()
{
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long PageSetup::GetGutterStyle()
{
long result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetGutterStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetSectionDirection()
{
long result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetSectionDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetLayoutMode()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetLayoutMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageSetup::GetGutterPos()
{
long result;
InvokeHelper(0x4c6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetGutterPos(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4c6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL PageSetup::GetBookFoldPrinting()
{
BOOL result;
InvokeHelper(0x4c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageSetup::SetBookFoldPrinting(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4c7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL PageSetup::GetBookFoldRevPrinting()
{
BOOL result;
InvokeHelper(0x4c8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageSetup::SetBookFoldRevPrinting(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4c8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long PageSetup::GetBookFoldPrintingSheets()
{
long result;
InvokeHelper(0x4c9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageSetup::SetBookFoldPrintingSheets(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4c9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// LineNumbering properties


/
// LineNumbering operations


LPDISPATCH LineNumbering::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LineNumbering::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH LineNumbering::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LineNumbering::GetRestartMode()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineNumbering::SetRestartMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineNumbering::GetStartingNumber()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineNumbering::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float LineNumbering::GetDistanceFromText()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void LineNumbering::SetDistanceFromText(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long LineNumbering::GetCountBy()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineNumbering::SetCountBy(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineNumbering::GetActive()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineNumbering::SetActive(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// TextColumns properties


/
// TextColumns operations


LPUNKNOWN TextColumns::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TextColumns::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextColumns::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextColumns::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextColumns::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextColumns::GetEvenlySpaced()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextColumns::SetEvenlySpaced(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextColumns::GetLineBetween()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextColumns::SetLineBetween(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float TextColumns::GetWidth()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextColumns::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TextColumns::GetSpacing()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextColumns::SetSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH TextColumns::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH TextColumns::Add(VARIANT* Width, VARIANT* Spacing, VARIANT* EvenlySpaced)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xc9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Width, Spacing, EvenlySpaced);
return result;
}


void TextColumns::SetCount(long NumColumns)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xca, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumColumns);
}


long TextColumns::GetFlowDirection()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextColumns::SetFlowDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// TextColumn properties


/
// TextColumn operations


LPDISPATCH TextColumn::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextColumn::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextColumn::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float TextColumn::GetWidth()
{
float result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextColumn::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TextColumn::GetSpaceAfter()
{
float result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextColumn::SetSpaceAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}




/
// Selection properties


/
// Selection operations


CString Selection::GetText()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Selection::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Selection::GetFormattedText()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::SetFormattedText(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Selection::GetStart()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetStart(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Selection::GetEnd()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetEnd(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Selection::GetFont()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Selection::GetType()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Selection::GetStoryType()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT Selection::GetStyle()
{
VARIANT result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Selection::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Selection::GetTables()
{
LPDISPATCH result;
InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetWords()
{
LPDISPATCH result;
InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetSentences()
{
LPDISPATCH result;
InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetCharacters()
{
LPDISPATCH result;
InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFootnotes()
{
LPDISPATCH result;
InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetEndnotes()
{
LPDISPATCH result;
InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetComments()
{
LPDISPATCH result;
InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetCells()
{
LPDISPATCH result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetSections()
{
LPDISPATCH result;
InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Selection::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFields()
{
LPDISPATCH result;
InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFormFields()
{
LPDISPATCH result;
InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFrames()
{
LPDISPATCH result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Selection::GetPageSetup()
{
LPDISPATCH result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::SetPageSetup(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Selection::GetBookmarks()
{
LPDISPATCH result;
InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Selection::GetStoryLength()
{
long result;
InvokeHelper(0x98, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Selection::GetLanguageID()
{
long result;
InvokeHelper(0x99, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x99, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Selection::GetLanguageIDFarEast()
{
long result;
InvokeHelper(0x9a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetLanguageIDFarEast(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Selection::GetLanguageIDOther()
{
long result;
InvokeHelper(0x9b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetLanguageIDOther(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Selection::GetHyperlinks()
{
LPDISPATCH result;
InvokeHelper(0x9c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetColumns()
{
LPDISPATCH result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetRows()
{
LPDISPATCH result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetHeaderFooter()
{
LPDISPATCH result;
InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Selection::GetIsEndOfRowMark()
{
BOOL result;
InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Selection::GetBookmarkID()
{
long result;
InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Selection::GetPreviousBookmarkID()
{
long result;
InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFind()
{
LPDISPATCH result;
InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x190, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT Selection::GetInformation(long Type)
{
VARIANT result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
Type);
return result;
}


long Selection::GetFlags()
{
long result;
InvokeHelper(0x192, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetFlags(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Selection::GetActive()
{
BOOL result;
InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Selection::GetStartIsActive()
{
BOOL result;
InvokeHelper(0x194, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Selection::SetStartIsActive(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x194, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Selection::GetIPAtEndOfLine()
{
BOOL result;
InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Selection::GetExtendMode()
{
BOOL result;
InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Selection::SetExtendMode(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x196, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Selection::GetColumnSelectMode()
{
BOOL result;
InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Selection::SetColumnSelectMode(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x197, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Selection::GetOrientation()
{
long result;
InvokeHelper(0x19a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x19a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Selection::GetInlineShapes()
{
LPDISPATCH result;
InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Selection::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetDocument()
{
LPDISPATCH result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetShapeRange()
{
LPDISPATCH result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SetRange(long Start, long End)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Start, End);
}


void Selection::Collapse(VARIANT* Direction)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Direction);
}


void Selection::InsertBefore(LPCTSTR Text)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Text);
}


void Selection::InsertAfter(LPCTSTR Text)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Text);
}


LPDISPATCH Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::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 Selection::Cut()
{
InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::Copy()
{
InvokeHelper(0x78, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::Paste()
{
InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertBreak(VARIANT* Type)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x7a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type);
}


void Selection::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, NULL, parms,
FileName, Range, ConfirmConversions, Link, Attachment);
}


BOOL Selection::InStory(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x7d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


BOOL Selection::InRange(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x7e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


long Selection::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;
}


long Selection::Expand(VARIANT* Unit)
{
long result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x81, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit);
return result;
}


void Selection::InsertParagraph()
{
InvokeHelper(0xa0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertParagraphAfter()
{
InvokeHelper(0xa1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::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, NULL, parms,
CharacterNumber, Font, Unicode, Bias);
}


void Selection::CopyAsPicture()
{
InvokeHelper(0xa7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SortAscending()
{
InvokeHelper(0xa9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SortDescending()
{
InvokeHelper(0xaa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL Selection::IsEqual(LPDISPATCH Range)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xab, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Range);
return result;
}


float Selection::Calculate()
{
float result;
InvokeHelper(0xac, DISPATCH_METHOD, VT_R4, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::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 Selection::GoToNext(long What)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xae, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
What);
return result;
}


LPDISPATCH Selection::GoToPrevious(long What)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xaf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
What);
return result;
}


void Selection::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, NULL, parms,
IconIndex, Link, Placement, DisplayAsIcon, DataType, IconFileName, IconLabel);
}


LPDISPATCH Selection::PreviousField()
{
LPDISPATCH result;
InvokeHelper(0xb1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::NextField()
{
LPDISPATCH result;
InvokeHelper(0xb2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::InsertParagraphBefore()
{
InvokeHelper(0xd4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertCells(VARIANT* ShiftCells)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xd6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ShiftCells);
}


void Selection::Extend(VARIANT* Character)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x12c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Character);
}


void Selection::Shrink()
{
InvokeHelper(0x12d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Selection::MoveLeft(VARIANT* Unit, VARIANT* Count, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f4, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Count, Extend);
return result;
}


long Selection::MoveRight(VARIANT* Unit, VARIANT* Count, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f5, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Count, Extend);
return result;
}


long Selection::MoveUp(VARIANT* Unit, VARIANT* Count, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Count, Extend);
return result;
}


long Selection::MoveDown(VARIANT* Unit, VARIANT* Count, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Count, Extend);
return result;
}


long Selection::HomeKey(VARIANT* Unit, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Extend);
return result;
}


long Selection::EndKey(VARIANT* Unit, VARIANT* Extend)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x1f9, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
Unit, Extend);
return result;
}


void Selection::EscapeKey()
{
InvokeHelper(0x1fa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::TypeText(LPCTSTR Text)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1fb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Text);
}


void Selection::CopyFormat()
{
InvokeHelper(0x1fd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::PasteFormat()
{
InvokeHelper(0x1fe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::TypeParagraph()
{
InvokeHelper(0x200, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::TypeBackspace()
{
InvokeHelper(0x201, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::NextSubdocument()
{
InvokeHelper(0x202, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::PreviousSubdocument()
{
InvokeHelper(0x203, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectColumn()
{
InvokeHelper(0x204, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentFont()
{
InvokeHelper(0x205, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentAlignment()
{
InvokeHelper(0x206, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentSpacing()
{
InvokeHelper(0x207, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentIndent()
{
InvokeHelper(0x208, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentTabs()
{
InvokeHelper(0x209, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCurrentColor()
{
InvokeHelper(0x20a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::CreateTextbox()
{
InvokeHelper(0x20b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::WholeStory()
{
InvokeHelper(0x20c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectRow()
{
InvokeHelper(0x20d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SplitTable()
{
InvokeHelper(0x20e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertRows(VARIANT* NumRows)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x210, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumRows);
}


void Selection::InsertColumns()
{
InvokeHelper(0x211, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertFormula(VARIANT* Formula, VARIANT* NumberFormat)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x212, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Formula, NumberFormat);
}


LPDISPATCH Selection::NextRevision(VARIANT* Wrap)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x213, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Wrap);
return result;
}


LPDISPATCH Selection::PreviousRevision(VARIANT* Wrap)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x214, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Wrap);
return result;
}


void Selection::PasteAsNestedTable()
{
InvokeHelper(0x215, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Selection::CreateAutoTextEntry(LPCTSTR Name, LPCTSTR StyleName)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x216, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, StyleName);
return result;
}


void Selection::DetectLanguage()
{
InvokeHelper(0x217, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::SelectCell()
{
InvokeHelper(0x218, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertRowsBelow(VARIANT* NumRows)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x219, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumRows);
}


void Selection::InsertColumnsRight()
{
InvokeHelper(0x21a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertRowsAbove(VARIANT* NumRows)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x21b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumRows);
}


void Selection::RtlRun()
{
InvokeHelper(0x258, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::LtrRun()
{
InvokeHelper(0x259, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::BoldRun()
{
InvokeHelper(0x25a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::ItalicRun()
{
InvokeHelper(0x25b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::RtlPara()
{
InvokeHelper(0x25d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::LtrPara()
{
InvokeHelper(0x25e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::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, NULL, parms,
DateTimeFormat, InsertAsField, InsertAsFullWidth, DateLanguage, CalendarType);
}


LPDISPATCH Selection::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(0x1c9, 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;
}


long Selection::GetNoProofing()
{
long result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Selection::SetNoProofing(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3ed, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Selection::GetTopLevelTables()
{
LPDISPATCH result;
InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Selection::GetLanguageDetected()
{
BOOL result;
InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Selection::SetLanguageDetected(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3ef, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Selection::GetFitTextWidth()
{
float result;
InvokeHelper(0x3f0, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Selection::SetFitTextWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3f0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void Selection::ClearFormatting()
{
InvokeHelper(0x3f1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::PasteAppendTable()
{
InvokeHelper(0x3f2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Selection::GetHTMLDivisions()
{
LPDISPATCH result;
InvokeHelper(0x3f3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetSmartTags()
{
LPDISPATCH result;
InvokeHelper(0x3f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetChildShapeRange()
{
LPDISPATCH result;
InvokeHelper(0x3fd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Selection::GetHasChildShapeRange()
{
BOOL result;
InvokeHelper(0x3fe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetFootnoteOptions()
{
LPDISPATCH result;
InvokeHelper(0x400, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetEndnoteOptions()
{
LPDISPATCH result;
InvokeHelper(0x401, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Selection::ToggleCharacterCode()
{
InvokeHelper(0x3f4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::PasteAndFormat(long Type)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3f5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type);
}


void Selection::PasteExcelTable(BOOL LinkedToExcel, BOOL WordFormatting, BOOL RTF)
{
static BYTE parms[] =
VTS_BOOL VTS_BOOL VTS_BOOL;
InvokeHelper(0x3f6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
LinkedToExcel, WordFormatting, RTF);
}


void Selection::ShrinkDiscontiguousSelection()
{
InvokeHelper(0x3fb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::InsertStyleSeparator()
{
InvokeHelper(0x3fc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Selection::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, VARIANT* SubFieldNumber, 
VARIANT* SubFieldNumber2, VARIANT* SubFieldNumber3)
{
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 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x3ff, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ExcludeHeader, FieldNumber, SortFieldType, SortOrder, FieldNumber2, SortFieldType2, SortOrder2, FieldNumber3, SortFieldType3, SortOrder3, SortColumn, Separator, CaseSensitive, BidiSort, IgnoreThe, IgnoreKashida, IgnoreDiacritics, 
IgnoreHe, LanguageID, SubFieldNumber, SubFieldNumber2, SubFieldNumber3);
}


LPDISPATCH Selection::GetXMLNodes()
{
LPDISPATCH result;
InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetXMLParentNode()
{
LPDISPATCH result;
InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GetEditors()
{
LPDISPATCH result;
InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Selection::GetXml(BOOL DataOnly)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
DataOnly);
return result;
}


VARIANT Selection::GetEnhMetaFileBits()
{
VARIANT result;
InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


LPDISPATCH Selection::GoToEditableRange(VARIANT* EditorID)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x403, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
EditorID);
return result;
}


void Selection::InsertXML(LPCTSTR XML, VARIANT* Transform)
{
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x404, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
XML, Transform);
}


void Selection::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, NULL, parms,
Label, Title, TitleAutoText, Position, ExcludeLabel);
}


void Selection::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, NULL, parms,
ReferenceType, ReferenceKind, ReferenceItem, InsertAsHyperlink, IncludePosition, SeparateNumbers, SeparatorString);
}




/
// TablesOfAuthoritiesCategories properties


/
// TablesOfAuthoritiesCategories operations


LPDISPATCH TablesOfAuthoritiesCategories::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TablesOfAuthoritiesCategories::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TablesOfAuthoritiesCategories::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN TablesOfAuthoritiesCategories::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TablesOfAuthoritiesCategories::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TablesOfAuthoritiesCategories::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// TableOfAuthoritiesCategory properties


/
// TableOfAuthoritiesCategory operations


LPDISPATCH TableOfAuthoritiesCategory::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableOfAuthoritiesCategory::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TableOfAuthoritiesCategory::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString TableOfAuthoritiesCategory::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TableOfAuthoritiesCategory::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long TableOfAuthoritiesCategory::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// CaptionLabels properties


/
// CaptionLabels operations


LPDISPATCH CaptionLabels::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CaptionLabels::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CaptionLabels::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN CaptionLabels::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long CaptionLabels::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CaptionLabels::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH CaptionLabels::Add(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// CaptionLabel properties


/
// CaptionLabel operations


LPDISPATCH CaptionLabel::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CaptionLabel::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CaptionLabel::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString CaptionLabel::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL CaptionLabel::GetBuiltIn()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long CaptionLabel::GetId()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL CaptionLabel::GetIncludeChapterNumber()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void CaptionLabel::SetIncludeChapterNumber(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long CaptionLabel::GetNumberStyle()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CaptionLabel::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CaptionLabel::GetChapterStyleLevel()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CaptionLabel::SetChapterStyleLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CaptionLabel::GetSeparator()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CaptionLabel::SetSeparator(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CaptionLabel::GetPosition()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CaptionLabel::SetPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void CaptionLabel::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// AutoCaptions properties


/
// AutoCaptions operations


LPDISPATCH AutoCaptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCaptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCaptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN AutoCaptions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long AutoCaptions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCaptions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void AutoCaptions::CancelAutoInsert()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// AutoCaption properties


/
// AutoCaption operations


LPDISPATCH AutoCaption::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AutoCaption::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AutoCaption::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString AutoCaption::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL AutoCaption::GetAutoInsert()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AutoCaption::SetAutoInsert(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long AutoCaption::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT AutoCaption::GetCaptionLabel()
{
VARIANT result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void AutoCaption::SetCaptionLabel(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}




/
// Indexes properties


/
// Indexes operations


LPDISPATCH Indexes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Indexes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Indexes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Indexes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Indexes::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Indexes::GetFormat()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Indexes::SetFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Indexes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Indexes::MarkEntry(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* CrossReference, VARIANT* CrossReferenceAutoText, VARIANT* BookmarkName, VARIANT* Bold, VARIANT* Italic, VARIANT* Reading)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, Entry, EntryAutoText, CrossReference, CrossReferenceAutoText, BookmarkName, Bold, Italic, Reading);
return result;
}


void Indexes::MarkAllEntries(LPDISPATCH Range, VARIANT* Entry, VARIANT* EntryAutoText, VARIANT* CrossReference, VARIANT* CrossReferenceAutoText, VARIANT* BookmarkName, VARIANT* Bold, VARIANT* Italic)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Range, Entry, EntryAutoText, CrossReference, CrossReferenceAutoText, BookmarkName, Bold, Italic);
}


void Indexes::AutoMarkEntries(LPCTSTR ConcordanceFileName)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ConcordanceFileName);
}


LPDISPATCH Indexes::Add(LPDISPATCH Range, VARIANT* HeadingSeparator, VARIANT* RightAlignPageNumbers, VARIANT* Type, VARIANT* NumberOfColumns, VARIANT* AccentedLetters, VARIANT* SortBy, VARIANT* IndexLanguage)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range, HeadingSeparator, RightAlignPageNumbers, Type, NumberOfColumns, AccentedLetters, SortBy, IndexLanguage);
return result;
}




/
// Index properties


/
// Index operations


LPDISPATCH Index::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Index::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Index::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Index::GetHeadingSeparator()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetHeadingSeparator(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Index::GetRightAlignPageNumbers()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Index::SetRightAlignPageNumbers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Index::GetType()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Index::GetNumberOfColumns()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetNumberOfColumns(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Index::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Index::GetTabLeader()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetTabLeader(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Index::GetAccentedLetters()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Index::SetAccentedLetters(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Index::GetSortBy()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetSortBy(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Index::GetFilter()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetFilter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Index::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Index::Update()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long Index::GetIndexLanguage()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Index::SetIndexLanguage(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// AddIn properties


/
// AddIn operations


LPDISPATCH AddIn::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AddIn::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AddIn::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString AddIn::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long AddIn::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString AddIn::GetPath()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL AddIn::GetInstalled()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AddIn::SetInstalled(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL AddIn::GetCompiled()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL AddIn::GetAutoload()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void AddIn::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// AddIns properties


/
// AddIns operations


LPDISPATCH AddIns::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long AddIns::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AddIns::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN AddIns::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long AddIns::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH AddIns::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH AddIns::Add(LPCTSTR FileName, VARIANT* Install)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, Install);
return result;
}


void AddIns::Unload(BOOL RemoveFromList)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
RemoveFromList);
}




/
// Revisions properties


/
// Revisions operations


LPDISPATCH Revisions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Revisions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Revisions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Revisions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Revisions::GetCount()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Revisions::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Revisions::AcceptAll()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Revisions::RejectAll()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Revision properties


/
// Revision operations


LPDISPATCH Revision::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Revision::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Revision::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Revision::GetAuthor()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


DATE Revision::GetDate()
{
DATE result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
return result;
}


LPDISPATCH Revision::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Revision::GetType()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Revision::GetIndex()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Revision::Accept()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Revision::Reject()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Revision::GetStyle()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Revision::GetFormatDescription()
{
CString result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// Task properties


/
// Task operations


LPDISPATCH Task::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Task::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Task::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Task::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long Task::GetLeft()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Task::SetLeft(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Task::GetTop()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Task::SetTop(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Task::GetWidth()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Task::SetWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Task::GetHeight()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Task::SetHeight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Task::GetWindowState()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Task::SetWindowState(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Task::GetVisible()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Task::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Task::Activate(VARIANT* Wait)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Wait);
}


void Task::Close()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Task::Move(long Left, long Top)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Left, Top);
}


void Task::Resize(long Width, long Height)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Width, Height);
}


void Task::SendWindowMessage(long Message, long wParam, long lParam)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_I4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Message, wParam, lParam);
}




/
// Tasks properties


/
// Tasks operations


LPDISPATCH Tasks::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Tasks::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Tasks::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Tasks::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Tasks::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Tasks::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


BOOL Tasks::Exists(LPCTSTR Name)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
Name);
return result;
}


void Tasks::ExitWindows_()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// HeadersFooters properties


/
// HeadersFooters operations


LPDISPATCH HeadersFooters::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HeadersFooters::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeadersFooters::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN HeadersFooters::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long HeadersFooters::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeadersFooters::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// HeaderFooter properties


/
// HeaderFooter operations


LPDISPATCH HeaderFooter::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HeaderFooter::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeaderFooter::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH HeaderFooter::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HeaderFooter::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL HeaderFooter::GetIsHeader()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL HeaderFooter::GetExists()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void HeaderFooter::SetExists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH HeaderFooter::GetPageNumbers()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL HeaderFooter::GetLinkToPrevious()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void HeaderFooter::SetLinkToPrevious(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH HeaderFooter::GetShapes()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// PageNumbers properties


/
// PageNumbers operations


LPDISPATCH PageNumbers::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long PageNumbers::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH PageNumbers::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN PageNumbers::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long PageNumbers::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long PageNumbers::GetNumberStyle()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageNumbers::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL PageNumbers::GetIncludeChapterNumber()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageNumbers::SetIncludeChapterNumber(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long PageNumbers::GetHeadingLevelForChapter()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageNumbers::SetHeadingLevelForChapter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PageNumbers::GetChapterPageSeparator()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageNumbers::SetChapterPageSeparator(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL PageNumbers::GetRestartNumberingAtSection()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageNumbers::SetRestartNumberingAtSection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long PageNumbers::GetStartingNumber()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageNumbers::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL PageNumbers::GetShowFirstPageNumber()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageNumbers::SetShowFirstPageNumber(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH PageNumbers::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH PageNumbers::Add(VARIANT* PageNumberAlignment, VARIANT* FirstPage)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
PageNumberAlignment, FirstPage);
return result;
}


BOOL PageNumbers::GetDoubleQuote()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void PageNumbers::SetDoubleQuote(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// PageNumber properties


/
// PageNumber operations


LPDISPATCH PageNumber::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long PageNumber::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH PageNumber::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long PageNumber::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long PageNumber::GetAlignment()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PageNumber::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void PageNumber::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void PageNumber::Copy()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void PageNumber::Cut()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void PageNumber::Delete()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Subdocuments properties


/
// Subdocuments operations


LPDISPATCH Subdocuments::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Subdocuments::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Subdocuments::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Subdocuments::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN Subdocuments::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


BOOL Subdocuments::GetExpanded()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Subdocuments::SetExpanded(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Subdocuments::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Subdocuments::AddFromFile(VARIANT* Name, VARIANT* ConfirmConversions, VARIANT* ReadOnly, VARIANT* PasswordDocument, VARIANT* PasswordTemplate, VARIANT* Revert, VARIANT* WritePasswordDocument, VARIANT* WritePasswordTemplate)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, ConfirmConversions, ReadOnly, PasswordDocument, PasswordTemplate, Revert, WritePasswordDocument, WritePasswordTemplate);
return result;
}


LPDISPATCH Subdocuments::AddFromRange(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


void Subdocuments::Merge(VARIANT* FirstSubdocument, VARIANT* LastSubdocument)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FirstSubdocument, LastSubdocument);
}


void Subdocuments::Delete()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Subdocuments::Select()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Subdocument properties


/
// Subdocument operations


LPDISPATCH Subdocument::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Subdocument::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Subdocument::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Subdocument::GetLocked()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Subdocument::SetLocked(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Subdocument::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Subdocument::GetName()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Subdocument::GetPath()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL Subdocument::GetHasFile()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Subdocument::GetLevel()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Subdocument::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Subdocument::Split(LPDISPATCH Range)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Range);
}


LPDISPATCH Subdocument::Open()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// HeadingStyles properties


/
// HeadingStyles operations


LPDISPATCH HeadingStyles::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HeadingStyles::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeadingStyles::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN HeadingStyles::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long HeadingStyles::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeadingStyles::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH HeadingStyles::Add(VARIANT* Style, short Level)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_I2;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Style, Level);
return result;
}




/
// HeadingStyle properties


/
// HeadingStyle operations


LPDISPATCH HeadingStyle::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HeadingStyle::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HeadingStyle::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT HeadingStyle::GetStyle()
{
VARIANT result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void HeadingStyle::SetStyle(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


short HeadingStyle::GetLevel()
{
short result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
return result;
}


void HeadingStyle::SetLevel(short nNewValue)
{
static BYTE parms[] =
VTS_I2;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void HeadingStyle::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// StoryRanges properties


/
// StoryRanges operations


LPUNKNOWN StoryRanges::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long StoryRanges::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH StoryRanges::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long StoryRanges::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH StoryRanges::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH StoryRanges::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// ListLevel properties


/
// ListLevel operations


long ListLevel::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString ListLevel::GetNumberFormat()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ListLevel::SetNumberFormat(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long ListLevel::GetTrailingCharacter()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListLevel::SetTrailingCharacter(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ListLevel::GetNumberStyle()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListLevel::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float ListLevel::GetNumberPosition()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ListLevel::SetNumberPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ListLevel::GetAlignment()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListLevel::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float ListLevel::GetTextPosition()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ListLevel::SetTextPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ListLevel::GetTabPosition()
{
float result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ListLevel::SetTabPosition(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ListLevel::GetStartAt()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListLevel::SetStartAt(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString ListLevel::GetLinkedStyle()
{
CString result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ListLevel::SetLinkedStyle(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH ListLevel::GetFont()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ListLevel::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ListLevel::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListLevel::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListLevel::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListLevel::GetResetOnHigher()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ListLevel::SetResetOnHigher(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH ListLevel::GetPictureBullet()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListLevel::ApplyPictureBullet(LPCTSTR FileName)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName);
return result;
}




/
// ListLevels properties


/
// ListLevels operations


LPUNKNOWN ListLevels::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ListLevels::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListLevels::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListLevels::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListLevels::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListLevels::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// ListTemplate properties


/
// ListTemplate operations


LPDISPATCH ListTemplate::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListTemplate::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListTemplate::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL ListTemplate::GetOutlineNumbered()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void ListTemplate::SetOutlineNumbered(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString ListTemplate::GetName()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ListTemplate::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH ListTemplate::GetListLevels()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListTemplate::Convert(VARIANT* Level)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Level);
return result;
}




/
// ListTemplates properties


/
// ListTemplates operations


LPUNKNOWN ListTemplates::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ListTemplates::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListTemplates::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListTemplates::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListTemplates::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListTemplates::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH ListTemplates::Add(VARIANT* OutlineNumbered, VARIANT* Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
OutlineNumbered, Name);
return result;
}




/
// ListParagraphs properties


/
// ListParagraphs operations


LPUNKNOWN ListParagraphs::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ListParagraphs::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListParagraphs::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListParagraphs::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListParagraphs::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListParagraphs::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// List properties


/
// List operations


LPDISPATCH List::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH List::GetListParagraphs()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL List::GetSingleListTemplate()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH List::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long List::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH List::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void List::ConvertNumbersToText(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


void List::RemoveNumbers(VARIANT* NumberType)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NumberType);
}


long List::CountNumberedItems(VARIANT* NumberType, VARIANT* Level)
{
long result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
NumberType, Level);
return result;
}


long List::CanContinuePreviousList(LPDISPATCH ListTemplate)
{
long result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x69, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
ListTemplate);
return result;
}


void List::ApplyListTemplate(LPDISPATCH ListTemplate, VARIANT* ContinuePreviousList, VARIANT* DefaultListBehavior)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ListTemplate, ContinuePreviousList, DefaultListBehavior);
}


CString List::GetStyleName()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// Lists properties


/
// Lists operations


LPUNKNOWN Lists::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Lists::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Lists::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Lists::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Lists::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Lists::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// ListGallery properties


/
// ListGallery operations


LPDISPATCH ListGallery::GetListTemplates()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListGallery::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListGallery::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListGallery::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL ListGallery::GetModified(long Index)
{
BOOL result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
Index);
return result;
}


void ListGallery::Reset(long Index)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index);
}




/
// ListGalleries properties


/
// ListGalleries operations


LPUNKNOWN ListGalleries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ListGalleries::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListGalleries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ListGalleries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ListGalleries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ListGalleries::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// KeyBindings properties


/
// KeyBindings operations


LPDISPATCH KeyBindings::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long KeyBindings::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH KeyBindings::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN KeyBindings::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long KeyBindings::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH KeyBindings::GetContext()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH KeyBindings::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH KeyBindings::Add(long KeyCategory, LPCTSTR Command, long KeyCode, VARIANT* KeyCode2, VARIANT* CommandParameter)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_I4 VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
KeyCategory, Command, KeyCode, KeyCode2, CommandParameter);
return result;
}


void KeyBindings::ClearAll()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH KeyBindings::Key(long KeyCode, VARIANT* KeyCode2)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_PVARIANT;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
KeyCode, KeyCode2);
return result;
}




/
// KeysBoundTo properties


/
// KeysBoundTo operations


LPDISPATCH KeysBoundTo::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long KeysBoundTo::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH KeysBoundTo::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN KeysBoundTo::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long KeysBoundTo::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long KeysBoundTo::GetKeyCategory()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString KeysBoundTo::GetCommand()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString KeysBoundTo::GetCommandParameter()
{
CString result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH KeysBoundTo::GetContext()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH KeysBoundTo::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH KeysBoundTo::Key(long KeyCode, VARIANT* KeyCode2)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_PVARIANT;
InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
KeyCode, KeyCode2);
return result;
}




/
// KeyBinding properties


/
// KeyBinding operations


LPDISPATCH KeyBinding::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long KeyBinding::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH KeyBinding::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString KeyBinding::GetCommand()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString KeyBinding::GetKeyString()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL KeyBinding::GetProtected()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long KeyBinding::GetKeyCategory()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long KeyBinding::GetKeyCode()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long KeyBinding::GetKeyCode2()
{
long result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString KeyBinding::GetCommandParameter()
{
CString result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH KeyBinding::GetContext()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void KeyBinding::Clear()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void KeyBinding::Disable()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void KeyBinding::Execute()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void KeyBinding::Rebind(long KeyCategory, LPCTSTR Command, VARIANT* CommandParameter)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
KeyCategory, Command, CommandParameter);
}




/
// FileConverter properties


/
// FileConverter operations


LPDISPATCH FileConverter::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FileConverter::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FileConverter::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString FileConverter::GetFormatName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString FileConverter::GetClassName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long FileConverter::GetSaveFormat()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FileConverter::GetOpenFormat()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL FileConverter::GetCanSave()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL FileConverter::GetCanOpen()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString FileConverter::GetPath()
{
CString result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString FileConverter::GetName()
{
CString result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString FileConverter::GetExtensions()
{
CString result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// FileConverters properties


/
// FileConverters operations


LPDISPATCH FileConverters::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FileConverters::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FileConverters::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FileConverters::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN FileConverters::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long FileConverters::GetConvertMacWordChevrons()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FileConverters::SetConvertMacWordChevrons(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH FileConverters::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// SynonymInfo properties


/
// SynonymInfo operations


LPDISPATCH SynonymInfo::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SynonymInfo::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SynonymInfo::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString SynonymInfo::GetWord()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


BOOL SynonymInfo::GetFound()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long SynonymInfo::GetMeaningCount()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT SynonymInfo::GetMeaningList()
{
VARIANT result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


VARIANT SynonymInfo::GetPartOfSpeechList()
{
VARIANT result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


VARIANT SynonymInfo::GetSynonymList(VARIANT* Meaning)
{
VARIANT result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
Meaning);
return result;
}


VARIANT SynonymInfo::GetAntonymList()
{
VARIANT result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


VARIANT SynonymInfo::GetRelatedExpressionList()
{
VARIANT result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


VARIANT SynonymInfo::GetRelatedWordList()
{
VARIANT result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}




/
// Hyperlinks properties


/
// Hyperlinks operations


LPDISPATCH Hyperlinks::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Hyperlinks::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Hyperlinks::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Hyperlinks::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN Hyperlinks::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Hyperlinks::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Hyperlinks::Add(LPDISPATCH Anchor, VARIANT* Address, VARIANT* SubAddress, VARIANT* ScreenTip, VARIANT* TextToDisplay, VARIANT* Target)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Anchor, Address, SubAddress, ScreenTip, TextToDisplay, Target);
return result;
}




/
// Hyperlink properties


/
// Hyperlink operations


LPDISPATCH Hyperlink::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Hyperlink::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Hyperlink::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Hyperlink::GetName()
{
CString result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long Hyperlink::GetType()
{
long result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Hyperlink::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Hyperlink::GetShape()
{
LPDISPATCH result;
InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Hyperlink::GetExtraInfoRequired()
{
BOOL result;
InvokeHelper(0x3f1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Hyperlink::Delete()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Hyperlink::Follow(VARIANT* NewWindow, VARIANT* AddHistory, VARIANT* ExtraInfo, VARIANT* Method, VARIANT* HeaderInfo)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NewWindow, AddHistory, ExtraInfo, Method, HeaderInfo);
}


void Hyperlink::AddToFavorites()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Hyperlink::CreateNewDocument(LPCTSTR FileName, BOOL EditNow, BOOL Overwrite)
{
static BYTE parms[] =
VTS_BSTR VTS_BOOL VTS_BOOL;
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FileName, EditNow, Overwrite);
}


CString Hyperlink::GetAddress()
{
CString result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetAddress(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Hyperlink::GetSubAddress()
{
CString result;
InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetSubAddress(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Hyperlink::GetEmailSubject()
{
CString result;
InvokeHelper(0x3f2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetEmailSubject(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Hyperlink::GetScreenTip()
{
CString result;
InvokeHelper(0x3f3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetScreenTip(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Hyperlink::GetTextToDisplay()
{
CString result;
InvokeHelper(0x3f4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetTextToDisplay(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString Hyperlink::GetTarget()
{
CString result;
InvokeHelper(0x3f5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Hyperlink::SetTarget(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}




/
// Shapes properties


/
// Shapes operations


LPDISPATCH Shapes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shapes::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shapes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shapes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN Shapes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Shapes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Shapes::AddCallout(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddCurve(VARIANT* SafeArrayOfPoints, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
SafeArrayOfPoints, Anchor);
return result;
}


LPDISPATCH Shapes::AddLabel(long Orientation, float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Orientation, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddLine(float BeginX, float BeginY, float EndX, float EndY, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeginX, BeginY, EndX, EndY, Anchor);
return result;
}


LPDISPATCH Shapes::AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, LinkToFile, SaveWithDocument, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddPolyline(VARIANT* SafeArrayOfPoints, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
SafeArrayOfPoints, Anchor);
return result;
}


LPDISPATCH Shapes::AddShape(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_BSTR VTS_R4 VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
PresetTextEffect, Text, FontName, FontSize, FontBold, FontItalic, Left, Top, Anchor);
return result;
}


LPDISPATCH Shapes::AddTextbox(long Orientation, float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Orientation, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::BuildFreeform(long EditingType, float X1, float Y1)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4;
InvokeHelper(0x14, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
EditingType, X1, Y1);
return result;
}


LPDISPATCH Shapes::Range(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Shapes::SelectAll()
{
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Shapes::AddOLEObject(VARIANT* ClassType, VARIANT* FileName, VARIANT* LinkToFile, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, 
VARIANT* Anchor)
{
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(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
ClassType, FileName, LinkToFile, DisplayAsIcon, IconFileName, IconIndex, IconLabel, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddOLEControl(VARIANT* ClassType, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
ClassType, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddDiagram(long Type, float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0x17, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, Left, Top, Width, Height, Anchor);
return result;
}


LPDISPATCH Shapes::AddCanvas(float Left, float Top, float Width, float Height, VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_PVARIANT;
InvokeHelper(0x19, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Left, Top, Width, Height, Anchor);
return result;
}




/
// ShapeRange properties


/
// ShapeRange operations


LPDISPATCH ShapeRange::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN ShapeRange::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetAdjustments()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetAutoShapeType()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetAutoShapeType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH ShapeRange::GetCallout()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetFill()
{
LPDISPATCH result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetGroupItems()
{
LPDISPATCH result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float ShapeRange::GetHeight()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ShapeRange::GetHorizontalFlip()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float ShapeRange::GetLeft()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ShapeRange::GetLine()
{
LPDISPATCH result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetLockAspectRatio()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetLockAspectRatio(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString ShapeRange::GetName()
{
CString result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ShapeRange::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH ShapeRange::GetNodes()
{
LPDISPATCH result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float ShapeRange::GetRotation()
{
float result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetRotation(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ShapeRange::GetPictureFormat()
{
LPDISPATCH result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetShadow()
{
LPDISPATCH result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetTextEffect()
{
LPDISPATCH result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetTextFrame()
{
LPDISPATCH result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetThreeD()
{
LPDISPATCH result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float ShapeRange::GetTop()
{
float result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ShapeRange::GetType()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long ShapeRange::GetVerticalFlip()
{
long result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT ShapeRange::GetVertices()
{
VARIANT result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


long ShapeRange::GetVisible()
{
long result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float ShapeRange::GetWidth()
{
float result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ShapeRange::GetZOrderPosition()
{
long result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetHyperlink()
{
LPDISPATCH result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetRelativeHorizontalPosition()
{
long result;
InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetRelativeHorizontalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ShapeRange::GetRelativeVerticalPosition()
{
long result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetRelativeVerticalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ShapeRange::GetLockAnchor()
{
long result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetLockAnchor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH ShapeRange::GetWrapFormat()
{
LPDISPATCH result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetAnchor()
{
LPDISPATCH result;
InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void ShapeRange::Align(long Align, long RelativeTo)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Align, RelativeTo);
}


void ShapeRange::Apply()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ShapeRange::Delete()
{
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ShapeRange::Distribute(long Distribute, long RelativeTo)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Distribute, RelativeTo);
}


LPDISPATCH ShapeRange::Duplicate()
{
LPDISPATCH result;
InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ShapeRange::Flip(long FlipCmd)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FlipCmd);
}


void ShapeRange::IncrementLeft(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShapeRange::IncrementRotation(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShapeRange::IncrementTop(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


LPDISPATCH ShapeRange::Group()
{
LPDISPATCH result;
InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ShapeRange::PickUp()
{
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH ShapeRange::Regroup()
{
LPDISPATCH result;
InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ShapeRange::ScaleHeight(float Factor, long RelativeToOriginalSize, long Scale)
{
static BYTE parms[] =
VTS_R4 VTS_I4 VTS_I4;
InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Factor, RelativeToOriginalSize, Scale);
}


void ShapeRange::ScaleWidth(float Factor, long RelativeToOriginalSize, long Scale)
{
static BYTE parms[] =
VTS_R4 VTS_I4 VTS_I4;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Factor, RelativeToOriginalSize, Scale);
}


void ShapeRange::Select(VARIANT* Replace)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Replace);
}


void ShapeRange::SetShapesDefaultProperties()
{
InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH ShapeRange::Ungroup()
{
LPDISPATCH result;
InvokeHelper(0x1b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ShapeRange::ZOrder(long ZOrderCmd)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ZOrderCmd);
}


LPDISPATCH ShapeRange::ConvertToFrame()
{
LPDISPATCH result;
InvokeHelper(0x1d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::ConvertToInlineShape()
{
LPDISPATCH result;
InvokeHelper(0x1e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ShapeRange::Activate()
{
InvokeHelper(0x32, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


CString ShapeRange::GetAlternativeText()
{
CString result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ShapeRange::SetAlternativeText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long ShapeRange::GetHasDiagram()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetDiagram()
{
LPDISPATCH result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetHasDiagramNode()
{
long result;
InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetDiagramNode()
{
LPDISPATCH result;
InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetChild()
{
long result;
InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetParentGroup()
{
LPDISPATCH result;
InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeRange::GetCanvasItems()
{
LPDISPATCH result;
InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeRange::GetId()
{
long result;
InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::CanvasCropLeft(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShapeRange::CanvasCropTop(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShapeRange::CanvasCropRight(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShapeRange::CanvasCropBottom(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


long ShapeRange::GetLayoutInCell()
{
long result;
InvokeHelper(0x91, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShapeRange::SetLayoutInCell(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x91, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// GroupShapes properties


/
// GroupShapes operations


LPDISPATCH GroupShapes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long GroupShapes::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH GroupShapes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long GroupShapes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN GroupShapes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH GroupShapes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH GroupShapes::Range(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Shape properties


/
// Shape operations


LPDISPATCH Shape::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetAdjustments()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetAutoShapeType()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetAutoShapeType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Shape::GetCallout()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetFill()
{
LPDISPATCH result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetGroupItems()
{
LPDISPATCH result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Shape::GetHeight()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Shape::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Shape::GetHorizontalFlip()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Shape::GetLeft()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Shape::SetLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Shape::GetLine()
{
LPDISPATCH result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetLockAspectRatio()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetLockAspectRatio(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Shape::GetName()
{
CString result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Shape::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Shape::GetNodes()
{
LPDISPATCH result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Shape::GetRotation()
{
float result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Shape::SetRotation(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Shape::GetPictureFormat()
{
LPDISPATCH result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetShadow()
{
LPDISPATCH result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetTextEffect()
{
LPDISPATCH result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetTextFrame()
{
LPDISPATCH result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetThreeD()
{
LPDISPATCH result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float Shape::GetTop()
{
float result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Shape::SetTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Shape::GetType()
{
long result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Shape::GetVerticalFlip()
{
long result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT Shape::GetVertices()
{
VARIANT result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


long Shape::GetVisible()
{
long result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float Shape::GetWidth()
{
float result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Shape::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Shape::GetZOrderPosition()
{
long result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetHyperlink()
{
LPDISPATCH result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetRelativeHorizontalPosition()
{
long result;
InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetRelativeHorizontalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shape::GetRelativeVerticalPosition()
{
long result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetRelativeVerticalPosition(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Shape::GetLockAnchor()
{
long result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetLockAnchor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Shape::GetWrapFormat()
{
LPDISPATCH result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetOLEFormat()
{
LPDISPATCH result;
InvokeHelper(0x1f4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetAnchor()
{
LPDISPATCH result;
InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetLinkFormat()
{
LPDISPATCH result;
InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Shape::Apply()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Shape::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Shape::Duplicate()
{
LPDISPATCH result;
InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Shape::Flip(long FlipCmd)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
FlipCmd);
}


void Shape::IncrementLeft(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::IncrementRotation(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::IncrementTop(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::PickUp()
{
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Shape::ScaleHeight(float Factor, long RelativeToOriginalSize, long Scale)
{
static BYTE parms[] =
VTS_R4 VTS_I4 VTS_I4;
InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Factor, RelativeToOriginalSize, Scale);
}


void Shape::ScaleWidth(float Factor, long RelativeToOriginalSize, long Scale)
{
static BYTE parms[] =
VTS_R4 VTS_I4 VTS_I4;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Factor, RelativeToOriginalSize, Scale);
}


void Shape::Select(VARIANT* Replace)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Replace);
}


void Shape::SetShapesDefaultProperties()
{
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Shape::Ungroup()
{
LPDISPATCH result;
InvokeHelper(0x17, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Shape::ZOrder(long ZOrderCmd)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ZOrderCmd);
}


LPDISPATCH Shape::ConvertToInlineShape()
{
LPDISPATCH result;
InvokeHelper(0x19, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::ConvertToFrame()
{
LPDISPATCH result;
InvokeHelper(0x1d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Shape::Activate()
{
InvokeHelper(0x32, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


CString Shape::GetAlternativeText()
{
CString result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Shape::SetAlternativeText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH Shape::GetScript()
{
LPDISPATCH result;
InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetHasDiagram()
{
long result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetDiagram()
{
LPDISPATCH result;
InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetHasDiagramNode()
{
long result;
InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetDiagramNode()
{
LPDISPATCH result;
InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetChild()
{
long result;
InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetParentGroup()
{
LPDISPATCH result;
InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Shape::GetCanvasItems()
{
LPDISPATCH result;
InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Shape::GetId()
{
long result;
InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::CanvasCropLeft(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::CanvasCropTop(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::CanvasCropRight(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void Shape::CanvasCropBottom(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


long Shape::GetLayoutInCell()
{
long result;
InvokeHelper(0x91, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Shape::SetLayoutInCell(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x91, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// TextFrame properties


/
// TextFrame operations


LPDISPATCH TextFrame::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextFrame::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextFrame::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float TextFrame::GetMarginBottom()
{
float result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextFrame::SetMarginBottom(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TextFrame::GetMarginLeft()
{
float result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextFrame::SetMarginLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TextFrame::GetMarginRight()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextFrame::SetMarginRight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TextFrame::GetMarginTop()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextFrame::SetMarginTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long TextFrame::GetOrientation()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextFrame::SetOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH TextFrame::GetTextRange()
{
LPDISPATCH result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH TextFrame::GetContainingRange()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH TextFrame::GetNext()
{
LPDISPATCH result;
InvokeHelper(0x1389, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void TextFrame::SetNext(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x1389, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH TextFrame::GetPrevious()
{
LPDISPATCH result;
InvokeHelper(0x138a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void TextFrame::SetPrevious(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x138a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL TextFrame::GetOverflowing()
{
BOOL result;
InvokeHelper(0x138b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long TextFrame::GetHasText()
{
long result;
InvokeHelper(0x1390, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextFrame::BreakForwardLink()
{
InvokeHelper(0x138c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL TextFrame::ValidLinkTarget(LPDISPATCH TargetTextFrame)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x138e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
TargetTextFrame);
return result;
}


long TextFrame::GetAutoSize()
{
long result;
InvokeHelper(0x1391, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextFrame::SetAutoSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1391, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextFrame::GetWordWrap()
{
long result;
InvokeHelper(0x1392, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextFrame::SetWordWrap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1392, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// _LetterContent properties


/
// _LetterContent operations


LPDISPATCH _LetterContent::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long _LetterContent::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH _LetterContent::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH _LetterContent::GetDuplicate()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString _LetterContent::GetDateFormat()
{
CString result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetDateFormat(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _LetterContent::GetIncludeHeaderFooter()
{
BOOL result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _LetterContent::SetIncludeHeaderFooter(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _LetterContent::GetPageDesign()
{
CString result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetPageDesign(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _LetterContent::GetLetterStyle()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetLetterStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL _LetterContent::GetLetterhead()
{
BOOL result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _LetterContent::SetLetterhead(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long _LetterContent::GetLetterheadLocation()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetLetterheadLocation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float _LetterContent::GetLetterheadSize()
{
float result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetLetterheadSize(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString _LetterContent::GetRecipientName()
{
CString result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetRecipientName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetRecipientAddress()
{
CString result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetRecipientAddress(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSalutation()
{
CString result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSalutation(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _LetterContent::GetSalutationType()
{
long result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSalutationType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString _LetterContent::GetRecipientReference()
{
CString result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetRecipientReference(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetMailingInstructions()
{
CString result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetMailingInstructions(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetAttentionLine()
{
CString result;
InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetAttentionLine(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSubject()
{
CString result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSubject(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _LetterContent::GetEnclosureNumber()
{
long result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetEnclosureNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString _LetterContent::GetCCList()
{
CString result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetCCList(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetReturnAddress()
{
CString result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetReturnAddress(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderName()
{
CString result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetClosing()
{
CString result;
InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetClosing(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderCompany()
{
CString result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderCompany(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderJobTitle()
{
CString result;
InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderJobTitle(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderInitials()
{
CString result;
InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderInitials(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL _LetterContent::GetInfoBlock()
{
BOOL result;
InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void _LetterContent::SetInfoBlock(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString _LetterContent::GetRecipientCode()
{
CString result;
InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetRecipientCode(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _LetterContent::GetRecipientGender()
{
long result;
InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetRecipientGender(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString _LetterContent::GetReturnAddressShortForm()
{
CString result;
InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetReturnAddressShortForm(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderCity()
{
CString result;
InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderCity(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString _LetterContent::GetSenderCode()
{
CString result;
InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderCode(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long _LetterContent::GetSenderGender()
{
long result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderGender(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString _LetterContent::GetSenderReference()
{
CString result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void _LetterContent::SetSenderReference(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}




/
// View properties


/
// View operations


LPDISPATCH View::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long View::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH View::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long View::GetType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL View::GetFullScreen()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetFullScreen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetDraft()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetDraft(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowAll()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowAll(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowFieldCodes()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowFieldCodes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetMailMergeDataView()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetMailMergeDataView(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetMagnifier()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetMagnifier(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowFirstLineOnly()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowFirstLineOnly(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowFormat()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowFormat(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH View::GetZoom()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL View::GetShowObjectAnchors()
{
BOOL result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowObjectAnchors(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowTextBoundaries()
{
BOOL result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowTextBoundaries(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowHighlight()
{
BOOL result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowHighlight(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowDrawings()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowDrawings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowTabs()
{
BOOL result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowTabs(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowSpaces()
{
BOOL result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowSpaces(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowParagraphs()
{
BOOL result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowParagraphs(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowHyphens()
{
BOOL result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowHyphens(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowHiddenText()
{
BOOL result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowHiddenText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetWrapToWindow()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetWrapToWindow(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowPicturePlaceHolders()
{
BOOL result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowPicturePlaceHolders(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowBookmarks()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowBookmarks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long View::GetFieldShading()
{
long result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetFieldShading(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL View::GetShowAnimation()
{
BOOL result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowAnimation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetTableGridlines()
{
BOOL result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetTableGridlines(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowMainTextLayer()
{
BOOL result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowMainTextLayer(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long View::GetSeekView()
{
long result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetSeekView(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long View::GetSplitSpecial()
{
long result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetSplitSpecial(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL View::GetShowOptionalBreaks()
{
BOOL result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowOptionalBreaks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void View::CollapseOutline(VARIANT* Range)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Range);
}


void View::ExpandOutline(VARIANT* Range)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Range);
}


void View::ShowAllHeadings()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void View::ShowHeading(long Level)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Level);
}


void View::PreviousHeaderFooter()
{
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void View::NextHeaderFooter()
{
InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


BOOL View::GetDisplayPageBoundaries()
{
BOOL result;
InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetDisplayPageBoundaries(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetDisplaySmartTags()
{
BOOL result;
InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetDisplaySmartTags(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowRevisionsAndComments()
{
BOOL result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowRevisionsAndComments(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowComments()
{
BOOL result;
InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowComments(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowInsertionsAndDeletions()
{
BOOL result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowInsertionsAndDeletions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetShowFormatChanges()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowFormatChanges(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long View::GetRevisionsView()
{
long result;
InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetRevisionsView(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long View::GetRevisionsMode()
{
long result;
InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetRevisionsMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float View::GetRevisionsBalloonWidth()
{
float result;
InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void View::SetRevisionsBalloonWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long View::GetRevisionsBalloonWidthType()
{
long result;
InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetRevisionsBalloonWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long View::GetRevisionsBalloonSide()
{
long result;
InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetRevisionsBalloonSide(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH View::GetReviewers()
{
LPDISPATCH result;
InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL View::GetRevisionsBalloonShowConnectingLines()
{
BOOL result;
InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetRevisionsBalloonShowConnectingLines(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetReadingLayout()
{
BOOL result;
InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetReadingLayout(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long View::GetShowXMLMarkup()
{
long result;
InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetShowXMLMarkup(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long View::GetShadeEditableRanges()
{
long result;
InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void View::SetShadeEditableRanges(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL View::GetShowInkAnnotations()
{
BOOL result;
InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetShowInkAnnotations(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetDisplayBackgrounds()
{
BOOL result;
InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetDisplayBackgrounds(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x31, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetReadingLayoutActualView()
{
BOOL result;
InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetReadingLayoutActualView(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL View::GetReadingLayoutAllowMultiplePages()
{
BOOL result;
InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void View::SetReadingLayoutAllowMultiplePages(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// Zoom properties


/
// Zoom operations


LPDISPATCH Zoom::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Zoom::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Zoom::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Zoom::GetPercentage()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Zoom::SetPercentage(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Zoom::GetPageFit()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Zoom::SetPageFit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Zoom::GetPageRows()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Zoom::SetPageRows(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Zoom::GetPageColumns()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Zoom::SetPageColumns(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Zooms properties


/
// Zooms operations


LPDISPATCH Zooms::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Zooms::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Zooms::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Zooms::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// InlineShape properties


/
// InlineShape operations


LPDISPATCH InlineShape::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long InlineShape::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void InlineShape::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x44c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH InlineShape::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetLinkFormat()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetField()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetOLEFormat()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long InlineShape::GetType()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetHyperlink()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float InlineShape::GetHeight()
{
float result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void InlineShape::SetHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float InlineShape::GetWidth()
{
float result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void InlineShape::SetWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float InlineShape::GetScaleHeight()
{
float result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void InlineShape::SetScaleHeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float InlineShape::GetScaleWidth()
{
float result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void InlineShape::SetScaleWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long InlineShape::GetLockAspectRatio()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void InlineShape::SetLockAspectRatio(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH InlineShape::GetLine()
{
LPDISPATCH result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetFill()
{
LPDISPATCH result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetPictureFormat()
{
LPDISPATCH result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void InlineShape::SetPictureFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void InlineShape::Activate()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void InlineShape::Reset()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void InlineShape::Delete()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void InlineShape::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH InlineShape::ConvertToShape()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetHorizontalLineFormat()
{
LPDISPATCH result;
InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetScript()
{
LPDISPATCH result;
InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShape::GetTextEffect()
{
LPDISPATCH result;
InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void InlineShape::SetTextEffect(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString InlineShape::GetAlternativeText()
{
CString result;
InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void InlineShape::SetAlternativeText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL InlineShape::GetIsPictureBullet()
{
BOOL result;
InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}




/
// InlineShapes properties


/
// InlineShapes operations


LPDISPATCH InlineShapes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long InlineShapes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShapes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long InlineShapes::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN InlineShapes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH InlineShapes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH InlineShapes::AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, LinkToFile, SaveWithDocument, Range);
return result;
}


LPDISPATCH InlineShapes::AddOLEObject(VARIANT* ClassType, VARIANT* FileName, VARIANT* LinkToFile, VARIANT* DisplayAsIcon, VARIANT* IconFileName, VARIANT* IconIndex, VARIANT* IconLabel, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
ClassType, FileName, LinkToFile, DisplayAsIcon, IconFileName, IconIndex, IconLabel, Range);
return result;
}


LPDISPATCH InlineShapes::AddOLEControl(VARIANT* ClassType, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
ClassType, Range);
return result;
}


LPDISPATCH InlineShapes::New(LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH InlineShapes::AddHorizontalLine(LPCTSTR FileName, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, Range);
return result;
}


LPDISPATCH InlineShapes::AddHorizontalLineStandard(VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH InlineShapes::AddPictureBullet(LPCTSTR FileName, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x6a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, Range);
return result;
}




/
// SpellingSuggestions properties


/
// SpellingSuggestions operations


LPDISPATCH SpellingSuggestions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SpellingSuggestions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SpellingSuggestions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN SpellingSuggestions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long SpellingSuggestions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long SpellingSuggestions::GetSpellingErrorType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SpellingSuggestions::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// SpellingSuggestion properties


/
// SpellingSuggestion operations


LPDISPATCH SpellingSuggestion::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SpellingSuggestion::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SpellingSuggestion::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString SpellingSuggestion::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// Dictionaries properties


/
// Dictionaries operations


LPDISPATCH Dictionaries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Dictionaries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dictionaries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Dictionaries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Dictionaries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Dictionaries::GetMaximum()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dictionaries::GetActiveCustomDictionary()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Dictionaries::SetActiveCustomDictionary(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH Dictionaries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Dictionaries::Add(LPCTSTR FileName)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName);
return result;
}


void Dictionaries::ClearAll()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// HangulHanjaConversionDictionaries properties


/
// HangulHanjaConversionDictionaries operations


LPDISPATCH HangulHanjaConversionDictionaries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HangulHanjaConversionDictionaries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulHanjaConversionDictionaries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN HangulHanjaConversionDictionaries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long HangulHanjaConversionDictionaries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long HangulHanjaConversionDictionaries::GetMaximum()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulHanjaConversionDictionaries::GetActiveCustomDictionary()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void HangulHanjaConversionDictionaries::SetActiveCustomDictionary(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH HangulHanjaConversionDictionaries::GetBuiltinDictionary()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulHanjaConversionDictionaries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH HangulHanjaConversionDictionaries::Add(LPCTSTR FileName)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName);
return result;
}


void HangulHanjaConversionDictionaries::ClearAll()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Dictionary properties


/
// Dictionary operations


LPDISPATCH Dictionary::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Dictionary::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Dictionary::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Dictionary::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Dictionary::GetPath()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long Dictionary::GetLanguageID()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Dictionary::SetLanguageID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Dictionary::GetReadOnly()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


long Dictionary::GetType()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL Dictionary::GetLanguageSpecific()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Dictionary::SetLanguageSpecific(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


void Dictionary::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// ReadabilityStatistics properties


/
// ReadabilityStatistics operations


LPDISPATCH ReadabilityStatistics::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ReadabilityStatistics::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ReadabilityStatistics::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN ReadabilityStatistics::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ReadabilityStatistics::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ReadabilityStatistics::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// ReadabilityStatistic properties


/
// ReadabilityStatistic operations


LPDISPATCH ReadabilityStatistic::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ReadabilityStatistic::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ReadabilityStatistic::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString ReadabilityStatistic::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


float ReadabilityStatistic::GetValue()
{
float result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}




/
// Versions properties


/
// Versions operations


LPDISPATCH Versions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Versions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Versions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Versions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Versions::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Versions::GetAutoVersion()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Versions::SetAutoVersion(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH Versions::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void Versions::Save(VARIANT* Comment)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Comment);
}




/
// Version properties


/
// Version operations


LPDISPATCH Version::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Version::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Version::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString Version::GetSavedBy()
{
CString result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Version::GetComment()
{
CString result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


DATE Version::GetDate()
{
DATE result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
return result;
}


long Version::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Version::Delete()
{
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH Version::Open()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Options properties


/
// Options operations


LPDISPATCH Options::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Options::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Options::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Options::GetAllowAccentedUppercase()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowAccentedUppercase(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetWPHelp()
{
BOOL result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetWPHelp(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetWPDocNavKeys()
{
BOOL result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetWPDocNavKeys(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPagination()
{
BOOL result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPagination(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetBlueScreen()
{
BOOL result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetBlueScreen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetEnableSound()
{
BOOL result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetEnableSound(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetConfirmConversions()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetConfirmConversions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetUpdateLinksAtOpen()
{
BOOL result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUpdateLinksAtOpen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSendMailAttach()
{
BOOL result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSendMailAttach(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetMeasurementUnit()
{
long result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetMeasurementUnit(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetButtonFieldClicks()
{
long result;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetButtonFieldClicks(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetShortMenuNames()
{
BOOL result;
InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShortMenuNames(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetRTFInClipboard()
{
BOOL result;
InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetRTFInClipboard(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetUpdateFieldsAtPrint()
{
BOOL result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUpdateFieldsAtPrint(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintProperties()
{
BOOL result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintProperties(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintFieldCodes()
{
BOOL result;
InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintFieldCodes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintComments()
{
BOOL result;
InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintComments(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintHiddenText()
{
BOOL result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintHiddenText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetEnvelopeFeederInstalled()
{
BOOL result;
InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL Options::GetUpdateLinksAtPrint()
{
BOOL result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUpdateLinksAtPrint(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintBackground()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintBackground(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintDrawingObjects()
{
BOOL result;
InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintDrawingObjects(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString Options::GetDefaultTray()
{
CString result;
InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Options::SetDefaultTray(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Options::GetDefaultTrayID()
{
long result;
InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultTrayID(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetCreateBackup()
{
BOOL result;
InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCreateBackup(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAllowFastSave()
{
BOOL result;
InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowFastSave(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSavePropertiesPrompt()
{
BOOL result;
InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSavePropertiesPrompt(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSaveNormalPrompt()
{
BOOL result;
InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSaveNormalPrompt(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetSaveInterval()
{
long result;
InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetSaveInterval(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetBackgroundSave()
{
BOOL result;
InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetBackgroundSave(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetInsertedTextMark()
{
long result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetInsertedTextMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x39, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetDeletedTextMark()
{
long result;
InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDeletedTextMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetRevisedLinesMark()
{
long result;
InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetRevisedLinesMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetInsertedTextColor()
{
long result;
InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetInsertedTextColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetDeletedTextColor()
{
long result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDeletedTextColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetRevisedLinesColor()
{
long result;
InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetRevisedLinesColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString Options::GetDefaultFilePath(long Path)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
Path);
return result;
}


void Options::SetDefaultFilePath(long Path, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_I4 VTS_BSTR;
InvokeHelper(0x41, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
Path, lpszNewValue);
}


BOOL Options::GetOvertype()
{
BOOL result;
InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetOvertype(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetReplaceSelection()
{
BOOL result;
InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetReplaceSelection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x43, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAllowDragAndDrop()
{
BOOL result;
InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowDragAndDrop(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoWordSelection()
{
BOOL result;
InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoWordSelection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x45, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetINSKeyForPaste()
{
BOOL result;
InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetINSKeyForPaste(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x46, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSmartCutPaste()
{
BOOL result;
InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSmartCutPaste(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x47, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetTabIndentKey()
{
BOOL result;
InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetTabIndentKey(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString Options::GetPictureEditor()
{
CString result;
InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Options::SetPictureEditor(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL Options::GetAnimateScreenMovements()
{
BOOL result;
InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAnimateScreenMovements(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetRevisedPropertiesMark()
{
long result;
InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetRevisedPropertiesMark(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetRevisedPropertiesColor()
{
long result;
InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetRevisedPropertiesColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetSnapToGrid()
{
BOOL result;
InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSnapToGrid(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSnapToShapes()
{
BOOL result;
InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSnapToShapes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


float Options::GetGridDistanceHorizontal()
{
float result;
InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Options::SetGridDistanceHorizontal(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x51, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Options::GetGridDistanceVertical()
{
float result;
InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Options::SetGridDistanceVertical(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Options::GetGridOriginHorizontal()
{
float result;
InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Options::SetGridOriginHorizontal(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float Options::GetGridOriginVertical()
{
float result;
InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Options::SetGridOriginVertical(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x54, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL Options::GetInlineConversion()
{
BOOL result;
InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetInlineConversion(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x56, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetIMEAutomaticControl()
{
BOOL result;
InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetIMEAutomaticControl(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x57, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatApplyHeadings()
{
BOOL result;
InvokeHelper(0xfa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatApplyHeadings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xfa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatApplyLists()
{
BOOL result;
InvokeHelper(0xfb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatApplyLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xfb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatApplyBulletedLists()
{
BOOL result;
InvokeHelper(0xfc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatApplyBulletedLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xfc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatApplyOtherParas()
{
BOOL result;
InvokeHelper(0xfd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatApplyOtherParas(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xfd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceQuotes()
{
BOOL result;
InvokeHelper(0xfe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceQuotes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xfe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceSymbols()
{
BOOL result;
InvokeHelper(0xff, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceSymbols(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xff, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceOrdinals()
{
BOOL result;
InvokeHelper(0x100, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceOrdinals(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x100, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceFractions()
{
BOOL result;
InvokeHelper(0x101, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceFractions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x101, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplacePlainTextEmphasis()
{
BOOL result;
InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplacePlainTextEmphasis(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x102, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatPreserveStyles()
{
BOOL result;
InvokeHelper(0x103, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatPreserveStyles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x103, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyHeadings()
{
BOOL result;
InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyHeadings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyBorders()
{
BOOL result;
InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyBorders(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyBulletedLists()
{
BOOL result;
InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyBulletedLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyNumberedLists()
{
BOOL result;
InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyNumberedLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceQuotes()
{
BOOL result;
InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceQuotes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceSymbols()
{
BOOL result;
InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceSymbols(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceOrdinals()
{
BOOL result;
InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceOrdinals(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceFractions()
{
BOOL result;
InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceFractions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplacePlainTextEmphasis()
{
BOOL result;
InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplacePlainTextEmphasis(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeFormatListItemBeginning()
{
BOOL result;
InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeFormatListItemBeginning(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeDefineStyles()
{
BOOL result;
InvokeHelper(0x10e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeDefineStyles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatPlainTextWordMail()
{
BOOL result;
InvokeHelper(0x10f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatPlainTextWordMail(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceHyperlinks()
{
BOOL result;
InvokeHelper(0x110, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x110, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceHyperlinks()
{
BOOL result;
InvokeHelper(0x111, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceHyperlinks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x111, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDefaultHighlightColorIndex()
{
long result;
InvokeHelper(0x112, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultHighlightColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x112, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetDefaultBorderLineStyle()
{
long result;
InvokeHelper(0x113, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultBorderLineStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x113, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetCheckSpellingAsYouType()
{
BOOL result;
InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCheckSpellingAsYouType(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetCheckGrammarAsYouType()
{
BOOL result;
InvokeHelper(0x115, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCheckGrammarAsYouType(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x115, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetIgnoreInternetAndFileAddresses()
{
BOOL result;
InvokeHelper(0x116, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetIgnoreInternetAndFileAddresses(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x116, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetShowReadabilityStatistics()
{
BOOL result;
InvokeHelper(0x117, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShowReadabilityStatistics(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x117, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetIgnoreUppercase()
{
BOOL result;
InvokeHelper(0x118, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetIgnoreUppercase(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x118, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetIgnoreMixedDigits()
{
BOOL result;
InvokeHelper(0x119, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetIgnoreMixedDigits(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x119, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSuggestFromMainDictionaryOnly()
{
BOOL result;
InvokeHelper(0x11a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSuggestFromMainDictionaryOnly(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSuggestSpellingCorrections()
{
BOOL result;
InvokeHelper(0x11b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSuggestSpellingCorrections(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDefaultBorderLineWidth()
{
long result;
InvokeHelper(0x11c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultBorderLineWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetCheckGrammarWithSpelling()
{
BOOL result;
InvokeHelper(0x11d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCheckGrammarWithSpelling(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDefaultOpenFormat()
{
long result;
InvokeHelper(0x11e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultOpenFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetPrintDraft()
{
BOOL result;
InvokeHelper(0x11f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintDraft(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x11f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintReverse()
{
BOOL result;
InvokeHelper(0x120, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintReverse(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x120, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMapPaperSize()
{
BOOL result;
InvokeHelper(0x121, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMapPaperSize(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x121, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyTables()
{
BOOL result;
InvokeHelper(0x122, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyTables(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x122, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatApplyFirstIndents()
{
BOOL result;
InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatApplyFirstIndents(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x123, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatMatchParentheses()
{
BOOL result;
InvokeHelper(0x126, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatMatchParentheses(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x126, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatReplaceFarEastDashes()
{
BOOL result;
InvokeHelper(0x127, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatReplaceFarEastDashes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x127, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatDeleteAutoSpaces()
{
BOOL result;
InvokeHelper(0x128, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatDeleteAutoSpaces(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x128, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyFirstIndents()
{
BOOL result;
InvokeHelper(0x129, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyFirstIndents(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x129, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyDates()
{
BOOL result;
InvokeHelper(0x12a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyDates(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeApplyClosings()
{
BOOL result;
InvokeHelper(0x12b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeApplyClosings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeMatchParentheses()
{
BOOL result;
InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeMatchParentheses(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeReplaceFarEastDashes()
{
BOOL result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeReplaceFarEastDashes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeDeleteAutoSpaces()
{
BOOL result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeDeleteAutoSpaces(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeInsertClosings()
{
BOOL result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeInsertClosings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeAutoLetterWizard()
{
BOOL result;
InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeAutoLetterWizard(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x130, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoFormatAsYouTypeInsertOvers()
{
BOOL result;
InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoFormatAsYouTypeInsertOvers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x131, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetDisplayGridLines()
{
BOOL result;
InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetDisplayGridLines(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyCase()
{
BOOL result;
InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyCase(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x135, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyByte()
{
BOOL result;
InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyByte(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyHiragana()
{
BOOL result;
InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyHiragana(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzySmallKana()
{
BOOL result;
InvokeHelper(0x138, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzySmallKana(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x138, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyDash()
{
BOOL result;
InvokeHelper(0x139, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyDash(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x139, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyIterationMark()
{
BOOL result;
InvokeHelper(0x13a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyIterationMark(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyKanji()
{
BOOL result;
InvokeHelper(0x13b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyKanji(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyOldKana()
{
BOOL result;
InvokeHelper(0x13c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyOldKana(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyProlongedSoundMark()
{
BOOL result;
InvokeHelper(0x13d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyProlongedSoundMark(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyDZ()
{
BOOL result;
InvokeHelper(0x13e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyDZ(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyBV()
{
BOOL result;
InvokeHelper(0x13f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyBV(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyTC()
{
BOOL result;
InvokeHelper(0x140, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyTC(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x140, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyHF()
{
BOOL result;
InvokeHelper(0x141, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyHF(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x141, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyZJ()
{
BOOL result;
InvokeHelper(0x142, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyZJ(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x142, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyAY()
{
BOOL result;
InvokeHelper(0x143, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyAY(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x143, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyKiKu()
{
BOOL result;
InvokeHelper(0x144, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyKiKu(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x144, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzyPunctuation()
{
BOOL result;
InvokeHelper(0x145, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzyPunctuation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x145, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetMatchFuzzySpace()
{
BOOL result;
InvokeHelper(0x146, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetMatchFuzzySpace(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x146, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetApplyFarEastFontsToAscii()
{
BOOL result;
InvokeHelper(0x147, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetApplyFarEastFontsToAscii(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x147, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetConvertHighAnsiToFarEast()
{
BOOL result;
InvokeHelper(0x148, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetConvertHighAnsiToFarEast(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x148, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintOddPagesInAscendingOrder()
{
BOOL result;
InvokeHelper(0x14a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintOddPagesInAscendingOrder(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintEvenPagesInAscendingOrder()
{
BOOL result;
InvokeHelper(0x14b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintEvenPagesInAscendingOrder(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x14b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDefaultBorderColorIndex()
{
long result;
InvokeHelper(0x151, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultBorderColorIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x151, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetEnableMisusedWordsDictionary()
{
BOOL result;
InvokeHelper(0x152, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetEnableMisusedWordsDictionary(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x152, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAllowCombinedAuxiliaryForms()
{
BOOL result;
InvokeHelper(0x153, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowCombinedAuxiliaryForms(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x153, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetHangulHanjaFastConversion()
{
BOOL result;
InvokeHelper(0x154, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetHangulHanjaFastConversion(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x154, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetCheckHangulEndings()
{
BOOL result;
InvokeHelper(0x155, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCheckHangulEndings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x155, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetEnableHangulHanjaRecentOrdering()
{
BOOL result;
InvokeHelper(0x156, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetEnableHangulHanjaRecentOrdering(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x156, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetMultipleWordConversionsMode()
{
long result;
InvokeHelper(0x157, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetMultipleWordConversionsMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x157, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Options::SetWPHelpOptions(VARIANT* CommandKeyHelp, VARIANT* DocNavigationKeys, VARIANT* MouseSimulation, VARIANT* DemoGuidance, VARIANT* DemoSpeed, VARIANT* HelpType)
{
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x14d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
CommandKeyHelp, DocNavigationKeys, MouseSimulation, DemoGuidance, DemoSpeed, HelpType);
}


long Options::GetDefaultBorderColor()
{
long result;
InvokeHelper(0x158, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultBorderColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x158, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetAllowPixelUnits()
{
BOOL result;
InvokeHelper(0x159, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowPixelUnits(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x159, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetUseCharacterUnit()
{
BOOL result;
InvokeHelper(0x15a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUseCharacterUnit(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAllowCompoundNounProcessing()
{
BOOL result;
InvokeHelper(0x15b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowCompoundNounProcessing(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoKeyboardSwitching()
{
BOOL result;
InvokeHelper(0x18f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoKeyboardSwitching(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDocumentViewDirection()
{
long result;
InvokeHelper(0x190, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDocumentViewDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x190, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetArabicNumeral()
{
long result;
InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetArabicNumeral(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetMonthNames()
{
long result;
InvokeHelper(0x192, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetMonthNames(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetCursorMovement()
{
long result;
InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetCursorMovement(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x193, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetVisualSelection()
{
long result;
InvokeHelper(0x194, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetVisualSelection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x194, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetShowDiacritics()
{
BOOL result;
InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShowDiacritics(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetShowControlCharacters()
{
BOOL result;
InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShowControlCharacters(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x196, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAddControlCharacters()
{
BOOL result;
InvokeHelper(0x197, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAddControlCharacters(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x197, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAddBiDirectionalMarksWhenSavingTextFile()
{
BOOL result;
InvokeHelper(0x198, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAddBiDirectionalMarksWhenSavingTextFile(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x198, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetStrictInitialAlefHamza()
{
BOOL result;
InvokeHelper(0x199, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetStrictInitialAlefHamza(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x199, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetStrictFinalYaa()
{
BOOL result;
InvokeHelper(0x19a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetStrictFinalYaa(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetHebrewMode()
{
long result;
InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetHebrewMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x19b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetArabicMode()
{
long result;
InvokeHelper(0x19c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetArabicMode(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x19c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetAllowClickAndTypeMouse()
{
BOOL result;
InvokeHelper(0x19d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowClickAndTypeMouse(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetUseGermanSpellingReform()
{
BOOL result;
InvokeHelper(0x19f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUseGermanSpellingReform(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetInterpretHighAnsi()
{
long result;
InvokeHelper(0x1a2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetInterpretHighAnsi(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetAddHebDoubleQuote()
{
BOOL result;
InvokeHelper(0x1a3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAddHebDoubleQuote(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetUseDiffDiacColor()
{
BOOL result;
InvokeHelper(0x1a4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetUseDiffDiacColor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetDiacriticColorVal()
{
long result;
InvokeHelper(0x1a5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDiacriticColorVal(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1a5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetOptimizeForWord97byDefault()
{
BOOL result;
InvokeHelper(0x1a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetOptimizeForWord97byDefault(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetLocalNetworkFile()
{
BOOL result;
InvokeHelper(0x1a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetLocalNetworkFile(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetTypeNReplace()
{
BOOL result;
InvokeHelper(0x1a9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetTypeNReplace(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1a9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSequenceCheck()
{
BOOL result;
InvokeHelper(0x1aa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSequenceCheck(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetBackgroundOpen()
{
BOOL result;
InvokeHelper(0x1ab, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetBackgroundOpen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1ab, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetDisableFeaturesbyDefault()
{
BOOL result;
InvokeHelper(0x1ac, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetDisableFeaturesbyDefault(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1ac, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteAdjustWordSpacing()
{
BOOL result;
InvokeHelper(0x1ad, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteAdjustWordSpacing(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1ad, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteAdjustParagraphSpacing()
{
BOOL result;
InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteAdjustParagraphSpacing(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1ae, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteAdjustTableFormatting()
{
BOOL result;
InvokeHelper(0x1af, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteAdjustTableFormatting(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1af, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteSmartStyleBehavior()
{
BOOL result;
InvokeHelper(0x1b0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteSmartStyleBehavior(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteMergeFromPPT()
{
BOOL result;
InvokeHelper(0x1b1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteMergeFromPPT(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteMergeFromXL()
{
BOOL result;
InvokeHelper(0x1b2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteMergeFromXL(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetCtrlClickHyperlinkToOpen()
{
BOOL result;
InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetCtrlClickHyperlinkToOpen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetPictureWrapType()
{
long result;
InvokeHelper(0x1b4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetPictureWrapType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1b4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetDisableFeaturesIntroducedAfterbyDefault()
{
long result;
InvokeHelper(0x1b5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDisableFeaturesIntroducedAfterbyDefault(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetPasteSmartCutPaste()
{
BOOL result;
InvokeHelper(0x1b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteSmartCutPaste(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetDisplayPasteOptions()
{
BOOL result;
InvokeHelper(0x1b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetDisplayPasteOptions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPromptUpdateStyle()
{
BOOL result;
InvokeHelper(0x1b9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPromptUpdateStyle(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1b9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString Options::GetDefaultEPostageApp()
{
CString result;
InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Options::SetDefaultEPostageApp(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long Options::GetDefaultTextEncoding()
{
long result;
InvokeHelper(0x1bb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetDefaultTextEncoding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1bb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetLabelSmartTags()
{
BOOL result;
InvokeHelper(0x1bc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetLabelSmartTags(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1bc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetDisplaySmartTagButtons()
{
BOOL result;
InvokeHelper(0x1bd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetDisplaySmartTagButtons(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1bd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetWarnBeforeSavingPrintingSendingMarkup()
{
BOOL result;
InvokeHelper(0x1be, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetWarnBeforeSavingPrintingSendingMarkup(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1be, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetStoreRSIDOnSave()
{
BOOL result;
InvokeHelper(0x1bf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetStoreRSIDOnSave(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1bf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetShowFormatError()
{
BOOL result;
InvokeHelper(0x1c0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShowFormatError(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetFormatScanning()
{
BOOL result;
InvokeHelper(0x1c1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetFormatScanning(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPasteMergeLists()
{
BOOL result;
InvokeHelper(0x1c2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPasteMergeLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAutoCreateNewDrawings()
{
BOOL result;
InvokeHelper(0x1c3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAutoCreateNewDrawings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSmartParaSelection()
{
BOOL result;
InvokeHelper(0x1c4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSmartParaSelection(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long Options::GetRevisionsBalloonPrintOrientation()
{
long result;
InvokeHelper(0x1c5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetRevisionsBalloonPrintOrientation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Options::GetCommentsColor()
{
long result;
InvokeHelper(0x1c6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Options::SetCommentsColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1c6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Options::GetPrintXMLTag()
{
BOOL result;
InvokeHelper(0x1c7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintXMLTag(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetPrintBackgrounds()
{
BOOL result;
InvokeHelper(0x1c8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetPrintBackgrounds(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetAllowReadingMode()
{
BOOL result;
InvokeHelper(0x1c9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetAllowReadingMode(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1c9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetShowMarkupOpenSave()
{
BOOL result;
InvokeHelper(0x1ca, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetShowMarkupOpenSave(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1ca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL Options::GetSmartCursoring()
{
BOOL result;
InvokeHelper(0x1cb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Options::SetSmartCursoring(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1cb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// MailMessage properties


/
// MailMessage operations


LPDISPATCH MailMessage::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MailMessage::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MailMessage::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void MailMessage::CheckName()
{
InvokeHelper(0x14e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::Delete()
{
InvokeHelper(0x14f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::DisplayMoveDialog()
{
InvokeHelper(0x150, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::DisplayProperties()
{
InvokeHelper(0x151, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::DisplaySelectNamesDialog()
{
InvokeHelper(0x152, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::Forward()
{
InvokeHelper(0x153, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::GoToNext()
{
InvokeHelper(0x154, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::GoToPrevious()
{
InvokeHelper(0x155, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::Reply()
{
InvokeHelper(0x156, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::ReplyAll()
{
InvokeHelper(0x157, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void MailMessage::ToggleHeader()
{
InvokeHelper(0x158, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// ProofreadingErrors properties


/
// ProofreadingErrors operations


LPDISPATCH ProofreadingErrors::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ProofreadingErrors::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ProofreadingErrors::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN ProofreadingErrors::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long ProofreadingErrors::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long ProofreadingErrors::GetType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ProofreadingErrors::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Mailer properties


/
// Mailer operations


LPDISPATCH Mailer::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Mailer::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Mailer::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


VARIANT Mailer::GetBCCRecipients()
{
VARIANT result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Mailer::SetBCCRecipients(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Mailer::GetCCRecipients()
{
VARIANT result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Mailer::SetCCRecipients(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Mailer::GetRecipients()
{
VARIANT result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Mailer::SetRecipients(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


VARIANT Mailer::GetEnclosures()
{
VARIANT result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


void Mailer::SetEnclosures(VARIANT* newValue)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


CString Mailer::GetSender()
{
CString result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


DATE Mailer::GetSendDateTime()
{
DATE result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
return result;
}


BOOL Mailer::GetReceived()
{
BOOL result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


CString Mailer::GetSubject()
{
CString result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Mailer::SetSubject(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}




/
// WrapFormat properties


/
// WrapFormat operations


LPDISPATCH WrapFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long WrapFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH WrapFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long WrapFormat::GetType()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long WrapFormat::GetSide()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetSide(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float WrapFormat::GetDistanceTop()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetDistanceTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float WrapFormat::GetDistanceBottom()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetDistanceBottom(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float WrapFormat::GetDistanceLeft()
{
float result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetDistanceLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float WrapFormat::GetDistanceRight()
{
float result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetDistanceRight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long WrapFormat::GetAllowOverlap()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WrapFormat::SetAllowOverlap(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// HangulAndAlphabetExceptions properties


/
// HangulAndAlphabetExceptions operations


LPDISPATCH HangulAndAlphabetExceptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HangulAndAlphabetExceptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulAndAlphabetExceptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN HangulAndAlphabetExceptions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long HangulAndAlphabetExceptions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulAndAlphabetExceptions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH HangulAndAlphabetExceptions::Add(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// HangulAndAlphabetException properties


/
// HangulAndAlphabetException operations


LPDISPATCH HangulAndAlphabetException::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HangulAndAlphabetException::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HangulAndAlphabetException::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HangulAndAlphabetException::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString HangulAndAlphabetException::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void HangulAndAlphabetException::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Adjustments properties


/
// Adjustments operations


LPDISPATCH Adjustments::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Adjustments::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Adjustments::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Adjustments::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float Adjustments::GetItem(long Index)
{
float result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, parms,
Index);
return result;
}


void Adjustments::SetItem(long Index, float newValue)
{
static BYTE parms[] =
VTS_I4 VTS_R4;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
Index, newValue);
}




/
// CalloutFormat properties


/
// CalloutFormat operations


LPDISPATCH CalloutFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CalloutFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CalloutFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CalloutFormat::GetAccent()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetAccent(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CalloutFormat::GetAngle()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetAngle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CalloutFormat::GetAutoAttach()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetAutoAttach(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long CalloutFormat::GetAutoLength()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long CalloutFormat::GetBorder()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetBorder(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float CalloutFormat::GetDrop()
{
float result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


long CalloutFormat::GetDropType()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float CalloutFormat::GetGap()
{
float result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetGap(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float CalloutFormat::GetLength()
{
float result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


long CalloutFormat::GetType()
{
long result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void CalloutFormat::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void CalloutFormat::AutomaticLength()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void CalloutFormat::CustomDrop(float Drop)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Drop);
}


void CalloutFormat::CustomLength(float Length)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Length);
}


void CalloutFormat::PresetDrop(long DropType)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
DropType);
}




/
// ColorFormat properties


/
// ColorFormat operations


LPDISPATCH ColorFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ColorFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ColorFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ColorFormat::GetRgb()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetRgb(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ColorFormat::GetType()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString ColorFormat::GetName()
{
CString result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void ColorFormat::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


float ColorFormat::GetTintAndShade()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetTintAndShade(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ColorFormat::GetOverPrint()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetOverPrint(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float ColorFormat::GetInk(long Index)
{
float result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, parms,
Index);
return result;
}


void ColorFormat::SetInk(long Index, float newValue)
{
static BYTE parms[] =
VTS_I4 VTS_R4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
Index, newValue);
}


long ColorFormat::GetCyan()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetCyan(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ColorFormat::GetMagenta()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetMagenta(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ColorFormat::GetYellow()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetYellow(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ColorFormat::GetBlack()
{
long result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ColorFormat::SetBlack(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void ColorFormat::SetCMYK(long Cyan, long Magenta, long Yellow, long Black)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_I4 VTS_I4;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Cyan, Magenta, Yellow, Black);
}




/
// ConnectorFormat properties


/
// ConnectorFormat operations


LPDISPATCH ConnectorFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetBeginConnected()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ConnectorFormat::GetBeginConnectedShape()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetBeginConnectionSite()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetEndConnected()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ConnectorFormat::GetEndConnectedShape()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetEndConnectionSite()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ConnectorFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ConnectorFormat::GetType()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ConnectorFormat::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void ConnectorFormat::BeginConnect(LPDISPATCH* ConnectedShape, long ConnectionSite)
{
static BYTE parms[] =
VTS_PDISPATCH VTS_I4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ConnectedShape, ConnectionSite);
}


void ConnectorFormat::BeginDisconnect()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ConnectorFormat::EndConnect(LPDISPATCH* ConnectedShape, long ConnectionSite)
{
static BYTE parms[] =
VTS_PDISPATCH VTS_I4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ConnectedShape, ConnectionSite);
}


void ConnectorFormat::EndDisconnect()
{
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// FillFormat properties


/
// FillFormat operations


LPDISPATCH FillFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FillFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FillFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FillFormat::GetBackColor()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH FillFormat::GetForeColor()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FillFormat::GetGradientColorType()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float FillFormat::GetGradientDegree()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


long FillFormat::GetGradientStyle()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FillFormat::GetGradientVariant()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FillFormat::GetPattern()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FillFormat::GetPresetGradientType()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FillFormat::GetPresetTexture()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString FillFormat::GetTextureName()
{
CString result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long FillFormat::GetTextureType()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float FillFormat::GetTransparency()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void FillFormat::SetTransparency(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long FillFormat::GetType()
{
long result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long FillFormat::GetVisible()
{
long result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FillFormat::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void FillFormat::OneColorGradient(long Style, long Variant, float Degree)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Style, Variant, Degree);
}


void FillFormat::Patterned(long Pattern)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Pattern);
}


void FillFormat::PresetGradient(long Style, long Variant, long PresetGradientType)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Style, Variant, PresetGradientType);
}


void FillFormat::PresetTextured(long PresetTexture)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
PresetTexture);
}


void FillFormat::Solid()
{
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void FillFormat::TwoColorGradient(long Style, long Variant)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Style, Variant);
}


void FillFormat::UserPicture(LPCTSTR PictureFile)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
PictureFile);
}


void FillFormat::UserTextured(LPCTSTR TextureFile)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
TextureFile);
}




/
// FreeformBuilder properties


/
// FreeformBuilder operations


LPDISPATCH FreeformBuilder::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FreeformBuilder::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FreeformBuilder::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void FreeformBuilder::AddNodes(long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SegmentType, EditingType, X1, Y1, X2, Y2, X3, Y3);
}


LPDISPATCH FreeformBuilder::ConvertToShape(VARIANT* Anchor)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Anchor);
return result;
}




/
// LineFormat properties


/
// LineFormat operations


LPDISPATCH LineFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LineFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH LineFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH LineFormat::GetBackColor()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LineFormat::GetBeginArrowheadLength()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetBeginArrowheadLength(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetBeginArrowheadStyle()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetBeginArrowheadStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetBeginArrowheadWidth()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetBeginArrowheadWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetDashStyle()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetDashStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetEndArrowheadLength()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetEndArrowheadLength(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetEndArrowheadStyle()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetEndArrowheadStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetEndArrowheadWidth()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetEndArrowheadWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH LineFormat::GetForeColor()
{
LPDISPATCH result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long LineFormat::GetPattern()
{
long result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetPattern(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long LineFormat::GetStyle()
{
long result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float LineFormat::GetTransparency()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void LineFormat::SetTransparency(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long LineFormat::GetVisible()
{
long result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float LineFormat::GetWeight()
{
float result;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void LineFormat::SetWeight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long LineFormat::GetInsetPen()
{
long result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void LineFormat::SetInsetPen(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// PictureFormat properties


/
// PictureFormat operations


LPDISPATCH PictureFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long PictureFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH PictureFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float PictureFormat::GetBrightness()
{
float result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetBrightness(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long PictureFormat::GetColorType()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetColorType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float PictureFormat::GetContrast()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetContrast(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PictureFormat::GetCropBottom()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetCropBottom(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PictureFormat::GetCropLeft()
{
float result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetCropLeft(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PictureFormat::GetCropRight()
{
float result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetCropRight(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float PictureFormat::GetCropTop()
{
float result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetCropTop(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long PictureFormat::GetTransparencyColor()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetTransparencyColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long PictureFormat::GetTransparentBackground()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void PictureFormat::SetTransparentBackground(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void PictureFormat::IncrementBrightness(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void PictureFormat::IncrementContrast(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}




/
// ShadowFormat properties


/
// ShadowFormat operations


LPDISPATCH ShadowFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShadowFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShadowFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ShadowFormat::GetForeColor()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShadowFormat::GetObscured()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetObscured(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float ShadowFormat::GetOffsetX()
{
float result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetOffsetX(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ShadowFormat::GetOffsetY()
{
float result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetOffsetY(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ShadowFormat::GetTransparency()
{
float result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetTransparency(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ShadowFormat::GetType()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ShadowFormat::GetVisible()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ShadowFormat::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void ShadowFormat::IncrementOffsetX(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ShadowFormat::IncrementOffsetY(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}




/
// ShapeNode properties


/
// ShapeNode operations


LPDISPATCH ShapeNode::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeNode::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeNode::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeNode::GetEditingType()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


VARIANT ShapeNode::GetPoints()
{
VARIANT result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}


long ShapeNode::GetSegmentType()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// ShapeNodes properties


/
// ShapeNodes operations


LPDISPATCH ShapeNodes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeNodes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ShapeNodes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ShapeNodes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN ShapeNodes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


void ShapeNodes::Delete(long Index)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index);
}


LPDISPATCH ShapeNodes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void ShapeNodes::SetEditingType(long Index, long EditingType)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index, EditingType);
}


void ShapeNodes::SetPosition(long Index, float X1, float Y1)
{
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index, X1, Y1);
}


void ShapeNodes::SetSegmentType(long Index, long SegmentType)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index, SegmentType);
}


void ShapeNodes::Insert(long Index, long SegmentType, long EditingType, float X1, float Y1, float X2, float Y2, float X3, float Y3)
{
static BYTE parms[] =
VTS_I4 VTS_I4 VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Index, SegmentType, EditingType, X1, Y1, X2, Y2, X3, Y3);
}




/
// TextEffectFormat properties


/
// TextEffectFormat operations


LPDISPATCH TextEffectFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextEffectFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TextEffectFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TextEffectFormat::GetAlignment()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetFontBold()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetFontBold(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetFontItalic()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetFontItalic(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString TextEffectFormat::GetFontName()
{
CString result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetFontName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


float TextEffectFormat::GetFontSize()
{
float result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetFontSize(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long TextEffectFormat::GetKernedPairs()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetKernedPairs(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetNormalizedHeight()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetNormalizedHeight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetPresetShape()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetPresetShape(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetPresetTextEffect()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetPresetTextEffect(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TextEffectFormat::GetRotatedChars()
{
long result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetRotatedChars(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString TextEffectFormat::GetText()
{
CString result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


float TextEffectFormat::GetTracking()
{
float result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TextEffectFormat::SetTracking(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


void TextEffectFormat::ToggleVerticalText()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// ThreeDFormat properties


/
// ThreeDFormat operations


LPDISPATCH ThreeDFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ThreeDFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ThreeDFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float ThreeDFormat::GetDepth()
{
float result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetDepth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ThreeDFormat::GetExtrusionColor()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ThreeDFormat::GetExtrusionColorType()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetExtrusionColorType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ThreeDFormat::GetPerspective()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetPerspective(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ThreeDFormat::GetPresetExtrusionDirection()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long ThreeDFormat::GetPresetLightingDirection()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetPresetLightingDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ThreeDFormat::GetPresetLightingSoftness()
{
long result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetPresetLightingSoftness(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ThreeDFormat::GetPresetMaterial()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetPresetMaterial(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long ThreeDFormat::GetPresetThreeDFormat()
{
long result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


float ThreeDFormat::GetRotationX()
{
float result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetRotationX(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ThreeDFormat::GetRotationY()
{
float result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetRotationY(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long ThreeDFormat::GetVisible()
{
long result;
InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void ThreeDFormat::SetVisible(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void ThreeDFormat::IncrementRotationX(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ThreeDFormat::IncrementRotationY(float Increment)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Increment);
}


void ThreeDFormat::ResetRotation()
{
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ThreeDFormat::SetExtrusionDirection(long PresetExtrusionDirection)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
PresetExtrusionDirection);
}


void ThreeDFormat::SetThreeDFormat(long PresetThreeDFormat)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
PresetThreeDFormat);
}




/
// ApplicationEvents properties


/
// ApplicationEvents operations




/
// DocumentEvents properties


/
// DocumentEvents operations


void DocumentEvents::New()
{
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DocumentEvents::Open()
{
InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DocumentEvents::Close()
{
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// OCXEvents properties


/
// OCXEvents operations


void OCXEvents::GotFocus()
{
InvokeHelper(0x800100e0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void OCXEvents::LostFocus()
{
InvokeHelper(0x800100e1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// IApplicationEvents properties


/
// IApplicationEvents operations


void IApplicationEvents::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// IApplicationEvents2 properties


/
// IApplicationEvents2 operations


void IApplicationEvents2::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents2::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents2::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents2::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents2::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents2::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void IApplicationEvents2::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents2::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents2::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents2::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void IApplicationEvents2::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void IApplicationEvents2::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}




/
// ApplicationEvents2 properties


/
// ApplicationEvents2 operations


void ApplicationEvents2::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents2::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents2::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents2::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents2::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents2::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void ApplicationEvents2::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents2::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents2::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents2::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void ApplicationEvents2::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void ApplicationEvents2::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}




/
// EmailAuthor properties


/
// EmailAuthor operations


LPDISPATCH EmailAuthor::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailAuthor::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailAuthor::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailAuthor::GetStyle()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// EmailOptions properties


/
// EmailOptions operations


LPDISPATCH EmailOptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailOptions::GetCreator()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailOptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL EmailOptions::GetUseThemeStyle()
{
BOOL result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetUseThemeStyle(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString EmailOptions::GetMarkCommentsWith()
{
CString result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void EmailOptions::SetMarkCommentsWith(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL EmailOptions::GetMarkComments()
{
BOOL result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetMarkComments(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH EmailOptions::GetEmailSignature()
{
LPDISPATCH result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailOptions::GetComposeStyle()
{
LPDISPATCH result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailOptions::GetReplyStyle()
{
LPDISPATCH result;
InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString EmailOptions::GetThemeName()
{
CString result;
InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void EmailOptions::SetThemeName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL EmailOptions::GetNewColorOnReply()
{
BOOL result;
InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetNewColorOnReply(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH EmailOptions::GetPlainTextStyle()
{
LPDISPATCH result;
InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL EmailOptions::GetUseThemeStyleOnReply()
{
BOOL result;
InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetUseThemeStyleOnReply(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyHeadings()
{
BOOL result;
InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyHeadings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyBorders()
{
BOOL result;
InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyBorders(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyBulletedLists()
{
BOOL result;
InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyBulletedLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyNumberedLists()
{
BOOL result;
InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyNumberedLists(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceQuotes()
{
BOOL result;
InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceQuotes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceSymbols()
{
BOOL result;
InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceSymbols(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceOrdinals()
{
BOOL result;
InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceOrdinals(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceFractions()
{
BOOL result;
InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceFractions(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplacePlainTextEmphasis()
{
BOOL result;
InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplacePlainTextEmphasis(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeFormatListItemBeginning()
{
BOOL result;
InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeFormatListItemBeginning(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeDefineStyles()
{
BOOL result;
InvokeHelper(0x10e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeDefineStyles(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x10e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceHyperlinks()
{
BOOL result;
InvokeHelper(0x110, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceHyperlinks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x110, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyTables()
{
BOOL result;
InvokeHelper(0x122, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyTables(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x122, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyFirstIndents()
{
BOOL result;
InvokeHelper(0x129, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyFirstIndents(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x129, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyDates()
{
BOOL result;
InvokeHelper(0x12a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyDates(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeApplyClosings()
{
BOOL result;
InvokeHelper(0x12b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeApplyClosings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeMatchParentheses()
{
BOOL result;
InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeMatchParentheses(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeReplaceFarEastDashes()
{
BOOL result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeReplaceFarEastDashes(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeDeleteAutoSpaces()
{
BOOL result;
InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeDeleteAutoSpaces(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeInsertClosings()
{
BOOL result;
InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeInsertClosings(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeAutoLetterWizard()
{
BOOL result;
InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeAutoLetterWizard(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x130, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetAutoFormatAsYouTypeInsertOvers()
{
BOOL result;
InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetAutoFormatAsYouTypeInsertOvers(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x131, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetRelyOnCSS()
{
BOOL result;
InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetRelyOnCSS(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long EmailOptions::GetHTMLFidelity()
{
long result;
InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void EmailOptions::SetHTMLFidelity(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x133, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL EmailOptions::GetEmbedSmartTag()
{
BOOL result;
InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetEmbedSmartTag(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x134, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL EmailOptions::GetTabIndentKey()
{
BOOL result;
InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void EmailOptions::SetTabIndentKey(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x135, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// EmailSignature properties


/
// EmailSignature operations


LPDISPATCH EmailSignature::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailSignature::GetCreator()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailSignature::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString EmailSignature::GetNewMessageSignature()
{
CString result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void EmailSignature::SetNewMessageSignature(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString EmailSignature::GetReplyMessageSignature()
{
CString result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void EmailSignature::SetReplyMessageSignature(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH EmailSignature::GetEmailSignatureEntries()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Email properties


/
// Email operations


LPDISPATCH Email::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Email::GetCreator()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Email::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Email::GetCurrentEmailAuthor()
{
LPDISPATCH result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// HorizontalLineFormat properties


/
// HorizontalLineFormat operations


LPDISPATCH HorizontalLineFormat::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HorizontalLineFormat::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HorizontalLineFormat::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float HorizontalLineFormat::GetPercentWidth()
{
float result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void HorizontalLineFormat::SetPercentWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


BOOL HorizontalLineFormat::GetNoShade()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void HorizontalLineFormat::SetNoShade(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long HorizontalLineFormat::GetAlignment()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void HorizontalLineFormat::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long HorizontalLineFormat::GetWidthType()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void HorizontalLineFormat::SetWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Frameset properties


/
// Frameset operations


LPDISPATCH Frameset::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Frameset::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Frameset::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN Frameset::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Frameset::GetParentFrameset()
{
LPDISPATCH result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Frameset::GetType()
{
long result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Frameset::GetWidthType()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetWidthType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frameset::GetHeightType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetHeightType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frameset::GetWidth()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetWidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frameset::GetHeight()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetHeight(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frameset::GetChildFramesetCount()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Frameset::GetChildFramesetItem(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


float Frameset::GetFramesetBorderWidth()
{
float result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void Frameset::SetFramesetBorderWidth(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long Frameset::GetFramesetBorderColor()
{
long result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetFramesetBorderColor(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Frameset::GetFrameScrollbarType()
{
long result;
InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameScrollbarType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL Frameset::GetFrameResizable()
{
BOOL result;
InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameResizable(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString Frameset::GetFrameName()
{
CString result;
InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL Frameset::GetFrameDisplayBorders()
{
BOOL result;
InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameDisplayBorders(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString Frameset::GetFrameDefaultURL()
{
CString result;
InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameDefaultURL(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL Frameset::GetFrameLinkToFile()
{
BOOL result;
InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Frameset::SetFrameLinkToFile(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH Frameset::AddNewFrame(long Where)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x32, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Where);
return result;
}


void Frameset::Delete()
{
InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// DefaultWebOptions properties


/
// DefaultWebOptions operations


LPDISPATCH DefaultWebOptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DefaultWebOptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DefaultWebOptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL DefaultWebOptions::GetOptimizeForBrowser()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetOptimizeForBrowser(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long DefaultWebOptions::GetBrowserLevel()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetBrowserLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL DefaultWebOptions::GetRelyOnCSS()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetRelyOnCSS(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetOrganizeInFolder()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetOrganizeInFolder(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetUpdateLinksOnSave()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetUpdateLinksOnSave(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetUseLongFileNames()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetUseLongFileNames(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetCheckIfOfficeIsHTMLEditor()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetCheckIfOfficeIsHTMLEditor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetCheckIfWordIsDefaultHTMLEditor()
{
BOOL result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetCheckIfWordIsDefaultHTMLEditor(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetRelyOnVML()
{
BOOL result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetRelyOnVML(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL DefaultWebOptions::GetAllowPNG()
{
BOOL result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetAllowPNG(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long DefaultWebOptions::GetScreenSize()
{
long result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetScreenSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long DefaultWebOptions::GetPixelsPerInch()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetPixelsPerInch(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long DefaultWebOptions::GetEncoding()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetEncoding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL DefaultWebOptions::GetAlwaysSaveInDefaultEncoding()
{
BOOL result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetAlwaysSaveInDefaultEncoding(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH DefaultWebOptions::GetFonts()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString DefaultWebOptions::GetFolderSuffix()
{
CString result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long DefaultWebOptions::GetTargetBrowser()
{
long result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetTargetBrowser(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL DefaultWebOptions::GetSaveNewWebPagesAsWebArchives()
{
BOOL result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void DefaultWebOptions::SetSaveNewWebPagesAsWebArchives(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// WebOptions properties


/
// WebOptions operations


LPDISPATCH WebOptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long WebOptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH WebOptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL WebOptions::GetOptimizeForBrowser()
{
BOOL result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetOptimizeForBrowser(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long WebOptions::GetBrowserLevel()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WebOptions::SetBrowserLevel(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL WebOptions::GetRelyOnCSS()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetRelyOnCSS(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL WebOptions::GetOrganizeInFolder()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetOrganizeInFolder(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL WebOptions::GetUseLongFileNames()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetUseLongFileNames(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL WebOptions::GetRelyOnVML()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetRelyOnVML(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL WebOptions::GetAllowPNG()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void WebOptions::SetAllowPNG(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


long WebOptions::GetScreenSize()
{
long result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WebOptions::SetScreenSize(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long WebOptions::GetPixelsPerInch()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WebOptions::SetPixelsPerInch(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long WebOptions::GetEncoding()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WebOptions::SetEncoding(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString WebOptions::GetFolderSuffix()
{
CString result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void WebOptions::UseDefaultFolderSuffix()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long WebOptions::GetTargetBrowser()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void WebOptions::SetTargetBrowser(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// OtherCorrectionsExceptions properties


/
// OtherCorrectionsExceptions operations


LPDISPATCH OtherCorrectionsExceptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long OtherCorrectionsExceptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH OtherCorrectionsExceptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN OtherCorrectionsExceptions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long OtherCorrectionsExceptions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH OtherCorrectionsExceptions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH OtherCorrectionsExceptions::Add(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// OtherCorrectionsException properties


/
// OtherCorrectionsException operations


LPDISPATCH OtherCorrectionsException::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long OtherCorrectionsException::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH OtherCorrectionsException::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long OtherCorrectionsException::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString OtherCorrectionsException::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void OtherCorrectionsException::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// EmailSignatureEntries properties


/
// EmailSignatureEntries operations


LPDISPATCH EmailSignatureEntries::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailSignatureEntries::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailSignatureEntries::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN EmailSignatureEntries::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long EmailSignatureEntries::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailSignatureEntries::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH EmailSignatureEntries::Add(LPCTSTR Name, LPDISPATCH Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_DISPATCH;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Range);
return result;
}




/
// EmailSignatureEntry properties


/
// EmailSignatureEntry operations


LPDISPATCH EmailSignatureEntry::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailSignatureEntry::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EmailSignatureEntry::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EmailSignatureEntry::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString EmailSignatureEntry::GetName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void EmailSignatureEntry::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void EmailSignatureEntry::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// HTMLDivision properties


/
// HTMLDivision operations


LPDISPATCH HTMLDivision::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HTMLDivision::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivision::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivision::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivision::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


float HTMLDivision::GetLeftIndent()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void HTMLDivision::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float HTMLDivision::GetRightIndent()
{
float result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void HTMLDivision::SetRightIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float HTMLDivision::GetSpaceBefore()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void HTMLDivision::SetSpaceBefore(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float HTMLDivision::GetSpaceAfter()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void HTMLDivision::SetSpaceAfter(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH HTMLDivision::GetHTMLDivisions()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivision::HTMLDivisionParent(VARIANT* LevelsUp)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
LevelsUp);
return result;
}


void HTMLDivision::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// HTMLDivisions properties


/
// HTMLDivisions operations


LPDISPATCH HTMLDivisions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long HTMLDivisions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivisions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN HTMLDivisions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long HTMLDivisions::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long HTMLDivisions::GetNestingLevel()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH HTMLDivisions::Add(VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}


LPDISPATCH HTMLDivisions::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// DiagramNode properties


/
// DiagramNode operations


LPDISPATCH DiagramNode::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNode::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::GetChildren()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::GetShape()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::GetRoot()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::GetDiagram()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNode::GetLayout()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void DiagramNode::SetLayout(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


LPDISPATCH DiagramNode::GetTextShape()
{
LPDISPATCH result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::AddNode(long Pos, long NodeType)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Pos, NodeType);
return result;
}


void DiagramNode::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DiagramNode::MoveNode(LPDISPATCH* TargetNode, long Pos)
{
static BYTE parms[] =
VTS_PDISPATCH VTS_I4;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
TargetNode, Pos);
}


void DiagramNode::ReplaceNode(LPDISPATCH* TargetNode)
{
static BYTE parms[] =
VTS_PDISPATCH;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
TargetNode);
}


void DiagramNode::SwapNode(LPDISPATCH* TargetNode, long Pos)
{
static BYTE parms[] =
VTS_PDISPATCH VTS_I4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
TargetNode, Pos);
}


LPDISPATCH DiagramNode::CloneNode(BOOL copyChildren, LPDISPATCH* TargetNode, long Pos)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BOOL VTS_PDISPATCH VTS_I4;
InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
copyChildren, TargetNode, Pos);
return result;
}


void DiagramNode::TransferChildren(LPDISPATCH* ReceivingNode)
{
static BYTE parms[] =
VTS_PDISPATCH;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ReceivingNode);
}


LPDISPATCH DiagramNode::NextNode()
{
LPDISPATCH result;
InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNode::PrevNode()
{
LPDISPATCH result;
InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// DiagramNodeChildren properties


/
// DiagramNodeChildren operations


LPDISPATCH DiagramNodeChildren::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNodeChildren::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN DiagramNodeChildren::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodeChildren::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNodeChildren::GetCount()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodeChildren::GetFirstChild()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodeChildren::GetLastChild()
{
LPDISPATCH result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodeChildren::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH DiagramNodeChildren::AddNode(VARIANT* Index, long NodeType)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_I4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index, NodeType);
return result;
}


void DiagramNodeChildren::SelectAll()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// DiagramNodes properties


/
// DiagramNodes operations


LPDISPATCH DiagramNodes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNodes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN DiagramNodes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long DiagramNodes::GetCount()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH DiagramNodes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void DiagramNodes::SelectAll()
{
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Diagram properties


/
// Diagram operations


LPDISPATCH Diagram::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Diagram::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Diagram::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Diagram::GetNodes()
{
LPDISPATCH result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Diagram::GetType()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Diagram::GetAutoLayout()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Diagram::SetAutoLayout(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Diagram::GetReverse()
{
long result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Diagram::SetReverse(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long Diagram::GetAutoFormat()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void Diagram::SetAutoFormat(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


void Diagram::Convert(long Type)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Type);
}


void Diagram::FitText()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// CustomProperty properties


/
// CustomProperty operations


CString CustomProperty::GetName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString CustomProperty::GetValue()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void CustomProperty::SetValue(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


LPDISPATCH CustomProperty::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CustomProperty::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomProperty::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void CustomProperty::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// CustomProperties properties


/
// CustomProperties operations


LPUNKNOWN CustomProperties::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long CustomProperties::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomProperties::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CustomProperties::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomProperties::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH CustomProperties::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH CustomProperties::Add(LPCTSTR Name, LPCTSTR Value)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Value);
return result;
}




/
// SmartTag properties


/
// SmartTag operations


CString SmartTag::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString SmartTag::GetXml()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTag::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString SmartTag::GetDownloadURL()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTag::GetProperties()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTag::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTag::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTag::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void SmartTag::Select()
{
InvokeHelper(0xffff, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void SmartTag::Delete()
{
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH SmartTag::GetSmartTagActions()
{
LPDISPATCH result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTag::GetXMLNode()
{
LPDISPATCH result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// SmartTags properties


/
// SmartTags operations


LPUNKNOWN SmartTags::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long SmartTags::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTags::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTags::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTags::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTags::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH SmartTags::Add(LPCTSTR Name, VARIANT* Range, VARIANT* Properties)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Range, Properties);
return result;
}


LPDISPATCH SmartTags::SmartTagsByType(LPCTSTR Name)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name);
return result;
}




/
// StyleSheet properties


/
// StyleSheet operations


LPDISPATCH StyleSheet::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long StyleSheet::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH StyleSheet::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString StyleSheet::GetFullName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long StyleSheet::GetIndex()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString StyleSheet::GetName()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString StyleSheet::GetPath()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long StyleSheet::GetType()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void StyleSheet::SetType(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


CString StyleSheet::GetTitle()
{
CString result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void StyleSheet::SetTitle(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void StyleSheet::Move(long Precedence)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Precedence);
}


void StyleSheet::Delete()
{
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// StyleSheets properties


/
// StyleSheets operations


LPDISPATCH StyleSheets::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long StyleSheets::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH StyleSheets::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPUNKNOWN StyleSheets::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long StyleSheets::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH StyleSheets::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH StyleSheets::Add(LPCTSTR FileName, long LinkType, LPCTSTR Title, long Precedence)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_I4 VTS_BSTR VTS_I4;
InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, LinkType, Title, Precedence);
return result;
}




/
// MappedDataField properties


/
// MappedDataField operations


LPDISPATCH MappedDataField::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MappedDataField::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MappedDataField::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MappedDataField::GetIndex()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


CString MappedDataField::GetDataFieldName()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString MappedDataField::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString MappedDataField::GetValue()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


long MappedDataField::GetDataFieldIndex()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void MappedDataField::SetDataFieldIndex(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// MappedDataFields properties


/
// MappedDataFields operations


LPDISPATCH MappedDataFields::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MappedDataFields::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH MappedDataFields::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long MappedDataFields::GetCount()
{
long result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN MappedDataFields::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH MappedDataFields::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// CanvasShapes properties


/
// CanvasShapes operations


LPDISPATCH CanvasShapes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x1f40, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CanvasShapes::GetCreator()
{
long result;
InvokeHelper(0x1f41, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH CanvasShapes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long CanvasShapes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPUNKNOWN CanvasShapes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH CanvasShapes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH CanvasShapes::AddCallout(long Type, float Left, float Top, float Width, float Height)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, Left, Top, Width, Height);
return result;
}


LPDISPATCH CanvasShapes::AddConnector(long Type, float BeginX, float BeginY, float EndX, float EndY)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, BeginX, BeginY, EndX, EndY);
return result;
}


LPDISPATCH CanvasShapes::AddCurve(VARIANT* SafeArrayOfPoints)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
SafeArrayOfPoints);
return result;
}


LPDISPATCH CanvasShapes::AddLabel(long Orientation, float Left, float Top, float Width, float Height)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Orientation, Left, Top, Width, Height);
return result;
}


LPDISPATCH CanvasShapes::AddLine(float BeginX, float BeginY, float EndX, float EndY)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
BeginX, BeginY, EndX, EndY);
return result;
}


LPDISPATCH CanvasShapes::AddPicture(LPCTSTR FileName, VARIANT* LinkToFile, VARIANT* SaveWithDocument, VARIANT* Left, VARIANT* Top, VARIANT* Width, VARIANT* Height)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
FileName, LinkToFile, SaveWithDocument, Left, Top, Width, Height);
return result;
}


LPDISPATCH CanvasShapes::AddPolyline(VARIANT* SafeArrayOfPoints)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
SafeArrayOfPoints);
return result;
}


LPDISPATCH CanvasShapes::AddShape(long Type, float Left, float Top, float Width, float Height)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Type, Left, Top, Width, Height);
return result;
}


LPDISPATCH CanvasShapes::AddTextEffect(long PresetTextEffect, LPCTSTR Text, LPCTSTR FontName, float FontSize, long FontBold, long FontItalic, float Left, float Top)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_BSTR VTS_BSTR VTS_R4 VTS_I4 VTS_I4 VTS_R4 VTS_R4;
InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
PresetTextEffect, Text, FontName, FontSize, FontBold, FontItalic, Left, Top);
return result;
}


LPDISPATCH CanvasShapes::AddTextbox(long Orientation, float Left, float Top, float Width, float Height)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Orientation, Left, Top, Width, Height);
return result;
}


LPDISPATCH CanvasShapes::BuildFreeform(long EditingType, float X1, float Y1)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4 VTS_R4 VTS_R4;
InvokeHelper(0x14, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
EditingType, X1, Y1);
return result;
}


LPDISPATCH CanvasShapes::Range(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void CanvasShapes::SelectAll()
{
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// TableStyle properties


/
// TableStyle operations


LPDISPATCH TableStyle::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableStyle::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TableStyle::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TableStyle::GetAllowPageBreaks()
{
BOOL result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TableStyle::SetAllowPageBreaks(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH TableStyle::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void TableStyle::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TableStyle::GetBottomPadding()
{
float result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetBottomPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TableStyle::GetLeftPadding()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetLeftPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TableStyle::GetTopPadding()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetTopPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float TableStyle::GetRightPadding()
{
float result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetRightPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


long TableStyle::GetAlignment()
{
long result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableStyle::SetAlignment(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float TableStyle::GetSpacing()
{
float result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetSpacing(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH TableStyle::Condition(long ConditionCode)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
ConditionCode);
return result;
}


long TableStyle::GetTableDirection()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableStyle::SetTableDirection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TableStyle::GetAllowBreakAcrossPage()
{
long result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableStyle::SetAllowBreakAcrossPage(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


float TableStyle::GetLeftIndent()
{
float result;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void TableStyle::SetLeftIndent(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH TableStyle::GetShading()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TableStyle::GetRowStripe()
{
long result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableStyle::SetRowStripe(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long TableStyle::GetColumnStripe()
{
long result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void TableStyle::SetColumnStripe(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// ConditionalStyle properties


/
// ConditionalStyle operations


LPDISPATCH ConditionalStyle::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long ConditionalStyle::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH ConditionalStyle::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ConditionalStyle::GetShading()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH ConditionalStyle::GetBorders()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetBorders(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ConditionalStyle::GetBottomPadding()
{
float result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetBottomPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ConditionalStyle::GetTopPadding()
{
float result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetTopPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ConditionalStyle::GetLeftPadding()
{
float result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetLeftPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


float ConditionalStyle::GetRightPadding()
{
float result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetRightPadding(float newValue)
{
static BYTE parms[] =
VTS_R4;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ConditionalStyle::GetParagraphFormat()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetParagraphFormat(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}


LPDISPATCH ConditionalStyle::GetFont()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void ConditionalStyle::SetFont(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}




/
// FootnoteOptions properties


/
// FootnoteOptions operations


LPDISPATCH FootnoteOptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FootnoteOptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH FootnoteOptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long FootnoteOptions::GetLocation()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FootnoteOptions::SetLocation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long FootnoteOptions::GetNumberStyle()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FootnoteOptions::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long FootnoteOptions::GetStartingNumber()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FootnoteOptions::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long FootnoteOptions::GetNumberingRule()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void FootnoteOptions::SetNumberingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// EndnoteOptions properties


/
// EndnoteOptions operations


LPDISPATCH EndnoteOptions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EndnoteOptions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH EndnoteOptions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long EndnoteOptions::GetLocation()
{
long result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void EndnoteOptions::SetLocation(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long EndnoteOptions::GetNumberStyle()
{
long result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void EndnoteOptions::SetNumberStyle(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long EndnoteOptions::GetStartingNumber()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void EndnoteOptions::SetStartingNumber(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long EndnoteOptions::GetNumberingRule()
{
long result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void EndnoteOptions::SetNumberingRule(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}




/
// Reviewers properties


/
// Reviewers operations


LPUNKNOWN Reviewers::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


LPDISPATCH Reviewers::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Reviewers::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Reviewers::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Reviewers::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Reviewers::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Reviewer properties


/
// Reviewer operations


LPDISPATCH Reviewer::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Reviewer::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Reviewer::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL Reviewer::GetVisible()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void Reviewer::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// TaskPane properties


/
// TaskPane operations


LPDISPATCH TaskPane::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TaskPane::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TaskPane::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL TaskPane::GetVisible()
{
BOOL result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void TaskPane::SetVisible(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}




/
// TaskPanes properties


/
// TaskPanes operations


LPUNKNOWN TaskPanes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long TaskPanes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TaskPanes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long TaskPanes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH TaskPanes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH TaskPanes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// IApplicationEvents3 properties


/
// IApplicationEvents3 operations


void IApplicationEvents3::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents3::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents3::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents3::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents3::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void IApplicationEvents3::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents3::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents3::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void IApplicationEvents3::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void IApplicationEvents3::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void IApplicationEvents3::EPostagePropertyDialog(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::EPostageInsert(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, DocResult);
}


void IApplicationEvents3::MailMergeAfterRecordMerge(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_PBOOL;
InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, StartRecord, EndRecord, Cancel);
}


void IApplicationEvents3::MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents3::MailMergeDataSourceLoad(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Handled);
}


void IApplicationEvents3::MailMergeWizardSendToCustom(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents3::MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PI4 VTS_PI4 VTS_PBOOL;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, FromState, ToState, Handled);
}


void IApplicationEvents3::WindowSize(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}




/
// ApplicationEvents3 properties


/
// ApplicationEvents3 operations


void ApplicationEvents3::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents3::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents3::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents3::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents3::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void ApplicationEvents3::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents3::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents3::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void ApplicationEvents3::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void ApplicationEvents3::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void ApplicationEvents3::EPostagePropertyDialog(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::EPostageInsert(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, DocResult);
}


void ApplicationEvents3::MailMergeAfterRecordMerge(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_PBOOL;
InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, StartRecord, EndRecord, Cancel);
}


void ApplicationEvents3::MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents3::MailMergeDataSourceLoad(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Handled);
}


void ApplicationEvents3::MailMergeWizardSendToCustom(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents3::MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PI4 VTS_PI4 VTS_PBOOL;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, FromState, ToState, Handled);
}


void ApplicationEvents3::WindowSize(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}




/
// SmartTagAction properties


/
// SmartTagAction operations


CString SmartTagAction::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagAction::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagAction::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagAction::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void SmartTagAction::Execute()
{
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


long SmartTagAction::GetType()
{
long result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


BOOL SmartTagAction::GetPresentInPane()
{
BOOL result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


BOOL SmartTagAction::GetExpandHelp()
{
BOOL result;
InvokeHelper(0x3ee, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetExpandHelp(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3ee, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL SmartTagAction::GetCheckboxState()
{
BOOL result;
InvokeHelper(0x3ef, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetCheckboxState(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3ef, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString SmartTagAction::GetTextboxText()
{
CString result;
InvokeHelper(0x3f0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetTextboxText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3f0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


long SmartTagAction::GetListSelection()
{
long result;
InvokeHelper(0x3f1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetListSelection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3f1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


long SmartTagAction::GetRadioGroupSelection()
{
long result;
InvokeHelper(0x3f2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetRadioGroupSelection(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}


BOOL SmartTagAction::GetExpandDocumentFragment()
{
BOOL result;
InvokeHelper(0x3f3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void SmartTagAction::SetExpandDocumentFragment(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3f3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH SmartTagAction::GetActiveXControl()
{
LPDISPATCH result;
InvokeHelper(0x3f4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// SmartTagActions properties


/
// SmartTagActions operations


LPUNKNOWN SmartTagActions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long SmartTagActions::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagActions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagActions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagActions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagActions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void SmartTagActions::ReloadActions()
{
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// SmartTagRecognizer properties


/
// SmartTagRecognizer operations


CString SmartTagRecognizer::GetFullName()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagRecognizer::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagRecognizer::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagRecognizer::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL SmartTagRecognizer::GetEnabled()
{
BOOL result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void SmartTagRecognizer::SetEnabled(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3eb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


CString SmartTagRecognizer::GetProgID()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString SmartTagRecognizer::GetCaption()
{
CString result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// SmartTagRecognizers properties


/
// SmartTagRecognizers operations


LPUNKNOWN SmartTagRecognizers::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long SmartTagRecognizers::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagRecognizers::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagRecognizers::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagRecognizers::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagRecognizers::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void SmartTagRecognizers::ReloadRecognizers()
{
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// SmartTagType properties


/
// SmartTagType operations


CString SmartTagType::GetName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagType::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagType::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagType::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagType::GetSmartTagActions()
{
LPDISPATCH result;
InvokeHelper(0x3eb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagType::GetSmartTagRecognizers()
{
LPDISPATCH result;
InvokeHelper(0x3ec, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString SmartTagType::GetFriendlyName()
{
CString result;
InvokeHelper(0x3ed, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}




/
// SmartTagTypes properties


/
// SmartTagTypes operations


LPUNKNOWN SmartTagTypes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long SmartTagTypes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagTypes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long SmartTagTypes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagTypes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH SmartTagTypes::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void SmartTagTypes::ReloadAll()
{
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// Line properties


/
// Line operations


LPDISPATCH Line::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Line::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Line::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Line::GetLineType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Line::GetLeft()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Line::GetTop()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Line::GetWidth()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Line::GetHeight()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Line::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Line::GetRectangles()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Lines properties


/
// Lines operations


LPUNKNOWN Lines::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Lines::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Lines::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Lines::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Lines::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Lines::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Rectangle properties


/
// Rectangle operations


LPDISPATCH Rectangle::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Rectangle::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangle::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Rectangle::GetRectangleType()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rectangle::GetLeft()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rectangle::GetTop()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rectangle::GetWidth()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Rectangle::GetHeight()
{
long result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangle::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangle::GetLines()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Rectangles properties


/
// Rectangles operations


LPUNKNOWN Rectangles::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Rectangles::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangles::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Rectangles::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangles::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Rectangles::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Break properties


/
// Break operations


LPDISPATCH Break::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Break::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Break::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Break::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Break::GetPageIndex()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}




/
// Breaks properties


/
// Breaks operations


LPUNKNOWN Breaks::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Breaks::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Breaks::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Breaks::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Breaks::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Breaks::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// Page properties


/
// Page operations


LPDISPATCH Page::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Page::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Page::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Page::GetLeft()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Page::GetTop()
{
long result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Page::GetWidth()
{
long result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long Page::GetHeight()
{
long result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Page::GetRectangles()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Page::GetBreaks()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}




/
// Pages properties


/
// Pages operations


LPUNKNOWN Pages::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long Pages::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Pages::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Pages::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Pages::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Pages::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// XMLNode properties


/
// XMLNode operations


CString XMLNode::GetBaseName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNode::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLNode::GetText()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void XMLNode::SetText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


CString XMLNode::GetNamespaceURI()
{
CString result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString XMLNode::GetXml(BOOL DataOnly)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
DataOnly);
return result;
}


LPDISPATCH XMLNode::GetNextSibling()
{
LPDISPATCH result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetPreviousSibling()
{
LPDISPATCH result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetParentNode()
{
LPDISPATCH result;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetFirstChild()
{
LPDISPATCH result;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetLastChild()
{
LPDISPATCH result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetOwnerDocument()
{
LPDISPATCH result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNode::GetNodeType()
{
long result;
InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetChildNodes()
{
LPDISPATCH result;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetAttributes()
{
LPDISPATCH result;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLNode::GetNodeValue()
{
CString result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void XMLNode::SetNodeValue(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


BOOL XMLNode::GetHasChildNodes()
{
BOOL result;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::SelectSingleNode(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BOOL;
InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
XPath, PrefixMapping, FastSearchSkippingTextNodes);
return result;
}


LPDISPATCH XMLNode::SelectNodes(LPCTSTR XPath, LPCTSTR PrefixMapping, BOOL FastSearchSkippingTextNodes)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_BOOL;
InvokeHelper(0x13, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
XPath, PrefixMapping, FastSearchSkippingTextNodes);
return result;
}


LPDISPATCH XMLNode::GetChildNodeSuggestions()
{
LPDISPATCH result;
InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNode::GetLevel()
{
long result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


long XMLNode::GetValidationStatus()
{
long result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNode::GetSmartTag()
{
LPDISPATCH result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLNode::GetValidationErrorText(BOOL Advanced)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
Advanced);
return result;
}


CString XMLNode::GetPlaceholderText()
{
CString result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void XMLNode::SetPlaceholderText(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}


void XMLNode::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void XMLNode::Copy()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void XMLNode::RemoveChild(LPDISPATCH ChildElement)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
ChildElement);
}


void XMLNode::Cut()
{
InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void XMLNode::Validate()
{
InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void XMLNode::SetValidationError(long Status, VARIANT* ErrorText, BOOL ClearedAutomatically)
{
static BYTE parms[] =
VTS_I4 VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Status, ErrorText, ClearedAutomatically);
}




/
// XMLNodes properties


/
// XMLNodes operations


LPUNKNOWN XMLNodes::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long XMLNodes::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNodes::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNodes::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNodes::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNodes::Item(long Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH XMLNodes::Add(LPCTSTR Name, LPCTSTR Namespace, VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_BSTR VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Name, Namespace, Range);
return result;
}




/
// XMLSchemaReference properties


/
// XMLSchemaReference operations


LPDISPATCH XMLSchemaReference::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLSchemaReference::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLSchemaReference::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLSchemaReference::GetNamespaceURI()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString XMLSchemaReference::GetLocation()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


void XMLSchemaReference::Delete()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void XMLSchemaReference::Reload()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// XMLSchemaReferences properties


/
// XMLSchemaReferences operations


LPUNKNOWN XMLSchemaReferences::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long XMLSchemaReferences::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLSchemaReferences::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLSchemaReferences::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLSchemaReferences::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


BOOL XMLSchemaReferences::GetAutomaticValidation()
{
BOOL result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void XMLSchemaReferences::SetAutomaticValidation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL XMLSchemaReferences::GetAllowSaveAsXMLWithoutValidation()
{
BOOL result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void XMLSchemaReferences::SetAllowSaveAsXMLWithoutValidation(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL XMLSchemaReferences::GetHideValidationErrors()
{
BOOL result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void XMLSchemaReferences::SetHideValidationErrors(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL XMLSchemaReferences::GetIgnoreMixedContent()
{
BOOL result;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void XMLSchemaReferences::SetIgnoreMixedContent(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


BOOL XMLSchemaReferences::GetShowPlaceholderText()
{
BOOL result;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}


void XMLSchemaReferences::SetShowPlaceholderText(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}


LPDISPATCH XMLSchemaReferences::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


void XMLSchemaReferences::Validate()
{
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


LPDISPATCH XMLSchemaReferences::Add(VARIANT* NamespaceURI, VARIANT* Alias, VARIANT* FileName, BOOL InstallForAllUsers)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
NamespaceURI, Alias, FileName, InstallForAllUsers);
return result;
}




/
// XMLChildNodeSuggestion properties


/
// XMLChildNodeSuggestion operations


LPDISPATCH XMLChildNodeSuggestion::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLChildNodeSuggestion::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestion::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLChildNodeSuggestion::GetBaseName()
{
CString result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString XMLChildNodeSuggestion::GetNamespaceURI()
{
CString result;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestion::GetXMLSchemaReference()
{
LPDISPATCH result;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestion::Insert(VARIANT* Range)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Range);
return result;
}




/
// XMLChildNodeSuggestions properties


/
// XMLChildNodeSuggestions operations


LPUNKNOWN XMLChildNodeSuggestions::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long XMLChildNodeSuggestions::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestions::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLChildNodeSuggestions::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestions::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLChildNodeSuggestions::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}




/
// XMLNamespace properties


/
// XMLNamespace operations


LPDISPATCH XMLNamespace::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNamespace::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNamespace::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XMLNamespace::GetUri()
{
CString result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString XMLNamespace::GetLocation(BOOL AllUsers)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
AllUsers);
return result;
}


void XMLNamespace::SetLocation(BOOL AllUsers, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BOOL VTS_BSTR;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
AllUsers, lpszNewValue);
}


CString XMLNamespace::GetAlias(BOOL AllUsers)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
AllUsers);
return result;
}


void XMLNamespace::SetAlias(BOOL AllUsers, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BOOL VTS_BSTR;
InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
AllUsers, lpszNewValue);
}


LPDISPATCH XMLNamespace::GetXSLTransforms()
{
LPDISPATCH result;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNamespace::GetDefaultTransform(BOOL AllUsers)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
AllUsers);
return result;
}


void XMLNamespace::SetDefaultTransform(BOOL AllUsers, LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_BOOL VTS_DISPATCH;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
AllUsers, newValue);
}


void XMLNamespace::AttachToDocument(VARIANT* Document)
{
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x64, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Document);
}


void XMLNamespace::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// XMLNamespaces properties


/
// XMLNamespaces operations


LPUNKNOWN XMLNamespaces::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long XMLNamespaces::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNamespaces::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XMLNamespaces::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNamespaces::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XMLNamespaces::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH XMLNamespaces::Add(LPCTSTR Path, VARIANT* NamespaceURI, VARIANT* Alias, BOOL InstallForAllUsers)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Path, NamespaceURI, Alias, InstallForAllUsers);
return result;
}


void XMLNamespaces::InstallManifest(LPCTSTR Path, BOOL InstallForAllUsers)
{
static BYTE parms[] =
VTS_BSTR VTS_BOOL;
InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Path, InstallForAllUsers);
}




/
// XSLTransform properties


/
// XSLTransform operations


LPDISPATCH XSLTransform::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XSLTransform::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XSLTransform::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


CString XSLTransform::GetAlias(BOOL AllUsers)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
AllUsers);
return result;
}


void XSLTransform::SetAlias(BOOL AllUsers, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BOOL VTS_BSTR;
InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
AllUsers, lpszNewValue);
}


CString XSLTransform::GetLocation(BOOL AllUsers)
{
CString result;
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
AllUsers);
return result;
}


void XSLTransform::SetLocation(BOOL AllUsers, LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BOOL VTS_BSTR;
InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
AllUsers, lpszNewValue);
}


void XSLTransform::Delete()
{
InvokeHelper(0x65, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// XSLTransforms properties


/
// XSLTransforms operations


LPUNKNOWN XSLTransforms::Get_NewEnum()
{
LPUNKNOWN result;
InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
return result;
}


long XSLTransforms::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XSLTransforms::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long XSLTransforms::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH XSLTransforms::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH XSLTransforms::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH XSLTransforms::Add(LPCTSTR Location, VARIANT* Alias, BOOL InstallForAllUsers)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_BSTR VTS_PVARIANT VTS_BOOL;
InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Location, Alias, InstallForAllUsers);
return result;
}




/
// Editors properties


/
// Editors operations


LPDISPATCH Editors::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Editors::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Editors::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Editors::GetCount()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Editors::Item(VARIANT* Index)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
Index);
return result;
}


LPDISPATCH Editors::Add(VARIANT* EditorID)
{
LPDISPATCH result;
static BYTE parms[] =
VTS_PVARIANT;
InvokeHelper(0x1f5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
EditorID);
return result;
}




/
// Editor properties


/
// Editor operations


CString Editor::GetId()
{
CString result;
InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


CString Editor::GetName()
{
CString result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}


LPDISPATCH Editor::GetRange()
{
LPDISPATCH result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Editor::GetNextRange()
{
LPDISPATCH result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


LPDISPATCH Editor::GetApplication()
{
LPDISPATCH result;
InvokeHelper(0x3e8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


long Editor::GetCreator()
{
long result;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}


LPDISPATCH Editor::GetParent()
{
LPDISPATCH result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
return result;
}


void Editor::Delete()
{
InvokeHelper(0x1f4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Editor::DeleteAll()
{
InvokeHelper(0x1f5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void Editor::SelectAll()
{
InvokeHelper(0x1f6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}




/
// IApplicationEvents4 properties


/
// IApplicationEvents4 operations


void IApplicationEvents4::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents4::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void IApplicationEvents4::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents4::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents4::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void IApplicationEvents4::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents4::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents4::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void IApplicationEvents4::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void IApplicationEvents4::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void IApplicationEvents4::EPostagePropertyDialog(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::EPostageInsert(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, DocResult);
}


void IApplicationEvents4::MailMergeAfterRecordMerge(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_PBOOL;
InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, StartRecord, EndRecord, Cancel);
}


void IApplicationEvents4::MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void IApplicationEvents4::MailMergeDataSourceLoad(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Handled);
}


void IApplicationEvents4::MailMergeWizardSendToCustom(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void IApplicationEvents4::MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PI4 VTS_PI4 VTS_PBOOL;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, FromState, ToState, Handled);
}


void IApplicationEvents4::WindowSize(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void IApplicationEvents4::XMLSelectionChange(LPDISPATCH Sel, LPDISPATCH OldXMLNode, LPDISPATCH NewXMLNode, long* Reason)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_PI4;
InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, OldXMLNode, NewXMLNode, Reason);
}


void IApplicationEvents4::XMLValidationError(LPDISPATCH XMLNode)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
XMLNode);
}


void IApplicationEvents4::DocumentSync(LPDISPATCH Doc, long SyncEventType)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4;
InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SyncEventType);
}


void IApplicationEvents4::EPostageInsertEx(LPDISPATCH Doc, long cpDeliveryAddrStart, long cpDeliveryAddrEnd, long cpReturnAddrStart, long cpReturnAddrEnd, long xaWidth, long yaHeight, LPCTSTR bstrPrinterName, LPCTSTR bstrPaperFeed, BOOL fPrint, BOOL* fCancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR VTS_BOOL VTS_PBOOL;
InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, cpDeliveryAddrStart, cpDeliveryAddrEnd, cpReturnAddrStart, cpReturnAddrEnd, xaWidth, yaHeight, bstrPrinterName, bstrPaperFeed, fPrint, fCancel);
}




/
// ApplicationEvents4 properties


/
// ApplicationEvents4 operations


void ApplicationEvents4::Quit()
{
InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents4::DocumentChange()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void ApplicationEvents4::DocumentOpen(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::DocumentBeforeClose(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents4::DocumentBeforePrint(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents4::DocumentBeforeSave(LPDISPATCH Doc, BOOL* SaveAsUI, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL VTS_PBOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SaveAsUI, Cancel);
}


void ApplicationEvents4::NewDocument(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::WindowActivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents4::WindowDeactivate(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents4::WindowSelectionChange(LPDISPATCH Sel)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel);
}


void ApplicationEvents4::WindowBeforeRightClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void ApplicationEvents4::WindowBeforeDoubleClick(LPDISPATCH Sel, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, Cancel);
}


void ApplicationEvents4::EPostagePropertyDialog(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::EPostageInsert(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::MailMergeAfterMerge(LPDISPATCH Doc, LPDISPATCH DocResult)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, DocResult);
}


void ApplicationEvents4::MailMergeAfterRecordMerge(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::MailMergeBeforeMerge(LPDISPATCH Doc, long StartRecord, long EndRecord, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_PBOOL;
InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, StartRecord, EndRecord, Cancel);
}


void ApplicationEvents4::MailMergeBeforeRecordMerge(LPDISPATCH Doc, BOOL* Cancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Cancel);
}


void ApplicationEvents4::MailMergeDataSourceLoad(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::MailMergeDataSourceValidate(LPDISPATCH Doc, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PBOOL;
InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Handled);
}


void ApplicationEvents4::MailMergeWizardSendToCustom(LPDISPATCH Doc)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc);
}


void ApplicationEvents4::MailMergeWizardStateChange(LPDISPATCH Doc, long* FromState, long* ToState, BOOL* Handled)
{
static BYTE parms[] =
VTS_DISPATCH VTS_PI4 VTS_PI4 VTS_PBOOL;
InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, FromState, ToState, Handled);
}


void ApplicationEvents4::WindowSize(LPDISPATCH Doc, LPDISPATCH Wn)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH;
InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, Wn);
}


void ApplicationEvents4::XMLSelectionChange(LPDISPATCH Sel, LPDISPATCH OldXMLNode, LPDISPATCH NewXMLNode, long* Reason)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_PI4;
InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Sel, OldXMLNode, NewXMLNode, Reason);
}


void ApplicationEvents4::XMLValidationError(LPDISPATCH XMLNode)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
XMLNode);
}


void ApplicationEvents4::DocumentSync(LPDISPATCH Doc, long SyncEventType)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4;
InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, SyncEventType);
}


void ApplicationEvents4::EPostageInsertEx(LPDISPATCH Doc, long cpDeliveryAddrStart, long cpDeliveryAddrEnd, long cpReturnAddrStart, long cpReturnAddrEnd, long xaWidth, long yaHeight, LPCTSTR bstrPrinterName, LPCTSTR bstrPaperFeed, BOOL fPrint, BOOL* fCancel)
{
static BYTE parms[] =
VTS_DISPATCH VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR VTS_BOOL VTS_PBOOL;
InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
Doc, cpDeliveryAddrStart, cpDeliveryAddrEnd, cpReturnAddrStart, cpReturnAddrEnd, xaWidth, yaHeight, bstrPrinterName, bstrPaperFeed, fPrint, fCancel);
}




/
// DocumentEvents2 properties


/
// DocumentEvents2 operations


void DocumentEvents2::New()
{
InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DocumentEvents2::Open()
{
InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DocumentEvents2::Close()
{
InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


void DocumentEvents2::Sync(long SyncEventType)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
SyncEventType);
}


void DocumentEvents2::XMLAfterInsert(LPDISPATCH NewXMLNode, BOOL InUndoRedo)
{
static BYTE parms[] =
VTS_DISPATCH VTS_BOOL;
InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
NewXMLNode, InUndoRedo);
}


void DocumentEvents2::XMLBeforeDelete(LPDISPATCH DeletedRange, LPDISPATCH OldXMLNode, BOOL InUndoRedo)
{
static BYTE parms[] =
VTS_DISPATCH VTS_DISPATCH VTS_BOOL;
InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
DeletedRange, OldXMLNode, InUndoRedo);
}