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

#include "stdafx.h"
#include "excel11.h"

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



/////////////////////////////////////////////////////////////////////////////
// Application properties

VARIANT Application::GetActiveCell()
{
	VARIANT result;
	GetProperty(0x131, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveCell(const VARIANT& propVal)
{
	SetProperty(0x131, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveChart()
{
	VARIANT result;
	GetProperty(0xb7, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveChart(const VARIANT& propVal)
{
	SetProperty(0xb7, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveDialog()
{
	VARIANT result;
	GetProperty(0x32f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveDialog(const VARIANT& propVal)
{
	SetProperty(0x32f, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveMenuBar()
{
	VARIANT result;
	GetProperty(0x2f6, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveMenuBar(const VARIANT& propVal)
{
	SetProperty(0x2f6, VT_VARIANT, &propVal);
}

VARIANT Application::GetActivePrinter()
{
	VARIANT result;
	GetProperty(0x132, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActivePrinter(const VARIANT& propVal)
{
	SetProperty(0x132, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveSheet()
{
	VARIANT result;
	GetProperty(0x133, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveSheet(const VARIANT& propVal)
{
	SetProperty(0x133, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveWindow()
{
	VARIANT result;
	GetProperty(0x2f7, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveWindow(const VARIANT& propVal)
{
	SetProperty(0x2f7, VT_VARIANT, &propVal);
}

VARIANT Application::GetActiveWorkbook()
{
	VARIANT result;
	GetProperty(0x134, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetActiveWorkbook(const VARIANT& propVal)
{
	SetProperty(0x134, VT_VARIANT, &propVal);
}

VARIANT Application::GetAlertBeforeOverwriting()
{
	VARIANT result;
	GetProperty(0x3a2, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetAlertBeforeOverwriting(const VARIANT& propVal)
{
	SetProperty(0x3a2, VT_VARIANT, &propVal);
}

VARIANT Application::GetAltStartupPath()
{
	VARIANT result;
	GetProperty(0x139, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetAltStartupPath(const VARIANT& propVal)
{
	SetProperty(0x139, VT_VARIANT, &propVal);
}

VARIANT Application::GetAskToUpdateLinks()
{
	VARIANT result;
	GetProperty(0x3e0, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetAskToUpdateLinks(const VARIANT& propVal)
{
	SetProperty(0x3e0, VT_VARIANT, &propVal);
}

VARIANT Application::GetAutoCorrect()
{
	VARIANT result;
	GetProperty(0x479, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetAutoCorrect(const VARIANT& propVal)
{
	SetProperty(0x479, VT_VARIANT, &propVal);
}

VARIANT Application::GetBuild()
{
	VARIANT result;
	GetProperty(0x13a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetBuild(const VARIANT& propVal)
{
	SetProperty(0x13a, VT_VARIANT, &propVal);
}

VARIANT Application::GetCalculateBeforeSave()
{
	VARIANT result;
	GetProperty(0x13b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCalculateBeforeSave(const VARIANT& propVal)
{
	SetProperty(0x13b, VT_VARIANT, &propVal);
}

VARIANT Application::GetCalculation()
{
	VARIANT result;
	GetProperty(0x13c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCalculation(const VARIANT& propVal)
{
	SetProperty(0x13c, VT_VARIANT, &propVal);
}

VARIANT Application::GetCaller()
{
	VARIANT result;
	GetProperty(0x13d, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCaller(const VARIANT& propVal)
{
	SetProperty(0x13d, VT_VARIANT, &propVal);
}

VARIANT Application::GetCanPlaySounds()
{
	VARIANT result;
	GetProperty(0x13e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCanPlaySounds(const VARIANT& propVal)
{
	SetProperty(0x13e, VT_VARIANT, &propVal);
}

VARIANT Application::GetCanRecordSounds()
{
	VARIANT result;
	GetProperty(0x13f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCanRecordSounds(const VARIANT& propVal)
{
	SetProperty(0x13f, VT_VARIANT, &propVal);
}

VARIANT Application::GetCaption()
{
	VARIANT result;
	GetProperty(0x8b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCaption(const VARIANT& propVal)
{
	SetProperty(0x8b, VT_VARIANT, &propVal);
}

VARIANT Application::GetCellDragAndDrop()
{
	VARIANT result;
	GetProperty(0x140, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCellDragAndDrop(const VARIANT& propVal)
{
	SetProperty(0x140, VT_VARIANT, &propVal);
}

VARIANT Application::GetClipboardFormats()
{
	VARIANT result;
	GetProperty(0x141, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetClipboardFormats(const VARIANT& propVal)
{
	SetProperty(0x141, VT_VARIANT, &propVal);
}

VARIANT Application::GetColorButtons()
{
	VARIANT result;
	GetProperty(0x16d, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetColorButtons(const VARIANT& propVal)
{
	SetProperty(0x16d, VT_VARIANT, &propVal);
}

VARIANT Application::GetCommandUnderlines()
{
	VARIANT result;
	GetProperty(0x143, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCommandUnderlines(const VARIANT& propVal)
{
	SetProperty(0x143, VT_VARIANT, &propVal);
}

VARIANT Application::GetConstrainNumeric()
{
	VARIANT result;
	GetProperty(0x144, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetConstrainNumeric(const VARIANT& propVal)
{
	SetProperty(0x144, VT_VARIANT, &propVal);
}

VARIANT Application::GetCopyObjectsWithCells()
{
	VARIANT result;
	GetProperty(0x3df, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCopyObjectsWithCells(const VARIANT& propVal)
{
	SetProperty(0x3df, VT_VARIANT, &propVal);
}

VARIANT Application::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Application::GetCursor()
{
	VARIANT result;
	GetProperty(0x489, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCursor(const VARIANT& propVal)
{
	SetProperty(0x489, VT_VARIANT, &propVal);
}

VARIANT Application::GetCustomListCount()
{
	VARIANT result;
	GetProperty(0x313, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCustomListCount(const VARIANT& propVal)
{
	SetProperty(0x313, VT_VARIANT, &propVal);
}

VARIANT Application::GetCutCopyMode()
{
	VARIANT result;
	GetProperty(0x14a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetCutCopyMode(const VARIANT& propVal)
{
	SetProperty(0x14a, VT_VARIANT, &propVal);
}

VARIANT Application::GetDataEntryMode()
{
	VARIANT result;
	GetProperty(0x14b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDataEntryMode(const VARIANT& propVal)
{
	SetProperty(0x14b, VT_VARIANT, &propVal);
}

VARIANT Application::GetDDEAppReturnCode()
{
	VARIANT result;
	GetProperty(0x14c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDDEAppReturnCode(const VARIANT& propVal)
{
	SetProperty(0x14c, VT_VARIANT, &propVal);
}

VARIANT Application::GetDefaultFilePath()
{
	VARIANT result;
	GetProperty(0x40e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDefaultFilePath(const VARIANT& propVal)
{
	SetProperty(0x40e, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayAlerts()
{
	VARIANT result;
	GetProperty(0x157, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayAlerts(const VARIANT& propVal)
{
	SetProperty(0x157, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayClipboardWindow()
{
	VARIANT result;
	GetProperty(0x142, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayClipboardWindow(const VARIANT& propVal)
{
	SetProperty(0x142, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayExcel4Menus()
{
	VARIANT result;
	GetProperty(0x39f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayExcel4Menus(const VARIANT& propVal)
{
	SetProperty(0x39f, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayFormulaBar()
{
	VARIANT result;
	GetProperty(0x158, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayFormulaBar(const VARIANT& propVal)
{
	SetProperty(0x158, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayFullScreen()
{
	VARIANT result;
	GetProperty(0x425, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayFullScreen(const VARIANT& propVal)
{
	SetProperty(0x425, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayInfoWindow()
{
	VARIANT result;
	GetProperty(0x2fd, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayInfoWindow(const VARIANT& propVal)
{
	SetProperty(0x2fd, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayNoteIndicator()
{
	VARIANT result;
	GetProperty(0x159, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayNoteIndicator(const VARIANT& propVal)
{
	SetProperty(0x159, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayRecentFiles()
{
	VARIANT result;
	GetProperty(0x39e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayRecentFiles(const VARIANT& propVal)
{
	SetProperty(0x39e, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayScrollBars()
{
	VARIANT result;
	GetProperty(0x15a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayScrollBars(const VARIANT& propVal)
{
	SetProperty(0x15a, VT_VARIANT, &propVal);
}

VARIANT Application::GetDisplayStatusBar()
{
	VARIANT result;
	GetProperty(0x15b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetDisplayStatusBar(const VARIANT& propVal)
{
	SetProperty(0x15b, VT_VARIANT, &propVal);
}

VARIANT Application::GetEditDirectlyInCell()
{
	VARIANT result;
	GetProperty(0x3a1, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetEditDirectlyInCell(const VARIANT& propVal)
{
	SetProperty(0x3a1, VT_VARIANT, &propVal);
}

VARIANT Application::GetEnableAnimations()
{
	VARIANT result;
	GetProperty(0x49c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetEnableAnimations(const VARIANT& propVal)
{
	SetProperty(0x49c, VT_VARIANT, &propVal);
}

VARIANT Application::GetEnableAutoComplete()
{
	VARIANT result;
	GetProperty(0x49b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetEnableAutoComplete(const VARIANT& propVal)
{
	SetProperty(0x49b, VT_VARIANT, &propVal);
}

VARIANT Application::GetEnableCancelKey()
{
	VARIANT result;
	GetProperty(0x448, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetEnableCancelKey(const VARIANT& propVal)
{
	SetProperty(0x448, VT_VARIANT, &propVal);
}

VARIANT Application::GetEnableTipWizard()
{
	VARIANT result;
	GetProperty(0x428, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetEnableTipWizard(const VARIANT& propVal)
{
	SetProperty(0x428, VT_VARIANT, &propVal);
}

VARIANT Application::GetFileConverters()
{
	VARIANT result;
	GetProperty(0x3a3, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetFileConverters(const VARIANT& propVal)
{
	SetProperty(0x3a3, VT_VARIANT, &propVal);
}

VARIANT Application::GetFixedDecimal()
{
	VARIANT result;
	GetProperty(0x15f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetFixedDecimal(const VARIANT& propVal)
{
	SetProperty(0x15f, VT_VARIANT, &propVal);
}

VARIANT Application::GetFixedDecimalPlaces()
{
	VARIANT result;
	GetProperty(0x160, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetFixedDecimalPlaces(const VARIANT& propVal)
{
	SetProperty(0x160, VT_VARIANT, &propVal);
}

VARIANT Application::GetHeight()
{
	VARIANT result;
	GetProperty(0x7b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetHeight(const VARIANT& propVal)
{
	SetProperty(0x7b, VT_VARIANT, &propVal);
}

VARIANT Application::GetIgnoreRemoteRequests()
{
	VARIANT result;
	GetProperty(0x164, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetIgnoreRemoteRequests(const VARIANT& propVal)
{
	SetProperty(0x164, VT_VARIANT, &propVal);
}

VARIANT Application::GetInteractive()
{
	VARIANT result;
	GetProperty(0x169, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetInteractive(const VARIANT& propVal)
{
	SetProperty(0x169, VT_VARIANT, &propVal);
}

VARIANT Application::GetInternational()
{
	VARIANT result;
	GetProperty(0x16a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetInternational(const VARIANT& propVal)
{
	SetProperty(0x16a, VT_VARIANT, &propVal);
}

VARIANT Application::GetIteration()
{
	VARIANT result;
	GetProperty(0x16b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetIteration(const VARIANT& propVal)
{
	SetProperty(0x16b, VT_VARIANT, &propVal);
}

VARIANT Application::GetLargeButtons()
{
	VARIANT result;
	GetProperty(0x16c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetLargeButtons(const VARIANT& propVal)
{
	SetProperty(0x16c, VT_VARIANT, &propVal);
}

VARIANT Application::GetLeft()
{
	VARIANT result;
	GetProperty(0x7f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetLeft(const VARIANT& propVal)
{
	SetProperty(0x7f, VT_VARIANT, &propVal);
}

VARIANT Application::GetLibraryPath()
{
	VARIANT result;
	GetProperty(0x16e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetLibraryPath(const VARIANT& propVal)
{
	SetProperty(0x16e, VT_VARIANT, &propVal);
}

VARIANT Application::GetMailSession()
{
	VARIANT result;
	GetProperty(0x3ae, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMailSession(const VARIANT& propVal)
{
	SetProperty(0x3ae, VT_VARIANT, &propVal);
}

VARIANT Application::GetMailSystem()
{
	VARIANT result;
	GetProperty(0x3cb, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMailSystem(const VARIANT& propVal)
{
	SetProperty(0x3cb, VT_VARIANT, &propVal);
}

VARIANT Application::GetMathCoprocessorAvailable()
{
	VARIANT result;
	GetProperty(0x16f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMathCoprocessorAvailable(const VARIANT& propVal)
{
	SetProperty(0x16f, VT_VARIANT, &propVal);
}

VARIANT Application::GetMaxChange()
{
	VARIANT result;
	GetProperty(0x170, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMaxChange(const VARIANT& propVal)
{
	SetProperty(0x170, VT_VARIANT, &propVal);
}

VARIANT Application::GetMaxIterations()
{
	VARIANT result;
	GetProperty(0x171, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMaxIterations(const VARIANT& propVal)
{
	SetProperty(0x171, VT_VARIANT, &propVal);
}

VARIANT Application::GetMemoryFree()
{
	VARIANT result;
	GetProperty(0x172, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMemoryFree(const VARIANT& propVal)
{
	SetProperty(0x172, VT_VARIANT, &propVal);
}

VARIANT Application::GetMemoryTotal()
{
	VARIANT result;
	GetProperty(0x173, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMemoryTotal(const VARIANT& propVal)
{
	SetProperty(0x173, VT_VARIANT, &propVal);
}

VARIANT Application::GetMemoryUsed()
{
	VARIANT result;
	GetProperty(0x174, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMemoryUsed(const VARIANT& propVal)
{
	SetProperty(0x174, VT_VARIANT, &propVal);
}

VARIANT Application::GetMouseAvailable()
{
	VARIANT result;
	GetProperty(0x175, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMouseAvailable(const VARIANT& propVal)
{
	SetProperty(0x175, VT_VARIANT, &propVal);
}

VARIANT Application::GetMoveAfterReturn()
{
	VARIANT result;
	GetProperty(0x176, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMoveAfterReturn(const VARIANT& propVal)
{
	SetProperty(0x176, VT_VARIANT, &propVal);
}

VARIANT Application::GetMoveAfterReturnDirection()
{
	VARIANT result;
	GetProperty(0x478, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetMoveAfterReturnDirection(const VARIANT& propVal)
{
	SetProperty(0x478, VT_VARIANT, &propVal);
}

VARIANT Application::GetName()
{
	VARIANT result;
	GetProperty(0x6e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetName(const VARIANT& propVal)
{
	SetProperty(0x6e, VT_VARIANT, &propVal);
}

VARIANT Application::GetNetworkTemplatesPath()
{
	VARIANT result;
	GetProperty(0x184, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetNetworkTemplatesPath(const VARIANT& propVal)
{
	SetProperty(0x184, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnCalculate()
{
	VARIANT result;
	GetProperty(0x271, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnCalculate(const VARIANT& propVal)
{
	SetProperty(0x271, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnData()
{
	VARIANT result;
	GetProperty(0x275, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnData(const VARIANT& propVal)
{
	SetProperty(0x275, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnDoubleClick()
{
	VARIANT result;
	GetProperty(0x274, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnDoubleClick(const VARIANT& propVal)
{
	SetProperty(0x274, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnEntry()
{
	VARIANT result;
	GetProperty(0x273, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnEntry(const VARIANT& propVal)
{
	SetProperty(0x273, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnSheetActivate()
{
	VARIANT result;
	GetProperty(0x407, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnSheetActivate(const VARIANT& propVal)
{
	SetProperty(0x407, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnSheetDeactivate()
{
	VARIANT result;
	GetProperty(0x439, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnSheetDeactivate(const VARIANT& propVal)
{
	SetProperty(0x439, VT_VARIANT, &propVal);
}

VARIANT Application::GetOnWindow()
{
	VARIANT result;
	GetProperty(0x26f, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOnWindow(const VARIANT& propVal)
{
	SetProperty(0x26f, VT_VARIANT, &propVal);
}

VARIANT Application::GetOperatingSystem()
{
	VARIANT result;
	GetProperty(0x177, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOperatingSystem(const VARIANT& propVal)
{
	SetProperty(0x177, VT_VARIANT, &propVal);
}

VARIANT Application::GetOrganizationName()
{
	VARIANT result;
	GetProperty(0x178, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetOrganizationName(const VARIANT& propVal)
{
	SetProperty(0x178, VT_VARIANT, &propVal);
}

VARIANT Application::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

VARIANT Application::GetPath()
{
	VARIANT result;
	GetProperty(0x123, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetPath(const VARIANT& propVal)
{
	SetProperty(0x123, VT_VARIANT, &propVal);
}

VARIANT Application::GetPathSeparator()
{
	VARIANT result;
	GetProperty(0x179, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetPathSeparator(const VARIANT& propVal)
{
	SetProperty(0x179, VT_VARIANT, &propVal);
}

VARIANT Application::GetPreviousSelections()
{
	VARIANT result;
	GetProperty(0x17a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetPreviousSelections(const VARIANT& propVal)
{
	SetProperty(0x17a, VT_VARIANT, &propVal);
}

VARIANT Application::GetPromptForSummaryInfo()
{
	VARIANT result;
	GetProperty(0x426, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetPromptForSummaryInfo(const VARIANT& propVal)
{
	SetProperty(0x426, VT_VARIANT, &propVal);
}

VARIANT Application::GetRecordRelative()
{
	VARIANT result;
	GetProperty(0x17b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetRecordRelative(const VARIANT& propVal)
{
	SetProperty(0x17b, VT_VARIANT, &propVal);
}

VARIANT Application::GetReferenceStyle()
{
	VARIANT result;
	GetProperty(0x17c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetReferenceStyle(const VARIANT& propVal)
{
	SetProperty(0x17c, VT_VARIANT, &propVal);
}

VARIANT Application::GetRegisteredFunctions()
{
	VARIANT result;
	GetProperty(0x307, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetRegisteredFunctions(const VARIANT& propVal)
{
	SetProperty(0x307, VT_VARIANT, &propVal);
}

VARIANT Application::GetScreenUpdating()
{
	VARIANT result;
	GetProperty(0x17e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetScreenUpdating(const VARIANT& propVal)
{
	SetProperty(0x17e, VT_VARIANT, &propVal);
}

VARIANT Application::GetSelection()
{
	VARIANT result;
	GetProperty(0x93, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetSelection(const VARIANT& propVal)
{
	SetProperty(0x93, VT_VARIANT, &propVal);
}

VARIANT Application::GetSheetsInNewWorkbook()
{
	VARIANT result;
	GetProperty(0x3e1, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetSheetsInNewWorkbook(const VARIANT& propVal)
{
	SetProperty(0x3e1, VT_VARIANT, &propVal);
}

VARIANT Application::GetShowToolTips()
{
	VARIANT result;
	GetProperty(0x183, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetShowToolTips(const VARIANT& propVal)
{
	SetProperty(0x183, VT_VARIANT, &propVal);
}

VARIANT Application::GetStandardFont()
{
	VARIANT result;
	GetProperty(0x39c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetStandardFont(const VARIANT& propVal)
{
	SetProperty(0x39c, VT_VARIANT, &propVal);
}

VARIANT Application::GetStandardFontSize()
{
	VARIANT result;
	GetProperty(0x39d, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetStandardFontSize(const VARIANT& propVal)
{
	SetProperty(0x39d, VT_VARIANT, &propVal);
}

VARIANT Application::GetStartupPath()
{
	VARIANT result;
	GetProperty(0x181, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetStartupPath(const VARIANT& propVal)
{
	SetProperty(0x181, VT_VARIANT, &propVal);
}

VARIANT Application::GetStatusBar()
{
	VARIANT result;
	GetProperty(0x182, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetStatusBar(const VARIANT& propVal)
{
	SetProperty(0x182, VT_VARIANT, &propVal);
}

VARIANT Application::GetTemplatesPath()
{
	VARIANT result;
	GetProperty(0x17d, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetTemplatesPath(const VARIANT& propVal)
{
	SetProperty(0x17d, VT_VARIANT, &propVal);
}

VARIANT Application::GetThisWorkbook()
{
	VARIANT result;
	GetProperty(0x30a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetThisWorkbook(const VARIANT& propVal)
{
	SetProperty(0x30a, VT_VARIANT, &propVal);
}

VARIANT Application::GetTop()
{
	VARIANT result;
	GetProperty(0x7e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetTop(const VARIANT& propVal)
{
	SetProperty(0x7e, VT_VARIANT, &propVal);
}

VARIANT Application::GetTransitionMenuKey()
{
	VARIANT result;
	GetProperty(0x136, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetTransitionMenuKey(const VARIANT& propVal)
{
	SetProperty(0x136, VT_VARIANT, &propVal);
}

VARIANT Application::GetTransitionMenuKeyAction()
{
	VARIANT result;
	GetProperty(0x137, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetTransitionMenuKeyAction(const VARIANT& propVal)
{
	SetProperty(0x137, VT_VARIANT, &propVal);
}

VARIANT Application::GetTransitionNavigKeys()
{
	VARIANT result;
	GetProperty(0x138, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetTransitionNavigKeys(const VARIANT& propVal)
{
	SetProperty(0x138, VT_VARIANT, &propVal);
}

VARIANT Application::GetUsableHeight()
{
	VARIANT result;
	GetProperty(0x185, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetUsableHeight(const VARIANT& propVal)
{
	SetProperty(0x185, VT_VARIANT, &propVal);
}

VARIANT Application::GetUsableWidth()
{
	VARIANT result;
	GetProperty(0x186, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetUsableWidth(const VARIANT& propVal)
{
	SetProperty(0x186, VT_VARIANT, &propVal);
}

VARIANT Application::GetUserName()
{
	VARIANT result;
	GetProperty(0x187, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetUserName(const VARIANT& propVal)
{
	SetProperty(0x187, VT_VARIANT, &propVal);
}

VARIANT Application::GetValue()
{
	VARIANT result;
	GetProperty(0x6, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetValue(const VARIANT& propVal)
{
	SetProperty(0x6, VT_VARIANT, &propVal);
}

VARIANT Application::GetVersion()
{
	VARIANT result;
	GetProperty(0x188, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetVersion(const VARIANT& propVal)
{
	SetProperty(0x188, VT_VARIANT, &propVal);
}

VARIANT Application::GetVisible()
{
	VARIANT result;
	GetProperty(0x22e, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetVisible(const VARIANT& propVal)
{
	SetProperty(0x22e, VT_VARIANT, &propVal);
}

VARIANT Application::GetWidth()
{
	VARIANT result;
	GetProperty(0x7a, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetWidth(const VARIANT& propVal)
{
	SetProperty(0x7a, VT_VARIANT, &propVal);
}

VARIANT Application::GetWindowsForPens()
{
	VARIANT result;
	GetProperty(0x18b, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetWindowsForPens(const VARIANT& propVal)
{
	SetProperty(0x18b, VT_VARIANT, &propVal);
}

VARIANT Application::GetWindowState()
{
	VARIANT result;
	GetProperty(0x18c, VT_VARIANT, (void*)&result);
	return result;
}

void Application::SetWindowState(const VARIANT& propVal)
{
	SetProperty(0x18c, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Application operations

VARIANT Application::_WSFunction(const VARIANT& Range, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, 
		const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, 
		const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, 
		const VARIANT& Arg30)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT 
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xa9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Range, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
	return result;
}

VARIANT Application::Acos()
{
	VARIANT result;
	InvokeHelper(0x4063, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Acosh()
{
	VARIANT result;
	InvokeHelper(0x40e9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ActivateMicrosoftApp(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x447, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::AddChartAutoFormat(const VARIANT& Chart, const VARIANT& Name, const VARIANT& Description)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xd8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Chart, &Name, &Description);
	return result;
}

VARIANT Application::AddCustomList(const VARIANT& ListArray, const VARIANT& ByRow)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x30c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ListArray, &ByRow);
	return result;
}

VARIANT Application::AddIns(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x225, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::And()
{
	VARIANT result;
	InvokeHelper(0x4024, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Application_()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Asin()
{
	VARIANT result;
	InvokeHelper(0x4062, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Asinh()
{
	VARIANT result;
	InvokeHelper(0x40e8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Atan2()
{
	VARIANT result;
	InvokeHelper(0x4061, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Atanh()
{
	VARIANT result;
	InvokeHelper(0x40ea, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::AveDev()
{
	VARIANT result;
	InvokeHelper(0x410d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Average()
{
	VARIANT result;
	InvokeHelper(0x4005, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::BetaDist()
{
	VARIANT result;
	InvokeHelper(0x410e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::BetaInv()
{
	VARIANT result;
	InvokeHelper(0x4110, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::BinomDist()
{
	VARIANT result;
	InvokeHelper(0x4111, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Calculate()
{
	VARIANT result;
	InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Ceiling()
{
	VARIANT result;
	InvokeHelper(0x4120, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Cells(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xee, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowIndex, &ColumnIndex);
	return result;
}

VARIANT Application::CentimetersToPoints(const VARIANT& Centimeters)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x43e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Centimeters);
	return result;
}

VARIANT Application::Charts(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x79, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::CheckSpelling(const VARIANT& Word, const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Word, &CustomDictionary, &IgnoreUppercase);
	return result;
}

VARIANT Application::ChiDist()
{
	VARIANT result;
	InvokeHelper(0x4112, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ChiInv()
{
	VARIANT result;
	InvokeHelper(0x4113, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ChiTest()
{
	VARIANT result;
	InvokeHelper(0x4132, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Choose()
{
	VARIANT result;
	InvokeHelper(0x4064, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Clean()
{
	VARIANT result;
	InvokeHelper(0x40a2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Columns(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xf1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Combin()
{
	VARIANT result;
	InvokeHelper(0x4114, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Confidence()
{
	VARIANT result;
	InvokeHelper(0x4115, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ConvertFormula(const VARIANT& Formula, const VARIANT& FromReferenceStyle, const VARIANT& ToReferenceStyle, const VARIANT& ToAbsolute, const VARIANT& RelativeTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x145, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Formula, &FromReferenceStyle, &ToReferenceStyle, &ToAbsolute, &RelativeTo);
	return result;
}

VARIANT Application::Correl()
{
	VARIANT result;
	InvokeHelper(0x4133, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Cosh()
{
	VARIANT result;
	InvokeHelper(0x40e6, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Count()
{
	VARIANT result;
	InvokeHelper(0x4000, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::CountA()
{
	VARIANT result;
	InvokeHelper(0x40a9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::CountBlank()
{
	VARIANT result;
	InvokeHelper(0x415b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::CountIf()
{
	VARIANT result;
	InvokeHelper(0x415a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Covar()
{
	VARIANT result;
	InvokeHelper(0x4134, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::CritBinom()
{
	VARIANT result;
	InvokeHelper(0x4116, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DAverage()
{
	VARIANT result;
	InvokeHelper(0x402a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Days360()
{
	VARIANT result;
	InvokeHelper(0x40dc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Db()
{
	VARIANT result;
	InvokeHelper(0x40f7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DCount()
{
	VARIANT result;
	InvokeHelper(0x4028, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DCountA()
{
	VARIANT result;
	InvokeHelper(0x40c7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Ddb()
{
	VARIANT result;
	InvokeHelper(0x4090, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DDEExecute(const VARIANT& Channel, const VARIANT& String)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x14d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Channel, &String);
	return result;
}

VARIANT Application::DDEInitiate(const VARIANT& App, const VARIANT& Topic)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x14e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&App, &Topic);
	return result;
}

VARIANT Application::DDEPoke(const VARIANT& Channel, const VARIANT& Item, const VARIANT& Data)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x14f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Channel, &Item, &Data);
	return result;
}

VARIANT Application::DDERequest(const VARIANT& Channel, const VARIANT& Item)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x150, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Channel, &Item);
	return result;
}

VARIANT Application::DDETerminate(const VARIANT& Channel)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x151, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Channel);
	return result;
}

VARIANT Application::Degrees()
{
	VARIANT result;
	InvokeHelper(0x4157, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DeleteChartAutoFormat(const VARIANT& Name)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xd9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name);
	return result;
}

VARIANT Application::DeleteCustomList(const VARIANT& ListNum)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x30f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ListNum);
	return result;
}

VARIANT Application::DevSq()
{
	VARIANT result;
	InvokeHelper(0x413e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DGet()
{
	VARIANT result;
	InvokeHelper(0x40eb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Dialogs(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::DialogSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2fc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::DMax()
{
	VARIANT result;
	InvokeHelper(0x402c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DMin()
{
	VARIANT result;
	InvokeHelper(0x402b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Dollar()
{
	VARIANT result;
	InvokeHelper(0x400d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DoubleClick()
{
	VARIANT result;
	InvokeHelper(0x15d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DProduct()
{
	VARIANT result;
	InvokeHelper(0x40bd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DStDev()
{
	VARIANT result;
	InvokeHelper(0x402d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DStDevP()
{
	VARIANT result;
	InvokeHelper(0x40c3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DSum()
{
	VARIANT result;
	InvokeHelper(0x4029, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DVar()
{
	VARIANT result;
	InvokeHelper(0x402f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::DVarP()
{
	VARIANT result;
	InvokeHelper(0x40c4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::_Evaluate(const VARIANT& Name)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name);
	return result;
}

VARIANT Application::Evaluate(const VARIANT& Name)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name);
	return result;
}

VARIANT Application::Even()
{
	VARIANT result;
	InvokeHelper(0x4117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Excel4IntlMacroSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x245, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Excel4MacroSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x243, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::ExecuteExcel4Macro(const VARIANT& String)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x15e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&String);
	return result;
}

VARIANT Application::ExponDist()
{
	VARIANT result;
	InvokeHelper(0x4118, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Fact()
{
	VARIANT result;
	InvokeHelper(0x40b8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FDist()
{
	VARIANT result;
	InvokeHelper(0x4119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Find()
{
	VARIANT result;
	InvokeHelper(0x407c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FindB()
{
	VARIANT result;
	InvokeHelper(0x40cd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FindFile()
{
	VARIANT result;
	InvokeHelper(0x42c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FInv()
{
	VARIANT result;
	InvokeHelper(0x411a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Fisher()
{
	VARIANT result;
	InvokeHelper(0x411b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FisherInv()
{
	VARIANT result;
	InvokeHelper(0x411c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Fixed()
{
	VARIANT result;
	InvokeHelper(0x400e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Floor()
{
	VARIANT result;
	InvokeHelper(0x411d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Forecast()
{
	VARIANT result;
	InvokeHelper(0x4135, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Frequency()
{
	VARIANT result;
	InvokeHelper(0x40fc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::FTest()
{
	VARIANT result;
	InvokeHelper(0x4136, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Fv()
{
	VARIANT result;
	InvokeHelper(0x4039, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::GammaDist()
{
	VARIANT result;
	InvokeHelper(0x411e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::GammaInv()
{
	VARIANT result;
	InvokeHelper(0x411f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::GammaLn()
{
	VARIANT result;
	InvokeHelper(0x410f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::GeoMean()
{
	VARIANT result;
	InvokeHelper(0x413f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::GetCustomListContents(const VARIANT& ListNum)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x312, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ListNum);
	return result;
}

VARIANT Application::GetCustomListNum(const VARIANT& ListArray)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x311, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ListArray);
	return result;
}

VARIANT Application::GetOpenFilename(const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText, const VARIANT& MultiSelect)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x433, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&FileFilter, &FilterIndex, &Title, &ButtonText, &MultiSelect);
	return result;
}

VARIANT Application::GetSaveAsFilename(const VARIANT& InitialFilename, const VARIANT& FileFilter, const VARIANT& FilterIndex, const VARIANT& Title, const VARIANT& ButtonText)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x434, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&InitialFilename, &FileFilter, &FilterIndex, &Title, &ButtonText);
	return result;
}

VARIANT Application::Goto(const VARIANT& Reference, const VARIANT& Scroll)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1db, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Reference, &Scroll);
	return result;
}

VARIANT Application::Growth()
{
	VARIANT result;
	InvokeHelper(0x4034, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::HarMean()
{
	VARIANT result;
	InvokeHelper(0x4140, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Help(const VARIANT& HelpFile, const VARIANT& HelpContextID)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x162, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&HelpFile, &HelpContextID);
	return result;
}

VARIANT Application::HLookup()
{
	VARIANT result;
	InvokeHelper(0x4065, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::HypGeomDist()
{
	VARIANT result;
	InvokeHelper(0x4121, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::InchesToPoints(const VARIANT& Inches)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x43f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Inches);
	return result;
}

VARIANT Application::Index()
{
	VARIANT result;
	InvokeHelper(0x401d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::InputBox(const VARIANT& Prompt, const VARIANT& Title, const VARIANT& Default, const VARIANT& Left, const VARIANT& Top, const VARIANT& HelpFile, const VARIANT& HelpContextID, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x165, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Prompt, &Title, &Default, &Left, &Top, &HelpFile, &HelpContextID, &Type);
	return result;
}

VARIANT Application::Intercept()
{
	VARIANT result;
	InvokeHelper(0x4137, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Intersect(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, 
		const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, 
		const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT 
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2fe, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
	return result;
}

VARIANT Application::Ipmt()
{
	VARIANT result;
	InvokeHelper(0x40a7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Irr()
{
	VARIANT result;
	InvokeHelper(0x403e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsErr()
{
	VARIANT result;
	InvokeHelper(0x407e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsError()
{
	VARIANT result;
	InvokeHelper(0x4003, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsLogical()
{
	VARIANT result;
	InvokeHelper(0x40c6, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsNA()
{
	VARIANT result;
	InvokeHelper(0x4002, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsNonText()
{
	VARIANT result;
	InvokeHelper(0x40be, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsNumber()
{
	VARIANT result;
	InvokeHelper(0x4080, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Ispmt()
{
	VARIANT result;
	InvokeHelper(0x415e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::IsText()
{
	VARIANT result;
	InvokeHelper(0x407f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Kurt()
{
	VARIANT result;
	InvokeHelper(0x4142, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Large()
{
	VARIANT result;
	InvokeHelper(0x4145, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::LinEst()
{
	VARIANT result;
	InvokeHelper(0x4031, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Ln()
{
	VARIANT result;
	InvokeHelper(0x4016, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Log()
{
	VARIANT result;
	InvokeHelper(0x406d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Log10()
{
	VARIANT result;
	InvokeHelper(0x4017, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::LogEst()
{
	VARIANT result;
	InvokeHelper(0x4033, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::LogInv()
{
	VARIANT result;
	InvokeHelper(0x4123, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::LogNormDist()
{
	VARIANT result;
	InvokeHelper(0x4122, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Lookup()
{
	VARIANT result;
	InvokeHelper(0x401c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MacroOptions(const VARIANT& Macro, const VARIANT& Description, const VARIANT& HasMenu, const VARIANT& MenuText, const VARIANT& HasShortcutKey, const VARIANT& ShortcutKey, const VARIANT& Category, const VARIANT& StatusBar, 
		const VARIANT& HelpContextID, const VARIANT& HelpFile)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x46f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Macro, &Description, &HasMenu, &MenuText, &HasShortcutKey, &ShortcutKey, &Category, &StatusBar, &HelpContextID, &HelpFile);
	return result;
}

VARIANT Application::MailLogoff()
{
	VARIANT result;
	InvokeHelper(0x3b1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MailLogon(const VARIANT& Name, const VARIANT& Password, const VARIANT& DownloadNewMail)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x3af, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &Password, &DownloadNewMail);
	return result;
}

VARIANT Application::Match()
{
	VARIANT result;
	InvokeHelper(0x4040, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Max()
{
	VARIANT result;
	InvokeHelper(0x4007, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MDeterm()
{
	VARIANT result;
	InvokeHelper(0x40a3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Median()
{
	VARIANT result;
	InvokeHelper(0x40e3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MenuBars(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x24d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Min()
{
	VARIANT result;
	InvokeHelper(0x4006, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MInverse()
{
	VARIANT result;
	InvokeHelper(0x40a4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MIrr()
{
	VARIANT result;
	InvokeHelper(0x403d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::MMult()
{
	VARIANT result;
	InvokeHelper(0x40a5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Mode()
{
	VARIANT result;
	InvokeHelper(0x414a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Modules(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x246, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Names(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1ba, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index, &IndexLocal, &RefersTo);
	return result;
}

VARIANT Application::NegBinomDist()
{
	VARIANT result;
	InvokeHelper(0x4124, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NextLetter()
{
	VARIANT result;
	InvokeHelper(0x3cc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NormDist()
{
	VARIANT result;
	InvokeHelper(0x4125, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NormInv()
{
	VARIANT result;
	InvokeHelper(0x4127, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NormSDist()
{
	VARIANT result;
	InvokeHelper(0x4126, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NormSInv()
{
	VARIANT result;
	InvokeHelper(0x4128, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::NPer()
{
	VARIANT result;
	InvokeHelper(0x403a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Npv()
{
	VARIANT result;
	InvokeHelper(0x400b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Odd()
{
	VARIANT result;
	InvokeHelper(0x412a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::OnKey(const VARIANT& Key, const VARIANT& Procedure)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x272, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Key, &Procedure);
	return result;
}

VARIANT Application::OnRepeat(const VARIANT& Text, const VARIANT& Procedure)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x301, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Text, &Procedure);
	return result;
}

VARIANT Application::OnTime(const VARIANT& EarliestTime, const VARIANT& Procedure, const VARIANT& LatestTime, const VARIANT& Schedule)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x270, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&EarliestTime, &Procedure, &LatestTime, &Schedule);
	return result;
}

VARIANT Application::OnUndo(const VARIANT& Text, const VARIANT& Procedure)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x302, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Text, &Procedure);
	return result;
}

VARIANT Application::Or()
{
	VARIANT result;
	InvokeHelper(0x4025, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Pearson()
{
	VARIANT result;
	InvokeHelper(0x4138, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Percentile()
{
	VARIANT result;
	InvokeHelper(0x4148, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::PercentRank()
{
	VARIANT result;
	InvokeHelper(0x4149, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Permut()
{
	VARIANT result;
	InvokeHelper(0x412b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Pi()
{
	VARIANT result;
	InvokeHelper(0x4013, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Pmt()
{
	VARIANT result;
	InvokeHelper(0x403b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Poisson()
{
	VARIANT result;
	InvokeHelper(0x412c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Power()
{
	VARIANT result;
	InvokeHelper(0x4151, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Ppmt()
{
	VARIANT result;
	InvokeHelper(0x40a8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Prob()
{
	VARIANT result;
	InvokeHelper(0x413d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Product()
{
	VARIANT result;
	InvokeHelper(0x40b7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Proper()
{
	VARIANT result;
	InvokeHelper(0x4072, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Pv()
{
	VARIANT result;
	InvokeHelper(0x4038, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Quartile()
{
	VARIANT result;
	InvokeHelper(0x4147, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Quit()
{
	VARIANT result;
	InvokeHelper(0x12e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Radians()
{
	VARIANT result;
	InvokeHelper(0x4156, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Range(const VARIANT& Cell1, const VARIANT& Cell2)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xc5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Cell1, &Cell2);
	return result;
}

VARIANT Application::Rank()
{
	VARIANT result;
	InvokeHelper(0x40d8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Rate()
{
	VARIANT result;
	InvokeHelper(0x403c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::RecordMacro(const VARIANT& BasicCode, const VARIANT& XlmCode)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x305, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&BasicCode, &XlmCode);
	return result;
}

VARIANT Application::RegisterXLL(const VARIANT& Filename)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename);
	return result;
}

VARIANT Application::Repeat()
{
	VARIANT result;
	InvokeHelper(0x12d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Replace()
{
	VARIANT result;
	InvokeHelper(0x4077, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ReplaceB()
{
	VARIANT result;
	InvokeHelper(0x40cf, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Rept()
{
	VARIANT result;
	InvokeHelper(0x401e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::ResetTipWizard()
{
	VARIANT result;
	InvokeHelper(0x3a0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Roman()
{
	VARIANT result;
	InvokeHelper(0x4162, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Round()
{
	VARIANT result;
	InvokeHelper(0x401b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::RoundDown()
{
	VARIANT result;
	InvokeHelper(0x40d5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::RoundUp()
{
	VARIANT result;
	InvokeHelper(0x40d4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Rows(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x102, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::RSq()
{
	VARIANT result;
	InvokeHelper(0x4139, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Run(const VARIANT& Macro, const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, 
		const VARIANT& Arg10, const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, 
		const VARIANT& Arg20, const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, 
		const VARIANT& Arg30)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT 
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Macro, &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
	return result;
}

VARIANT Application::Save(const VARIANT& Filename)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x11b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename);
	return result;
}

VARIANT Application::Search()
{
	VARIANT result;
	InvokeHelper(0x4052, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SearchB()
{
	VARIANT result;
	InvokeHelper(0x40ce, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SendKeys(const VARIANT& Keys, const VARIANT& Wait)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x17f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Keys, &Wait);
	return result;
}

VARIANT Application::SetDefaultChart(const VARIANT& FormatName)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xdb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&FormatName);
	return result;
}

VARIANT Application::Sheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1e5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::ShortcutMenus(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x308, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Sinh()
{
	VARIANT result;
	InvokeHelper(0x40e5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Skew()
{
	VARIANT result;
	InvokeHelper(0x4143, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Sln()
{
	VARIANT result;
	InvokeHelper(0x408e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Slope()
{
	VARIANT result;
	InvokeHelper(0x413b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Small()
{
	VARIANT result;
	InvokeHelper(0x4146, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Standardize()
{
	VARIANT result;
	InvokeHelper(0x4129, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::StDev()
{
	VARIANT result;
	InvokeHelper(0x400c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::StDevP()
{
	VARIANT result;
	InvokeHelper(0x40c1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::StEyx()
{
	VARIANT result;
	InvokeHelper(0x413a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Substitute()
{
	VARIANT result;
	InvokeHelper(0x4078, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Subtotal()
{
	VARIANT result;
	InvokeHelper(0x4158, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Sum()
{
	VARIANT result;
	InvokeHelper(0x4004, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumIf()
{
	VARIANT result;
	InvokeHelper(0x4159, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumProduct()
{
	VARIANT result;
	InvokeHelper(0x40e4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumSq()
{
	VARIANT result;
	InvokeHelper(0x4141, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumX2MY2()
{
	VARIANT result;
	InvokeHelper(0x4130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumX2PY2()
{
	VARIANT result;
	InvokeHelper(0x4131, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::SumXMY2()
{
	VARIANT result;
	InvokeHelper(0x412f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Syd()
{
	VARIANT result;
	InvokeHelper(0x408f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Tanh()
{
	VARIANT result;
	InvokeHelper(0x40e7, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::TDist()
{
	VARIANT result;
	InvokeHelper(0x412d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Text()
{
	VARIANT result;
	InvokeHelper(0x4030, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::TInv()
{
	VARIANT result;
	InvokeHelper(0x414c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Toolbars(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x228, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Transpose()
{
	VARIANT result;
	InvokeHelper(0x4053, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Trend()
{
	VARIANT result;
	InvokeHelper(0x4032, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Trim()
{
	VARIANT result;
	InvokeHelper(0x4076, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::TrimMean()
{
	VARIANT result;
	InvokeHelper(0x414b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::TTest()
{
	VARIANT result;
	InvokeHelper(0x413c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Undo()
{
	VARIANT result;
	InvokeHelper(0x12f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Union(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, 
		const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, 
		const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT 
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x30b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
	return result;
}

VARIANT Application::USDollar()
{
	VARIANT result;
	InvokeHelper(0x40cc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Var()
{
	VARIANT result;
	InvokeHelper(0x402e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::VarP()
{
	VARIANT result;
	InvokeHelper(0x40c2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Vdb()
{
	VARIANT result;
	InvokeHelper(0x40de, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::VLookup()
{
	VARIANT result;
	InvokeHelper(0x4066, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Volatile(const VARIANT& Volatile)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x314, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Volatile);
	return result;
}

VARIANT Application::Wait(const VARIANT& Time)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x189, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Time);
	return result;
}

VARIANT Application::Weekday()
{
	VARIANT result;
	InvokeHelper(0x4046, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Weibull()
{
	VARIANT result;
	InvokeHelper(0x412e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Application::Windows(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ae, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Workbooks(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x23c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::Worksheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ee, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Application::ZTest()
{
	VARIANT result;
	InvokeHelper(0x4144, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Range properties

VARIANT Range::GetAddIndent()
{
	VARIANT result;
	GetProperty(0x427, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetAddIndent(const VARIANT& propVal)
{
	SetProperty(0x427, VT_VARIANT, &propVal);
}

VARIANT Range::GetColumn()
{
	VARIANT result;
	GetProperty(0xf0, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetColumn(const VARIANT& propVal)
{
	SetProperty(0xf0, VT_VARIANT, &propVal);
}

VARIANT Range::GetColumnWidth()
{
	VARIANT result;
	GetProperty(0xf2, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetColumnWidth(const VARIANT& propVal)
{
	SetProperty(0xf2, VT_VARIANT, &propVal);
}

VARIANT Range::GetCount()
{
	VARIANT result;
	GetProperty(0x76, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetCount(const VARIANT& propVal)
{
	SetProperty(0x76, VT_VARIANT, &propVal);
}

VARIANT Range::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Range::GetCurrentArray()
{
	VARIANT result;
	GetProperty(0x1f5, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetCurrentArray(const VARIANT& propVal)
{
	SetProperty(0x1f5, VT_VARIANT, &propVal);
}

VARIANT Range::GetCurrentRegion()
{
	VARIANT result;
	GetProperty(0xf3, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetCurrentRegion(const VARIANT& propVal)
{
	SetProperty(0xf3, VT_VARIANT, &propVal);
}

VARIANT Range::GetDependents()
{
	VARIANT result;
	GetProperty(0x21f, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetDependents(const VARIANT& propVal)
{
	SetProperty(0x21f, VT_VARIANT, &propVal);
}

VARIANT Range::GetDirectDependents()
{
	VARIANT result;
	GetProperty(0x221, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetDirectDependents(const VARIANT& propVal)
{
	SetProperty(0x221, VT_VARIANT, &propVal);
}

VARIANT Range::GetDirectPrecedents()
{
	VARIANT result;
	GetProperty(0x222, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetDirectPrecedents(const VARIANT& propVal)
{
	SetProperty(0x222, VT_VARIANT, &propVal);
}

VARIANT Range::GetEntireColumn()
{
	VARIANT result;
	GetProperty(0xf6, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetEntireColumn(const VARIANT& propVal)
{
	SetProperty(0xf6, VT_VARIANT, &propVal);
}

VARIANT Range::GetEntireRow()
{
	VARIANT result;
	GetProperty(0xf7, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetEntireRow(const VARIANT& propVal)
{
	SetProperty(0xf7, VT_VARIANT, &propVal);
}

VARIANT Range::GetFont()
{
	VARIANT result;
	GetProperty(0x92, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFont(const VARIANT& propVal)
{
	SetProperty(0x92, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormula()
{
	VARIANT result;
	GetProperty(0x105, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormula(const VARIANT& propVal)
{
	SetProperty(0x105, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormulaArray()
{
	VARIANT result;
	GetProperty(0x24a, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormulaArray(const VARIANT& propVal)
{
	SetProperty(0x24a, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormulaHidden()
{
	VARIANT result;
	GetProperty(0x106, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormulaHidden(const VARIANT& propVal)
{
	SetProperty(0x106, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormulaLocal()
{
	VARIANT result;
	GetProperty(0x107, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormulaLocal(const VARIANT& propVal)
{
	SetProperty(0x107, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormulaR1C1()
{
	VARIANT result;
	GetProperty(0x108, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormulaR1C1(const VARIANT& propVal)
{
	SetProperty(0x108, VT_VARIANT, &propVal);
}

VARIANT Range::GetFormulaR1C1Local()
{
	VARIANT result;
	GetProperty(0x109, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetFormulaR1C1Local(const VARIANT& propVal)
{
	SetProperty(0x109, VT_VARIANT, &propVal);
}

VARIANT Range::GetHasArray()
{
	VARIANT result;
	GetProperty(0x10a, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetHasArray(const VARIANT& propVal)
{
	SetProperty(0x10a, VT_VARIANT, &propVal);
}

VARIANT Range::GetHasFormula()
{
	VARIANT result;
	GetProperty(0x10b, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetHasFormula(const VARIANT& propVal)
{
	SetProperty(0x10b, VT_VARIANT, &propVal);
}

VARIANT Range::GetHeight()
{
	VARIANT result;
	GetProperty(0x7b, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetHeight(const VARIANT& propVal)
{
	SetProperty(0x7b, VT_VARIANT, &propVal);
}

VARIANT Range::GetHidden()
{
	VARIANT result;
	GetProperty(0x10c, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetHidden(const VARIANT& propVal)
{
	SetProperty(0x10c, VT_VARIANT, &propVal);
}

VARIANT Range::GetHorizontalAlignment()
{
	VARIANT result;
	GetProperty(0x88, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetHorizontalAlignment(const VARIANT& propVal)
{
	SetProperty(0x88, VT_VARIANT, &propVal);
}

VARIANT Range::GetInterior()
{
	VARIANT result;
	GetProperty(0x81, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetInterior(const VARIANT& propVal)
{
	SetProperty(0x81, VT_VARIANT, &propVal);
}

VARIANT Range::GetLeft()
{
	VARIANT result;
	GetProperty(0x7f, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetLeft(const VARIANT& propVal)
{
	SetProperty(0x7f, VT_VARIANT, &propVal);
}

VARIANT Range::GetListHeaderRows()
{
	VARIANT result;
	GetProperty(0x4a3, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetListHeaderRows(const VARIANT& propVal)
{
	SetProperty(0x4a3, VT_VARIANT, &propVal);
}

VARIANT Range::GetLocationInTable()
{
	VARIANT result;
	GetProperty(0x2b3, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetLocationInTable(const VARIANT& propVal)
{
	SetProperty(0x2b3, VT_VARIANT, &propVal);
}

VARIANT Range::GetLocked()
{
	VARIANT result;
	GetProperty(0x10d, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetLocked(const VARIANT& propVal)
{
	SetProperty(0x10d, VT_VARIANT, &propVal);
}

VARIANT Range::GetName()
{
	VARIANT result;
	GetProperty(0x6e, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetName(const VARIANT& propVal)
{
	SetProperty(0x6e, VT_VARIANT, &propVal);
}

VARIANT Range::GetNext()
{
	VARIANT result;
	GetProperty(0x1f6, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetNext(const VARIANT& propVal)
{
	SetProperty(0x1f6, VT_VARIANT, &propVal);
}

VARIANT Range::GetNumberFormat()
{
	VARIANT result;
	GetProperty(0xc1, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetNumberFormat(const VARIANT& propVal)
{
	SetProperty(0xc1, VT_VARIANT, &propVal);
}

VARIANT Range::GetNumberFormatLocal()
{
	VARIANT result;
	GetProperty(0x449, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetNumberFormatLocal(const VARIANT& propVal)
{
	SetProperty(0x449, VT_VARIANT, &propVal);
}

VARIANT Range::GetOrientation()
{
	VARIANT result;
	GetProperty(0x86, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetOrientation(const VARIANT& propVal)
{
	SetProperty(0x86, VT_VARIANT, &propVal);
}

VARIANT Range::GetOutlineLevel()
{
	VARIANT result;
	GetProperty(0x10f, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetOutlineLevel(const VARIANT& propVal)
{
	SetProperty(0x10f, VT_VARIANT, &propVal);
}

VARIANT Range::GetPageBreak()
{
	VARIANT result;
	GetProperty(0xff, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPageBreak(const VARIANT& propVal)
{
	SetProperty(0xff, VT_VARIANT, &propVal);
}

VARIANT Range::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

VARIANT Range::GetPivotField()
{
	VARIANT result;
	GetProperty(0x2db, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPivotField(const VARIANT& propVal)
{
	SetProperty(0x2db, VT_VARIANT, &propVal);
}

VARIANT Range::GetPivotItem()
{
	VARIANT result;
	GetProperty(0x2e4, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPivotItem(const VARIANT& propVal)
{
	SetProperty(0x2e4, VT_VARIANT, &propVal);
}

VARIANT Range::GetPivotTable()
{
	VARIANT result;
	GetProperty(0x2cc, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPivotTable(const VARIANT& propVal)
{
	SetProperty(0x2cc, VT_VARIANT, &propVal);
}

VARIANT Range::GetPrecedents()
{
	VARIANT result;
	GetProperty(0x220, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPrecedents(const VARIANT& propVal)
{
	SetProperty(0x220, VT_VARIANT, &propVal);
}

VARIANT Range::GetPrefixCharacter()
{
	VARIANT result;
	GetProperty(0x1f8, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPrefixCharacter(const VARIANT& propVal)
{
	SetProperty(0x1f8, VT_VARIANT, &propVal);
}

VARIANT Range::GetPrevious()
{
	VARIANT result;
	GetProperty(0x1f7, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetPrevious(const VARIANT& propVal)
{
	SetProperty(0x1f7, VT_VARIANT, &propVal);
}

VARIANT Range::GetRow()
{
	VARIANT result;
	GetProperty(0x101, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetRow(const VARIANT& propVal)
{
	SetProperty(0x101, VT_VARIANT, &propVal);
}

VARIANT Range::GetRowHeight()
{
	VARIANT result;
	GetProperty(0x110, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetRowHeight(const VARIANT& propVal)
{
	SetProperty(0x110, VT_VARIANT, &propVal);
}

VARIANT Range::GetShowDetail()
{
	VARIANT result;
	GetProperty(0x249, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetShowDetail(const VARIANT& propVal)
{
	SetProperty(0x249, VT_VARIANT, &propVal);
}

VARIANT Range::GetSoundNote()
{
	VARIANT result;
	GetProperty(0x394, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetSoundNote(const VARIANT& propVal)
{
	SetProperty(0x394, VT_VARIANT, &propVal);
}

VARIANT Range::GetStyle()
{
	VARIANT result;
	GetProperty(0x104, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetStyle(const VARIANT& propVal)
{
	SetProperty(0x104, VT_VARIANT, &propVal);
}

VARIANT Range::GetSummary()
{
	VARIANT result;
	GetProperty(0x111, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetSummary(const VARIANT& propVal)
{
	SetProperty(0x111, VT_VARIANT, &propVal);
}

VARIANT Range::GetText()
{
	VARIANT result;
	GetProperty(0x8a, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetText(const VARIANT& propVal)
{
	SetProperty(0x8a, VT_VARIANT, &propVal);
}

VARIANT Range::GetTop()
{
	VARIANT result;
	GetProperty(0x7e, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetTop(const VARIANT& propVal)
{
	SetProperty(0x7e, VT_VARIANT, &propVal);
}

VARIANT Range::GetUseStandardHeight()
{
	VARIANT result;
	GetProperty(0x112, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetUseStandardHeight(const VARIANT& propVal)
{
	SetProperty(0x112, VT_VARIANT, &propVal);
}

VARIANT Range::GetUseStandardWidth()
{
	VARIANT result;
	GetProperty(0x113, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetUseStandardWidth(const VARIANT& propVal)
{
	SetProperty(0x113, VT_VARIANT, &propVal);
}

VARIANT Range::GetValue()
{
	VARIANT result;
	GetProperty(0x6, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetValue(const VARIANT& propVal)
{
	SetProperty(0x6, VT_VARIANT, &propVal);
}

VARIANT Range::GetVerticalAlignment()
{
	VARIANT result;
	GetProperty(0x89, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetVerticalAlignment(const VARIANT& propVal)
{
	SetProperty(0x89, VT_VARIANT, &propVal);
}

VARIANT Range::GetWidth()
{
	VARIANT result;
	GetProperty(0x7a, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetWidth(const VARIANT& propVal)
{
	SetProperty(0x7a, VT_VARIANT, &propVal);
}

VARIANT Range::GetWrapText()
{
	VARIANT result;
	GetProperty(0x114, VT_VARIANT, (void*)&result);
	return result;
}

void Range::SetWrapText(const VARIANT& propVal)
{
	SetProperty(0x114, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Range operations

VARIANT Range::_Dummy(const VARIANT& Activate, const VARIANT& DirectObject)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Activate, &DirectObject);
	return result;
}

VARIANT Range::_NewEnum()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Activate()
{
	VARIANT result;
	InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Address(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, const VARIANT& ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xec, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowAbsolute, &ColumnAbsolute, &ReferenceStyle, &External, &RelativeTo);
	return result;
}

VARIANT Range::AddressLocal(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, const VARIANT& ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1b5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowAbsolute, &ColumnAbsolute, &ReferenceStyle, &External, &RelativeTo);
	return result;
}

VARIANT Range::AdvancedFilter(const VARIANT& Action, const VARIANT& CriteriaRange, const VARIANT& CopyToRange, const VARIANT& Unique)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x36c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Action, &CriteriaRange, &CopyToRange, &Unique);
	return result;
}

VARIANT Range::Application()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ApplyNames(const VARIANT& Names, const VARIANT& IgnoreRelativeAbsolute, const VARIANT& UseRowColumnNames, const VARIANT& OmitColumn, const VARIANT& OmitRow, const VARIANT& Order, const VARIANT& AppendLast)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1b9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Names, &IgnoreRelativeAbsolute, &UseRowColumnNames, &OmitColumn, &OmitRow, &Order, &AppendLast);
	return result;
}

VARIANT Range::ApplyOutlineStyles()
{
	VARIANT result;
	InvokeHelper(0x1c0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Areas(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x238, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Range::AutoComplete(const VARIANT& String)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x4a1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&String);
	return result;
}

VARIANT Range::AutoFill(const VARIANT& Destination, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1c1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Destination, &Type);
	return result;
}

VARIANT Range::AutoFilter(const VARIANT& Field, const VARIANT& Criteria1, const VARIANT& Operator, const VARIANT& Criteria2)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x319, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Field, &Criteria1, &Operator, &Criteria2);
	return result;
}

VARIANT Range::AutoFit()
{
	VARIANT result;
	InvokeHelper(0xed, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::AutoFormat(const VARIANT& Format, const VARIANT& Number, const VARIANT& Font, const VARIANT& Alignment, const VARIANT& Border, const VARIANT& Pattern, const VARIANT& Width)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x72, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Format, &Number, &Font, &Alignment, &Border, &Pattern, &Width);
	return result;
}

VARIANT Range::AutoOutline()
{
	VARIANT result;
	InvokeHelper(0x40c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::BorderAround(const VARIANT& LineStyle, const VARIANT& Weight, const VARIANT& ColorIndex, const VARIANT& Color)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x42b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&LineStyle, &Weight, &ColorIndex, &Color);
	return result;
}

VARIANT Range::Borders(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1b3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Range::Calculate()
{
	VARIANT result;
	InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Cells(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xee, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowIndex, &ColumnIndex);
	return result;
}

VARIANT Range::Characters(const VARIANT& Start, const VARIANT& Length)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x25b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Start, &Length);
	return result;
}

VARIANT Range::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&CustomDictionary, &IgnoreUppercase, &AlwaysSuggest);
	return result;
}

VARIANT Range::Clear()
{
	VARIANT result;
	InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ClearContents()
{
	VARIANT result;
	InvokeHelper(0x71, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ClearFormats()
{
	VARIANT result;
	InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ClearNotes()
{
	VARIANT result;
	InvokeHelper(0xef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ClearOutline()
{
	VARIANT result;
	InvokeHelper(0x40d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ColumnDifferences(const VARIANT& Comparison)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1fe, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Comparison);
	return result;
}

VARIANT Range::Columns(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xf1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Range::Consolidate(const VARIANT& Sources, const VARIANT& Function, const VARIANT& TopRow, const VARIANT& LeftColumn, const VARIANT& CreateLinks)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1e2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Sources, &Function, &TopRow, &LeftColumn, &CreateLinks);
	return result;
}

VARIANT Range::Copy(const VARIANT& Destination)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Destination);
	return result;
}

VARIANT Range::CopyFromRecordset(const VARIANT& Data, const VARIANT& MaxRows, const VARIANT& MaxColumns)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x480, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Data, &MaxRows, &MaxColumns);
	return result;
}

VARIANT Range::CopyPicture(const VARIANT& Appearance, const VARIANT& Format)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Appearance, &Format);
	return result;
}

VARIANT Range::CreateNames(const VARIANT& Top, const VARIANT& Left, const VARIANT& Bottom, const VARIANT& Right)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1c9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Top, &Left, &Bottom, &Right);
	return result;
}

VARIANT Range::CreatePublisher(const VARIANT& Edition, const VARIANT& Appearance, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1ca, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Edition, &Appearance, &ContainsPICT, &ContainsBIFF, &ContainsRTF, &ContainsVALU);
	return result;
}

VARIANT Range::Cut(const VARIANT& Destination)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Destination);
	return result;
}

VARIANT Range::DataSeries(const VARIANT& Rowcol, const VARIANT& Type, const VARIANT& Date, const VARIANT& Step, const VARIANT& Stop, const VARIANT& Trend)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1d0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Rowcol, &Type, &Date, &Step, &Stop, &Trend);
	return result;
}

VARIANT Range::Delete(const VARIANT& Shift)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Shift);
	return result;
}

VARIANT Range::DialogBox_()
{
	VARIANT result;
	InvokeHelper(0xf5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::End(const VARIANT& Direction)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1f4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Direction);
	return result;
}

VARIANT Range::FillDown()
{
	VARIANT result;
	InvokeHelper(0xf8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::FillLeft()
{
	VARIANT result;
	InvokeHelper(0xf9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::FillRight()
{
	VARIANT result;
	InvokeHelper(0xfa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::FillUp()
{
	VARIANT result;
	InvokeHelper(0xfb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Find(const VARIANT& What, const VARIANT& After, const VARIANT& LookIn, const VARIANT& LookAt, const VARIANT& SearchOrder, const VARIANT& SearchDirection, const VARIANT& MatchCase, const VARIANT& MatchByte)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x18e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&What, &After, &LookIn, &LookAt, &SearchOrder, &SearchDirection, &MatchCase, &MatchByte);
	return result;
}

VARIANT Range::FindNext(const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x18f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&After);
	return result;
}

VARIANT Range::FindPrevious(const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x190, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&After);
	return result;
}

VARIANT Range::FunctionWizard()
{
	VARIANT result;
	InvokeHelper(0x23b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::GoalSeek(const VARIANT& Goal, const VARIANT& ChangingCell)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1d8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Goal, &ChangingCell);
	return result;
}

VARIANT Range::Group(const VARIANT& Start, const VARIANT& End, const VARIANT& By, const VARIANT& Periods)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Start, &End, &By, &Periods);
	return result;
}

VARIANT Range::Insert(const VARIANT& Shift)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xfc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Shift);
	return result;
}

VARIANT Range::Item(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xaa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowIndex, &ColumnIndex);
	return result;
}

VARIANT Range::Justify()
{
	VARIANT result;
	InvokeHelper(0x1ef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ListNames()
{
	VARIANT result;
	InvokeHelper(0xfd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::NavigateArrow(const VARIANT& TowardPrecedent, const VARIANT& ArrowNumber, const VARIANT& LinkNumber)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x408, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&TowardPrecedent, &ArrowNumber, &LinkNumber);
	return result;
}

VARIANT Range::NoteText(const VARIANT& Text, const VARIANT& Start, const VARIANT& Length)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x467, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Text, &Start, &Length);
	return result;
}

VARIANT Range::Offset(const VARIANT& RowOffset, const VARIANT& ColumnOffset)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xfe, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowOffset, &ColumnOffset);
	return result;
}

VARIANT Range::Parse(const VARIANT& ParseLine, const VARIANT& Destination)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1dd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ParseLine, &Destination);
	return result;
}

VARIANT Range::PasteSpecial(const VARIANT& Paste, const VARIANT& Operation, const VARIANT& SkipBlanks, const VARIANT& Transpose)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x403, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Paste, &Operation, &SkipBlanks, &Transpose);
	return result;
}

VARIANT Range::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate);
	return result;
}

VARIANT Range::PrintPreview()
{
	VARIANT result;
	InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Range_(const VARIANT& Cell1, const VARIANT& Cell2)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xc5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Cell1, &Cell2);
	return result;
}

VARIANT Range::RemoveSubtotal()
{
	VARIANT result;
	InvokeHelper(0x373, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Replace(const VARIANT& What, const VARIANT& Replacement, const VARIANT& LookAt, const VARIANT& SearchOrder, const VARIANT& MatchCase, const VARIANT& MatchByte)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xe2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&What, &Replacement, &LookAt, &SearchOrder, &MatchCase, &MatchByte);
	return result;
}

VARIANT Range::Resize(const VARIANT& RowSize, const VARIANT& ColumnSize)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x100, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowSize, &ColumnSize);
	return result;
}

VARIANT Range::RowDifferences(const VARIANT& Comparison)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ff, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Comparison);
	return result;
}


VARIANT Range::Rows(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x102, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Range::Run(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10, 
		const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20, 
		const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT 
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
	return result;
}

VARIANT Range::Select()
{
	VARIANT result;
	InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Show()
{
	VARIANT result;
	InvokeHelper(0x1f0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ShowDependents(const VARIANT& Remove)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x36d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Remove);
	return result;
}

VARIANT Range::ShowErrors()
{
	VARIANT result;
	InvokeHelper(0x36e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::ShowPrecedents(const VARIANT& Remove)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x36f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Remove);
	return result;
}

VARIANT Range::Sort(const VARIANT& Key1, const VARIANT& Order1, const VARIANT& Key2, const VARIANT& Type, const VARIANT& Order2, const VARIANT& Key3, const VARIANT& Order3, const VARIANT& Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, 
		const VARIANT& Orientation)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x370, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Key1, &Order1, &Key2, &Type, &Order2, &Key3, &Order3, &Header, &OrderCustom, &MatchCase, &Orientation);
	return result;
}

VARIANT Range::SortSpecial(const VARIANT& SortMethod, const VARIANT& Key1, const VARIANT& Order1, const VARIANT& Type, const VARIANT& Key2, const VARIANT& Order2, const VARIANT& Key3, const VARIANT& Order3, const VARIANT& Header, 
		const VARIANT& OrderCustom, const VARIANT& MatchCase, const VARIANT& Orientation)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x371, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&SortMethod, &Key1, &Order1, &Type, &Key2, &Order2, &Key3, &Order3, &Header, &OrderCustom, &MatchCase, &Orientation);
	return result;
}

VARIANT Range::SpecialCells(const VARIANT& Type, const VARIANT& Value)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x19a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Type, &Value);
	return result;
}

VARIANT Range::SubscribeTo(const VARIANT& Edition, const VARIANT& Format)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1e1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Edition, &Format);
	return result;
}

VARIANT Range::Subtotal(const VARIANT& GroupBy, const VARIANT& Function, const VARIANT& TotalList, const VARIANT& Replace, const VARIANT& PageBreaks, const VARIANT& SummaryBelowData)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x372, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&GroupBy, &Function, &TotalList, &Replace, &PageBreaks, &SummaryBelowData);
	return result;
}

VARIANT Range::Table(const VARIANT& RowInput, const VARIANT& ColumnInput)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1f1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowInput, &ColumnInput);
	return result;
}

VARIANT Range::TextToColumns(const VARIANT& Destination, const VARIANT& DataType, const VARIANT& TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, const VARIANT& Space, 
		const VARIANT& Other, const VARIANT& OtherChar, const VARIANT& FieldInfo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x410, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Destination, &DataType, &TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo);
	return result;
}

VARIANT Range::Ungroup()
{
	VARIANT result;
	InvokeHelper(0xf4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Range::Worksheet()
{
	VARIANT result;
	InvokeHelper(0x15c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Workbook properties

VARIANT Workbook::GetActiveChart()
{
	VARIANT result;
	GetProperty(0xb7, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetActiveChart(const VARIANT& propVal)
{
	SetProperty(0xb7, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetActiveSheet()
{
	VARIANT result;
	GetProperty(0x133, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetActiveSheet(const VARIANT& propVal)
{
	SetProperty(0x133, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetAuthor()
{
	VARIANT result;
	GetProperty(0x23e, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetAuthor(const VARIANT& propVal)
{
	SetProperty(0x23e, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetColors()
{
	VARIANT result;
	GetProperty(0x11e, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetColors(const VARIANT& propVal)
{
	SetProperty(0x11e, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetComments()
{
	VARIANT result;
	GetProperty(0x23f, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetComments(const VARIANT& propVal)
{
	SetProperty(0x23f, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetContainer()
{
	VARIANT result;
	GetProperty(0x4a6, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetContainer(const VARIANT& propVal)
{
	SetProperty(0x4a6, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetCreateBackup()
{
	VARIANT result;
	GetProperty(0x11f, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetCreateBackup(const VARIANT& propVal)
{
	SetProperty(0x11f, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetDate1904()
{
	VARIANT result;
	GetProperty(0x193, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetDate1904(const VARIANT& propVal)
{
	SetProperty(0x193, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetDisplayDrawingObjects()
{
	VARIANT result;
	GetProperty(0x194, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetDisplayDrawingObjects(const VARIANT& propVal)
{
	SetProperty(0x194, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetFileFormat()
{
	VARIANT result;
	GetProperty(0x120, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetFileFormat(const VARIANT& propVal)
{
	SetProperty(0x120, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetFullName()
{
	VARIANT result;
	GetProperty(0x121, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetFullName(const VARIANT& propVal)
{
	SetProperty(0x121, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetHasMailer()
{
	VARIANT result;
	GetProperty(0x3d0, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetHasMailer(const VARIANT& propVal)
{
	SetProperty(0x3d0, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetHasPassword()
{
	VARIANT result;
	GetProperty(0x122, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetHasPassword(const VARIANT& propVal)
{
	SetProperty(0x122, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetHasRoutingSlip()
{
	VARIANT result;
	GetProperty(0x3b6, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetHasRoutingSlip(const VARIANT& propVal)
{
	SetProperty(0x3b6, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetKeywords()
{
	VARIANT result;
	GetProperty(0x241, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetKeywords(const VARIANT& propVal)
{
	SetProperty(0x241, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetMailer()
{
	VARIANT result;
	GetProperty(0x3d3, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetMailer(const VARIANT& propVal)
{
	SetProperty(0x3d3, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetMultiUserEditing()
{
	VARIANT result;
	GetProperty(0x491, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetMultiUserEditing(const VARIANT& propVal)
{
	SetProperty(0x491, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetName()
{
	VARIANT result;
	GetProperty(0x6e, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetName(const VARIANT& propVal)
{
	SetProperty(0x6e, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetOnSave()
{
	VARIANT result;
	GetProperty(0x49a, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetOnSave(const VARIANT& propVal)
{
	SetProperty(0x49a, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetOnSheetActivate()
{
	VARIANT result;
	GetProperty(0x407, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetOnSheetActivate(const VARIANT& propVal)
{
	SetProperty(0x407, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetOnSheetDeactivate()
{
	VARIANT result;
	GetProperty(0x439, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetOnSheetDeactivate(const VARIANT& propVal)
{
	SetProperty(0x439, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetPath()
{
	VARIANT result;
	GetProperty(0x123, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetPath(const VARIANT& propVal)
{
	SetProperty(0x123, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetPrecisionAsDisplayed()
{
	VARIANT result;
	GetProperty(0x195, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetPrecisionAsDisplayed(const VARIANT& propVal)
{
	SetProperty(0x195, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetProtectStructure()
{
	VARIANT result;
	GetProperty(0x24c, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetProtectStructure(const VARIANT& propVal)
{
	SetProperty(0x24c, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetProtectWindows()
{
	VARIANT result;
	GetProperty(0x127, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetProtectWindows(const VARIANT& propVal)
{
	SetProperty(0x127, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetReadOnly()
{
	VARIANT result;
	GetProperty(0x128, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetReadOnly(const VARIANT& propVal)
{
	SetProperty(0x128, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetReadOnlyRecommended()
{
	VARIANT result;
	GetProperty(0x129, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetReadOnlyRecommended(const VARIANT& propVal)
{
	SetProperty(0x129, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetRevisionNumber()
{
	VARIANT result;
	GetProperty(0x494, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetRevisionNumber(const VARIANT& propVal)
{
	SetProperty(0x494, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetRouted()
{
	VARIANT result;
	GetProperty(0x3b7, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetRouted(const VARIANT& propVal)
{
	SetProperty(0x3b7, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetRoutingSlip()
{
	VARIANT result;
	GetProperty(0x3b5, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetRoutingSlip(const VARIANT& propVal)
{
	SetProperty(0x3b5, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetSaved()
{
	VARIANT result;
	GetProperty(0x12a, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetSaved(const VARIANT& propVal)
{
	SetProperty(0x12a, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetSaveLinkValues()
{
	VARIANT result;
	GetProperty(0x196, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetSaveLinkValues(const VARIANT& propVal)
{
	SetProperty(0x196, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetShowConflictHistory()
{
	VARIANT result;
	GetProperty(0x493, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetShowConflictHistory(const VARIANT& propVal)
{
	SetProperty(0x493, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetSubject()
{
	VARIANT result;
	GetProperty(0x3b9, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetSubject(const VARIANT& propVal)
{
	SetProperty(0x3b9, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetTitle()
{
	VARIANT result;
	GetProperty(0xc7, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetTitle(const VARIANT& propVal)
{
	SetProperty(0xc7, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetUpdateRemoteReferences()
{
	VARIANT result;
	GetProperty(0x19b, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetUpdateRemoteReferences(const VARIANT& propVal)
{
	SetProperty(0x19b, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetUserStatus()
{
	VARIANT result;
	GetProperty(0x495, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetUserStatus(const VARIANT& propVal)
{
	SetProperty(0x495, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetWriteReserved()
{
	VARIANT result;
	GetProperty(0x12b, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetWriteReserved(const VARIANT& propVal)
{
	SetProperty(0x12b, VT_VARIANT, &propVal);
}

VARIANT Workbook::GetWriteReservedBy()
{
	VARIANT result;
	GetProperty(0x12c, VT_VARIANT, (void*)&result);
	return result;
}

void Workbook::SetWriteReservedBy(const VARIANT& propVal)
{
	SetProperty(0x12c, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Workbook operations

VARIANT Workbook::Activate()
{
	VARIANT result;
	InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::Application()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::BuiltinDocumentProperties(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x498, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::ChangeFileAccess(const VARIANT& Mode, const VARIANT& WritePassword, const VARIANT& Notify)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x3dd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Mode, &WritePassword, &Notify);
	return result;
}

VARIANT Workbook::ChangeLink(const VARIANT& Name, const VARIANT& NewName, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x322, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &NewName, &Type);
	return result;
}

VARIANT Workbook::Charts(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x79, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Close(const VARIANT& SaveChanges, const VARIANT& Filename, const VARIANT& RouteWorkbook)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x115, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&SaveChanges, &Filename, &RouteWorkbook);
	return result;
}

VARIANT Workbook::CustomDocumentProperties(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x499, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::DeleteNumberFormat(const VARIANT& NumberFormat)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x18d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&NumberFormat);
	return result;
}

VARIANT Workbook::DialogSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2fc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Excel4IntlMacroSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x245, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Excel4MacroSheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x243, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::ExclusiveAccess()
{
	VARIANT result;
	InvokeHelper(0x490, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::ForwardMailer()
{
	VARIANT result;
	InvokeHelper(0x3cd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::LinkInfo(const VARIANT& Name, const VARIANT& LinkInfo, const VARIANT& Type, const VARIANT& EditionRef)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x327, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &LinkInfo, &Type, &EditionRef);
	return result;
}

VARIANT Workbook::LinkSources(const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x328, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Type);
	return result;
}

VARIANT Workbook::Modules(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x246, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Names(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1ba, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index, &IndexLocal, &RefersTo);
	return result;
}

VARIANT Workbook::NewWindow()
{
	VARIANT result;
	InvokeHelper(0x118, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::OpenLinks(const VARIANT& Name, const VARIANT& ReadOnly, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x323, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &ReadOnly, &Type);
	return result;
}

VARIANT Workbook::Post(const VARIANT& DestName)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x48e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&DestName);
	return result;
}

VARIANT Workbook::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate);
	return result;
}

VARIANT Workbook::PrintPreview()
{
	VARIANT result;
	InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::Protect(const VARIANT& Password, const VARIANT& Structure, const VARIANT& Windows)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x11a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Password, &Structure, &Windows);
	return result;
}

VARIANT Workbook::Reply()
{
	VARIANT result;
	InvokeHelper(0x3d1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::ReplyAll()
{
	VARIANT result;
	InvokeHelper(0x3d2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::Route()
{
	VARIANT result;
	InvokeHelper(0x3b2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::RunAutoMacros(const VARIANT& Which)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x27a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Which);
	return result;
}

VARIANT Workbook::Save()
{
	VARIANT result;
	InvokeHelper(0x11b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::SaveAs(const VARIANT& Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& AccessMode, 
		const VARIANT& ConflictResolution)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x11c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &AccessMode, &ConflictResolution);
	return result;
}

VARIANT Workbook::SaveCopyAs(const VARIANT& Filename)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xaf, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename);
	return result;
}

VARIANT Workbook::SendMail(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ReturnReceipt)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x3b3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Recipients, &Subject, &ReturnReceipt);
	return result;
}

VARIANT Workbook::SendMailer(const VARIANT& FileFormat, const VARIANT& Priority)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x3d4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&FileFormat, &Priority);
	return result;
}

VARIANT Workbook::SetLinkOnData(const VARIANT& Name, const VARIANT& Procedure)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x329, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &Procedure);
	return result;
}

VARIANT Workbook::Sheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1e5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Styles(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ed, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Unprotect(const VARIANT& Password)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x11d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Password);
	return result;
}

VARIANT Workbook::UpdateFromFile()
{
	VARIANT result;
	InvokeHelper(0x3e3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbook::UpdateLink(const VARIANT& Name, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x324, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name, &Type);
	return result;
}

VARIANT Workbook::Windows(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ae, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbook::Worksheets(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1ee, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Workbooks properties

VARIANT Workbooks::GetCount()
{
	VARIANT result;
	GetProperty(0x76, VT_VARIANT, (void*)&result);
	return result;
}

void Workbooks::SetCount(const VARIANT& propVal)
{
	SetProperty(0x76, VT_VARIANT, &propVal);
}

VARIANT Workbooks::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Workbooks::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Workbooks::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Workbooks::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Workbooks operations

VARIANT Workbooks::_NewEnum()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbooks::Add(const VARIANT& Template)
{
	VARIANT result;
	static BYTE parms[] = VTS_VARIANT;
	InvokeHelper(0xb5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Template);
	return result;
}

VARIANT Workbooks::Application()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbooks::Close()
{
	VARIANT result;
	InvokeHelper(0x115, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Workbooks::Item(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xaa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Workbooks::Open(const VARIANT& Filename, const VARIANT& UpdateLinks, const VARIANT& ReadOnly, const VARIANT& Format, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& IgnoreReadOnlyRecommended, const VARIANT& Origin, 
		const VARIANT& Delimiter, const VARIANT& Editable, const VARIANT& Notify, const VARIANT& Converter)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2aa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename, &UpdateLinks, &ReadOnly, &Format, &Password, &WriteResPassword, &IgnoreReadOnlyRecommended, &Origin, &Delimiter, &Editable, &Notify, &Converter);
	return result;
}

VARIANT Workbooks::OpenText(const VARIANT& Filename, const VARIANT& Origin, const VARIANT& StartRow, const VARIANT& DataType, const VARIANT& TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, 
		const VARIANT& Comma, const VARIANT& Space, const VARIANT& Other, const VARIANT& OtherChar, const VARIANT& FieldInfo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2ab, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename, &Origin, &StartRow, &DataType, &TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Worksheet properties

VARIANT Worksheet::GetAutoFilterMode()
{
	VARIANT result;
	GetProperty(0x318, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetAutoFilterMode(const VARIANT& propVal)
{
	SetProperty(0x318, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetCircularReference()
{
	VARIANT result;
	GetProperty(0x42d, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetCircularReference(const VARIANT& propVal)
{
	SetProperty(0x42d, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetConsolidationFunction()
{
	VARIANT result;
	GetProperty(0x315, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetConsolidationFunction(const VARIANT& propVal)
{
	SetProperty(0x315, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetConsolidationOptions()
{
	VARIANT result;
	GetProperty(0x316, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetConsolidationOptions(const VARIANT& propVal)
{
	SetProperty(0x316, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetConsolidationSources()
{
	VARIANT result;
	GetProperty(0x317, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetConsolidationSources(const VARIANT& propVal)
{
	SetProperty(0x317, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetDisplayAutomaticPageBreaks()
{
	VARIANT result;
	GetProperty(0x283, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetDisplayAutomaticPageBreaks(const VARIANT& propVal)
{
	SetProperty(0x283, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetEnableAutoFilter()
{
	VARIANT result;
	GetProperty(0x484, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetEnableAutoFilter(const VARIANT& propVal)
{
	SetProperty(0x484, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetEnableOutlining()
{
	VARIANT result;
	GetProperty(0x485, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetEnableOutlining(const VARIANT& propVal)
{
	SetProperty(0x485, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetEnablePivotTable()
{
	VARIANT result;
	GetProperty(0x486, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetEnablePivotTable(const VARIANT& propVal)
{
	SetProperty(0x486, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetFilterMode()
{
	VARIANT result;
	GetProperty(0x320, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetFilterMode(const VARIANT& propVal)
{
	SetProperty(0x320, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetIndex()
{
	VARIANT result;
	GetProperty(0x1e6, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetIndex(const VARIANT& propVal)
{
	SetProperty(0x1e6, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetName()
{
	VARIANT result;
	GetProperty(0x6e, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetName(const VARIANT& propVal)
{
	SetProperty(0x6e, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetNext()
{
	VARIANT result;
	GetProperty(0x1f6, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetNext(const VARIANT& propVal)
{
	SetProperty(0x1f6, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnCalculate()
{
	VARIANT result;
	GetProperty(0x271, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnCalculate(const VARIANT& propVal)
{
	SetProperty(0x271, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnData()
{
	VARIANT result;
	GetProperty(0x275, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnData(const VARIANT& propVal)
{
	SetProperty(0x275, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnDoubleClick()
{
	VARIANT result;
	GetProperty(0x274, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnDoubleClick(const VARIANT& propVal)
{
	SetProperty(0x274, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnEntry()
{
	VARIANT result;
	GetProperty(0x273, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnEntry(const VARIANT& propVal)
{
	SetProperty(0x273, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnSheetActivate()
{
	VARIANT result;
	GetProperty(0x407, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnSheetActivate(const VARIANT& propVal)
{
	SetProperty(0x407, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOnSheetDeactivate()
{
	VARIANT result;
	GetProperty(0x439, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOnSheetDeactivate(const VARIANT& propVal)
{
	SetProperty(0x439, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetOutline()
{
	VARIANT result;
	GetProperty(0x66, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetOutline(const VARIANT& propVal)
{
	SetProperty(0x66, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetPageSetup()
{
	VARIANT result;
	GetProperty(0x3e6, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetPageSetup(const VARIANT& propVal)
{
	SetProperty(0x3e6, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetPrevious()
{
	VARIANT result;
	GetProperty(0x1f7, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetPrevious(const VARIANT& propVal)
{
	SetProperty(0x1f7, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetProtectContents()
{
	VARIANT result;
	GetProperty(0x124, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetProtectContents(const VARIANT& propVal)
{
	SetProperty(0x124, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetProtectDrawingObjects()
{
	VARIANT result;
	GetProperty(0x125, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetProtectDrawingObjects(const VARIANT& propVal)
{
	SetProperty(0x125, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetProtectionMode()
{
	VARIANT result;
	GetProperty(0x487, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetProtectionMode(const VARIANT& propVal)
{
	SetProperty(0x487, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetProtectScenarios()
{
	VARIANT result;
	GetProperty(0x126, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetProtectScenarios(const VARIANT& propVal)
{
	SetProperty(0x126, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetStandardHeight()
{
	VARIANT result;
	GetProperty(0x197, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetStandardHeight(const VARIANT& propVal)
{
	SetProperty(0x197, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetStandardWidth()
{
	VARIANT result;
	GetProperty(0x198, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetStandardWidth(const VARIANT& propVal)
{
	SetProperty(0x198, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetTransitionExpEval()
{
	VARIANT result;
	GetProperty(0x191, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetTransitionExpEval(const VARIANT& propVal)
{
	SetProperty(0x191, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetTransitionFormEntry()
{
	VARIANT result;
	GetProperty(0x192, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetTransitionFormEntry(const VARIANT& propVal)
{
	SetProperty(0x192, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetType()
{
	VARIANT result;
	GetProperty(0x6c, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetType(const VARIANT& propVal)
{
	SetProperty(0x6c, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetUsedRange()
{
	VARIANT result;
	GetProperty(0x19c, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetUsedRange(const VARIANT& propVal)
{
	SetProperty(0x19c, VT_VARIANT, &propVal);
}

VARIANT Worksheet::GetVisible()
{
	VARIANT result;
	GetProperty(0x22e, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheet::SetVisible(const VARIANT& propVal)
{
	SetProperty(0x22e, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Worksheet operations

VARIANT Worksheet::Activate()
{
	VARIANT result;
	InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Application()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Arcs(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2f8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Buttons(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x22d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Calculate()
{
	VARIANT result;
	InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Cells(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xee, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&RowIndex, &ColumnIndex);
	return result;
}

VARIANT Worksheet::ChartObjects(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x424, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::CheckBoxes(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x338, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&CustomDictionary, &IgnoreUppercase, &AlwaysSuggest);
	return result;
}

VARIANT Worksheet::ClearArrows()
{
	VARIANT result;
	InvokeHelper(0x3ca, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Columns(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xf1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Copy(const VARIANT& Before, const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Before, &After);
	return result;
}

VARIANT Worksheet::Delete()
{
	VARIANT result;
	InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::DrawingObjects(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x58, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Drawings(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x304, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::DropDowns(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x344, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::_Evaluate(const VARIANT& Name)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name);
	return result;
}

VARIANT Worksheet::Evaluate(const VARIANT& Name)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xfffffffb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Name);
	return result;
}

VARIANT Worksheet::GroupBoxes(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x342, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::GroupObjects(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x459, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Labels(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x349, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Lines(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2ff, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::ListBoxes(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x340, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Move(const VARIANT& Before, const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x27d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Before, &After);
	return result;
}

VARIANT Worksheet::Names(const VARIANT& Index, const VARIANT& IndexLocal, const VARIANT& RefersTo)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1ba, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index, &IndexLocal, &RefersTo);
	return result;
}

VARIANT Worksheet::OLEObjects(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x31f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::OptionButtons(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x33a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Ovals(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x321, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Paste(const VARIANT& Destination, const VARIANT& Link)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xd3, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Destination, &Link);
	return result;
}

VARIANT Worksheet::PasteSpecial(const VARIANT& Format, const VARIANT& Link, const VARIANT& DisplayAsIcon, const VARIANT& IconFileName, const VARIANT& IconIndex, const VARIANT& IconLabel)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x403, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Format, &Link, &DisplayAsIcon, &IconFileName, &IconIndex, &IconLabel);
	return result;
}

VARIANT Worksheet::Pictures(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x303, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::PivotTables(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x2b2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::PivotTableWizard(const VARIANT& SourceType, const VARIANT& SourceData, const VARIANT& TableDestination, const VARIANT& TableName, const VARIANT& RowGrand, const VARIANT& ColumnGrand, const VARIANT& SaveData, 
		const VARIANT& HasAutoFormat, const VARIANT& AutoPage, const VARIANT& Reserved)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2ac, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&SourceType, &SourceData, &TableDestination, &TableName, &RowGrand, &ColumnGrand, &SaveData, &HasAutoFormat, &AutoPage, &Reserved);
	return result;
}

VARIANT Worksheet::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate);
	return result;
}

VARIANT Worksheet::PrintPreview()
{
	VARIANT result;
	InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Protect(const VARIANT& Password, const VARIANT& DrawingObjects, const VARIANT& Contents, const VARIANT& Scenarios, const VARIANT& UserInterfaceOnly)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x11a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Password, &DrawingObjects, &Contents, &Scenarios, &UserInterfaceOnly);
	return result;
}

VARIANT Worksheet::Range(const VARIANT& Cell1, const VARIANT& Cell2)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xc5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Cell1, &Cell2);
	return result;
}

VARIANT Worksheet::Rectangles(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x306, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Rows(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x102, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::SaveAs(const VARIANT& Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x11c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup);
	return result;
}

VARIANT Worksheet::Scenarios(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x38c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::ScrollBars(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x33e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Select(const VARIANT& Replace)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Replace);
	return result;
}

VARIANT Worksheet::SetBackgroundPicture(const VARIANT& Filename)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x4a4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Filename);
	return result;
}

VARIANT Worksheet::ShowAllData()
{
	VARIANT result;
	InvokeHelper(0x31a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::ShowDataForm()
{
	VARIANT result;
	InvokeHelper(0x199, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheet::Spinners(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x346, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::TextBoxes(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x309, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheet::Unprotect(const VARIANT& Password)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x11d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Password);
	return result;
}


/////////////////////////////////////////////////////////////////////////////
// Worksheets properties

VARIANT Worksheets::GetCount()
{
	VARIANT result;
	GetProperty(0x76, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheets::SetCount(const VARIANT& propVal)
{
	SetProperty(0x76, VT_VARIANT, &propVal);
}

VARIANT Worksheets::GetCreator()
{
	VARIANT result;
	GetProperty(0x95, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheets::SetCreator(const VARIANT& propVal)
{
	SetProperty(0x95, VT_VARIANT, &propVal);
}

VARIANT Worksheets::GetParent()
{
	VARIANT result;
	GetProperty(0x96, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheets::SetParent(const VARIANT& propVal)
{
	SetProperty(0x96, VT_VARIANT, &propVal);
}

VARIANT Worksheets::GetVisible()
{
	VARIANT result;
	GetProperty(0x22e, VT_VARIANT, (void*)&result);
	return result;
}

void Worksheets::SetVisible(const VARIANT& propVal)
{
	SetProperty(0x22e, VT_VARIANT, &propVal);
}

/////////////////////////////////////////////////////////////////////////////
// Worksheets operations

VARIANT Worksheets::_NewEnum()
{
	VARIANT result;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheets::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xb5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Before, &After, &Count, &Type);
	return result;
}

VARIANT Worksheets::Application()
{
	VARIANT result;
	InvokeHelper(0x94, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheets::Copy(const VARIANT& Before, const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Before, &After);
	return result;
}

VARIANT Worksheets::Delete()
{
	VARIANT result;
	InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheets::FillAcrossSheets(const VARIANT& Range, const VARIANT& Type)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1d5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Range, &Type);
	return result;
}

VARIANT Worksheets::Item(const VARIANT& Index)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xaa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Index);
	return result;
}

VARIANT Worksheets::Move(const VARIANT& Before, const VARIANT& After)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x27d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Before, &After);
	return result;
}

VARIANT Worksheets::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate);
	return result;
}

VARIANT Worksheets::PrintPreview()
{
	VARIANT result;
	InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
	return result;
}

VARIANT Worksheets::Select(const VARIANT& Replace)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&Replace);
	return result;
}