PC World Komputer 1996 February/PCWK0296.iso/abcflow/abc/samples/ole_vbx/abcauto.cpp

C/C++ Source or Header | 1995-01-25 | 97KB | 4,204 lines

// Machine generated IDispatch driver class(es) created with ClassWizard.

#include "stdafx.h"
#include "abcauto.h"

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

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

LPDISPATCH Application::GetActiveChart()
{
    LPDISPATCH result;
    InvokeHelper(0x60010016, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

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

void Application::SetCaption(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Application::GetCaption()
{
    CString result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

LPDISPATCH Application::GetCharts()
{
    LPDISPATCH result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Application::SetDefaultFilePath(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010088, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Application::GetDefaultFilePath()
{
    CString result;
    InvokeHelper(0x60010088, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Application::SetIndexVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600100ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Application::GetIndexVisible()
{
    BOOL result;
    InvokeHelper(0x600100ba, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long Application::GetIndexWindowHandle()
{
    long result;
    InvokeHelper(0x600100ea, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Application::SetFieldViewerVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010100, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Application::GetFieldViewerVisible()
{
    BOOL result;
    InvokeHelper(0x60010100, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long Application::GetFieldViewerWindowHandle()
{
    long result;
    InvokeHelper(0x60010130, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString Application::GetFullName()
{
    CString result;
    InvokeHelper(0x60010146, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Application::SetHeight(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x6001015c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

void Application::SetHourGlass(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001018c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Application::GetHourGlass()
{
    BOOL result;
    InvokeHelper(0x6001018c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void Application::SetNoteViewerVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600101d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Application::GetNoteViewerVisible()
{
    BOOL result;
    InvokeHelper(0x600101d2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long Application::GetNoteViewerWindowHandle()
{
    long result;
    InvokeHelper(0x60010202, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString Application::GetOperatingSystem()
{
    CString result;
    InvokeHelper(0x60010218, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Application::SetShapePaletteVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001022e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Application::GetShapePaletteVisible()
{
    BOOL result;
    InvokeHelper(0x6001022e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long Application::GetShapePaletteWindowHandle()
{
    long result;
    InvokeHelper(0x60010260, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void Application::SetPercentGaugeValue(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Application::GetPercentGaugeValue()
{
    short result;
    InvokeHelper(0x600102a2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

LPDISPATCH Application::GetPreferences()
{
    LPDISPATCH result;
    InvokeHelper(0x600102d2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Application::SetPrinter(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600102e8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Application::GetPrinter()
{
    CString result;
    InvokeHelper(0x600102e8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Application::SetLeft(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x6001031a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

void Application::SetRight(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010334, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

void Application::SetTop(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x6001034e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

void Application::SetBottom(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010368, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

long Application::GetRight()
{
    long result;
    InvokeHelper(0x60010334, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

long Application::GetBottom()
{
    long result;
    InvokeHelper(0x60010368, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Application::SetStatusBar(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600103dc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Application::GetStatusBar()
{
    CString result;
    InvokeHelper(0x600103dc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

void Application::SetVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010422, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

void Application::SetWidth(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010452, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

long Application::GetWindowHandle()
{
    long result;
    InvokeHelper(0x60010482, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL Application::GetUndoAvailable()
{
    BOOL result;
    InvokeHelper(0x60010498, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long Application::GetWhite()
{
    long result;
    InvokeHelper(0x600104ae, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetBlack()
{
    long result;
    InvokeHelper(0x600104c4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetRed()
{
    long result;
    InvokeHelper(0x600104da, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetGreen()
{
    long result;
    InvokeHelper(0x600104f0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetBlue()
{
    long result;
    InvokeHelper(0x60010506, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetYellow()
{
    long result;
    InvokeHelper(0x6001051c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetMagenta()
{
    long result;
    InvokeHelper(0x60010532, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetCyan()
{
    long result;
    InvokeHelper(0x60010548, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetGray()
{
    long result;
    InvokeHelper(0x60010560, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_red()
{
    long result;
    InvokeHelper(0x60010576, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_green()
{
    long result;
    InvokeHelper(0x6001058c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_blue()
{
    long result;
    InvokeHelper(0x600105a2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_yellow()
{
    long result;
    InvokeHelper(0x600105b8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_magenta()
{
    long result;
    InvokeHelper(0x600105ce, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_cyan()
{
    long result;
    InvokeHelper(0x600105e4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetDk_gray()
{
    long result;
    InvokeHelper(0x600105fa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long Application::GetBasicColor(short ColorIndex)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010610, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
        ColorIndex);
    return result;
}

BOOL Application::CreateAddOn(short Index, const char* Description, const char* FullAppPath, const VARIANT& FullIconPath, const VARIANT& Flags)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x6001062a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, Description, FullAppPath, &FullIconPath, &Flags);
    return result;
}

BOOL Application::RemoveAddOn(const VARIANT& Key)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x60010654, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &Key);
    return result;
}

void Application::Activate()
{
    InvokeHelper(0x6001066e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::ArrangeIcons()
{
    InvokeHelper(0x60010684, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::CascadeCharts()
{
    InvokeHelper(0x6001069a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::CloseAll()
{
    InvokeHelper(0x600106b0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Help(const VARIANT& helpfile, const VARIANT& helpcontextID)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x600106c6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &helpfile, &helpcontextID);
}

void Application::Hint(const char* Hint)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600106e4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Hint);
}

LPDISPATCH Application::New()
{
    LPDISPATCH result;
    InvokeHelper(0x60010700, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Application::NewFromTemplate(const char* filename)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010716, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        filename);
    return result;
}

LPDISPATCH Application::Open(const char* pathname, const VARIANT& AsReadOnly)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x60010730, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        pathname, &AsReadOnly);
    return result;
}

LPDISPATCH Application::AddMenu(const char* PopupName, LPDISPATCH VBXToNotify, const char* NotifyConsumerName, const VARIANT& ChartClass)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_DISPATCH VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x6001074e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        PopupName, VBXToNotify, NotifyConsumerName, &ChartClass);
    return result;
}

void Application::RemoveMenu(const char* PopupName)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010774, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         PopupName);
}

void Application::Quit()
{
    InvokeHelper(0x6001078e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long Application::MakeRGB(short RED, short GREEN, short BLUE)
{
    long result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_I2 VTS_I2;
    InvokeHelper(0x600107a4, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        RED, GREEN, BLUE);
    return result;
}

void Application::Restore()
{
    InvokeHelper(0x600107c6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Minimize()
{
    InvokeHelper(0x600107dc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Maximize()
{
    InvokeHelper(0x600107f2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

short Application::MsgBox(const char* Message, const VARIANT& Type, const VARIANT& Title)
{
    short result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010808, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
        Message, &Type, &Title);
    return result;
}

void Application::PercentGauge(const VARIANT& Title, const VARIANT& TextLine1, const VARIANT& TextLine2)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x6001082c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &Title, &TextLine1, &TextLine2);
}

void Application::HidePercentGauge()
{
    InvokeHelper(0x6001084e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Application::PercentGaugeCancelled()
{
    BOOL result;
    InvokeHelper(0x60010864, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Application::TileCharts()
{
    InvokeHelper(0x6001087a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Application::Undo()
{
    InvokeHelper(0x60010890, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Application::RegisterEvent(LPDISPATCH VBX, const char* ConsumerName, const char* EventName, const VARIANT& ChartType)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_BSTR VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x600108a6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBX, ConsumerName, EventName, &ChartType);
    return result;
}

void Application::ChartTypeShutdown(const char* ChartType, const char* ConsumerName)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_BSTR;
    InvokeHelper(0x600108cc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         ChartType, ConsumerName);
}

BOOL Application::UnRegisterEvent(LPDISPATCH VBX, const VARIANT& EventName, const VARIANT& ChartClass)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x600108ea, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBX, &EventName, &ChartClass);
    return result;
}

BOOL Application::_UnRegAll(LPDISPATCH VBX)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x6001090c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        VBX);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Chart properties

/////////////////////////////////////////////////////////////////////////////
// Chart operations

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

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

BOOL Chart::ClipboardFormatAvailable(short Format)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010042, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Format);
    return result;
}

void Chart::SetCurrentLineRouting(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001005c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetCurrentLineRouting()
{
    short result;
    InvokeHelper(0x6001005c, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetCurrentShape(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6001008c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetCurrentShape()
{
    CString result;
    InvokeHelper(0x6001008c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetCurrentShapePalette(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600100bc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetCurrentShapePalette()
{
    CString result;
    InvokeHelper(0x600100bc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetDrawDirection(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100ec, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetDrawDirection()
{
    short result;
    InvokeHelper(0x600100ec, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetDrawPositionX(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001011c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetDrawPositionX()
{
    double result;
    InvokeHelper(0x6001011c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Chart::SetDrawPositionY(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001014c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetDrawPositionY()
{
    double result;
    InvokeHelper(0x6001014c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Chart::SetDrawSpacingX(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001017c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetDrawSpacingX()
{
    double result;
    InvokeHelper(0x6001017c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Chart::SetDrawSpacingY(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600101ac, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetDrawSpacingY()
{
    double result;
    InvokeHelper(0x600101ac, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetFieldTemplates()
{
    LPDISPATCH result;
    InvokeHelper(0x600101dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetFieldFont()
{
    LPDISPATCH result;
    InvokeHelper(0x600101f2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Chart::SetFieldPlacement(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010208, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetFieldPlacement()
{
    short result;
    InvokeHelper(0x60010208, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetFieldNamesHidden(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001023a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetFieldNamesHidden()
{
    BOOL result;
    InvokeHelper(0x6001023a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetFieldsOpaque(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001026a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetFieldsOpaque()
{
    BOOL result;
    InvokeHelper(0x6001026a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetFieldsDaysPerWeek(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001029a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetFieldsDaysPerWeek()
{
    short result;
    InvokeHelper(0x6001029a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetFieldsHoursPerDay(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102ca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetFieldsHoursPerDay()
{
    short result;
    InvokeHelper(0x600102ca, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

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

void Chart::SetGuidelinesOn(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010310, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetGuidelinesOn()
{
    BOOL result;
    InvokeHelper(0x60010310, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::GetHasDiskFile()
{
    BOOL result;
    InvokeHelper(0x60010340, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetLaunchShadow(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010356, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetLaunchShadow()
{
    BOOL result;
    InvokeHelper(0x60010356, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetLaunchIndicator(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010386, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetLaunchIndicator()
{
    CString result;
    InvokeHelper(0x60010386, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetLineCrossoverStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600103b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetLineCrossoverStyle()
{
    short result;
    InvokeHelper(0x600103b6, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetLineCrossoverSize(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600103e6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetLineCrossoverSize()
{
    short result;
    InvokeHelper(0x600103e6, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetLinkShadow(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010416, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetLinkShadow()
{
    BOOL result;
    InvokeHelper(0x60010416, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetLinkIndicator(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010446, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetLinkIndicator()
{
    CString result;
    InvokeHelper(0x60010446, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetMasterItems()
{
    LPDISPATCH result;
    InvokeHelper(0x60010476, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

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

void Chart::SetNoteShadow(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600104a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetNoteShadow()
{
    BOOL result;
    InvokeHelper(0x600104a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetNoteIndicator(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600104d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetNoteIndicator()
{
    CString result;
    InvokeHelper(0x600104d2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetNoRepaint(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010502, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetNoRepaint()
{
    BOOL result;
    InvokeHelper(0x60010502, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetNextNumber(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010532, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetNextNumber()
{
    CString result;
    InvokeHelper(0x60010532, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetNextShapeHeight(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010562, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetNextShapeHeight()
{
    double result;
    InvokeHelper(0x60010562, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Chart::SetNextShapeWidth(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010592, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetNextShapeWidth()
{
    double result;
    InvokeHelper(0x60010592, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetNumberFont()
{
    LPDISPATCH result;
    InvokeHelper(0x600105c2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetObjects()
{
    LPDISPATCH result;
    InvokeHelper(0x600105d8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

short Chart::GetPageCount()
{
    short result;
    InvokeHelper(0x600105ee, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GetPageLayout()
{
    LPDISPATCH result;
    InvokeHelper(0x60010604, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

BOOL Chart::GetProtected()
{
    BOOL result;
    InvokeHelper(0x6001061a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::GetReadOnly()
{
    BOOL result;
    InvokeHelper(0x60010630, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::GetSaved()
{
    BOOL result;
    InvokeHelper(0x60010646, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetScrollLeft(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001065c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetScrollLeft()
{
    double result;
    InvokeHelper(0x6001065c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Chart::SetScrollTop(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001068c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Chart::GetScrollTop()
{
    double result;
    InvokeHelper(0x6001068c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

short Chart::GetSelectedShapeCount()
{
    short result;
    InvokeHelper(0x600106bc, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

short Chart::GetSelectedLineCount()
{
    short result;
    InvokeHelper(0x600106d2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

short Chart::GetSelectedObjectCount()
{
    short result;
    InvokeHelper(0x600106e8, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

short Chart::GetSelectedOtherCount()
{
    short result;
    InvokeHelper(0x60010700, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetShowNodesOnLines(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010716, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetShowNodesOnLines()
{
    BOOL result;
    InvokeHelper(0x60010716, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetShowLegend(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010746, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetShowLegend()
{
    BOOL result;
    InvokeHelper(0x60010746, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetType(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010776, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Chart::GetType()
{
    CString result;
    InvokeHelper(0x60010776, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Chart::SetTypeRequiresEXE(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600107a6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetTypeRequiresEXE()
{
    BOOL result;
    InvokeHelper(0x600107a6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetTypeUsesEXE(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600107d6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Chart::GetTypeUsesEXE()
{
    BOOL result;
    InvokeHelper(0x600107d6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetUnits(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010806, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetUnits()
{
    short result;
    InvokeHelper(0x60010806, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

BOOL Chart::GetValid()
{
    BOOL result;
    InvokeHelper(0x60010836, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::SetView(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001084c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetView()
{
    short result;
    InvokeHelper(0x6001084c, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Chart::SetZoomPercentage(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001087c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Chart::GetZoomPercentage()
{
    short result;
    InvokeHelper(0x6001087c, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

long Chart::GetWindowHandle()
{
    long result;
    InvokeHelper(0x600108ac, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Chart::Activate()
{
    InvokeHelper(0x600108c2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::AddHorizontalGuideline(double VertPos)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600108d8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         VertPos);
}

void Chart::AddVerticalGuideline(double HorzPos)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600108f2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         HorzPos);
}

BOOL Chart::Clear_()
{
    BOOL result;
    InvokeHelper(0x6001090c, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::ClearGuidelines()
{
    InvokeHelper(0x60010922, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::Close()
{
    InvokeHelper(0x60010938, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::CloseChart()
{
    InvokeHelper(0x6001094e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Copy()
{
    BOOL result;
    InvokeHelper(0x60010964, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Chart::Cut()
{
    BOOL result;
    InvokeHelper(0x6001097a, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::DeselectAll()
{
    InvokeHelper(0x60010990, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Duplicate()
{
    BOOL result;
    InvokeHelper(0x600109a6, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Chart::GroupAndLink(const VARIANT& filename, const VARIANT& LinkFields)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x600109bc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &filename, &LinkFields);
    return result;
}

LPDISPATCH Chart::DrawFreeLine(double ToX, double ToY)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x600109da, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        ToX, ToY);
    return result;
}

LPDISPATCH Chart::DrawLine(LPDISPATCH Source, LPDISPATCH Dest, const VARIANT& SourceFace, const VARIANT& DestFace)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x600109f8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Source, Dest, &SourceFace, &DestFace);
    return result;
}

LPDISPATCH Chart::DrawLineToOneObject(LPDISPATCH DestObject, const VARIANT& DestFace)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x60010a20, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        DestObject, &DestFace);
    return result;
}

LPDISPATCH Chart::DrawShape(const VARIANT& ShapeName)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x60010a40, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &ShapeName);
    return result;
}

LPDISPATCH Chart::DrawTextBlock(const char* Text)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010a5a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Text);
    return result;
}

LPDISPATCH Chart::InsertObjectFromFile(const char* filename, const VARIANT& bAsIcon, const VARIANT& bAsLink)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010a74, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        filename, &bAsIcon, &bAsLink);
    return result;
}

void Chart::Restore()
{
    InvokeHelper(0x60010a96, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::Minimize()
{
    InvokeHelper(0x60010aac, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::Maximize()
{
    InvokeHelper(0x60010ac2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Paste(const VARIANT& xPos, const VARIANT& yPos)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010ad8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &xPos, &yPos);
    return result;
}

BOOL Chart::PasteLink(const VARIANT& xPos, const VARIANT& yPos)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010af6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &xPos, &yPos);
    return result;
}

BOOL Chart::PasteSpecial(short Format, const VARIANT& AsIcon, const VARIANT& xPos, const VARIANT& yPos)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_I2 VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010b14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Format, &AsIcon, &xPos, &yPos);
    return result;
}

BOOL Chart::PrintOut(const VARIANT& FromPage, const VARIANT& ToPage, const VARIANT& NumCopies, const VARIANT& FitToPage, const VARIANT& PrintNotes)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010b3a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &FromPage, &ToPage, &NumCopies, &FitToPage, &PrintNotes);
    return result;
}

BOOL Chart::PrintSelected(const VARIANT& NumCopies, const VARIANT& FitToPage, const VARIANT& PrintNotes)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010b64, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &NumCopies, &FitToPage, &PrintNotes);
    return result;
}

void Chart::Repaint()
{
    InvokeHelper(0x60010b86, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::RevertToSaved()
{
    InvokeHelper(0x60010b9c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Chart::Save(const VARIANT& pathname, const VARIANT& Type)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x60010bb2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &pathname, &Type);
    return result;
}

void Chart::ScrollPage(short iPage)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010bd0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         iPage);
}

void Chart::ScrollPosition(double fPosX, double fPosY)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x60010bea, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         fPosX, fPosY);
}

void Chart::Select(short iSelect)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010c08, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         iSelect);
}

void Chart::SelectShapeType(const char* ShapeType)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010c24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         ShapeType);
}

void Chart::SetDefaults(LPDISPATCH Object)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x60010c40, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Object);
}

void Chart::SetProtection(BOOL bProtect, const char* Password)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL VTS_BSTR;
    InvokeHelper(0x60010c5a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         bProtect, Password);
}

BOOL Chart::SendMail()
{
    BOOL result;
    InvokeHelper(0x60010c78, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Chart::Spelling()
{
    InvokeHelper(0x60010c8e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::ToFront()
{
    InvokeHelper(0x60010ca4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::ToBack()
{
    InvokeHelper(0x60010cba, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::UpdateFields()
{
    InvokeHelper(0x60010cd0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::FullScreen()
{
    InvokeHelper(0x60010ce6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Chart::CancelFullScreen()
{
    InvokeHelper(0x60010cfc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// Charts properties

/////////////////////////////////////////////////////////////////////////////
// Charts operations

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

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

LPDISPATCH Charts::Add()
{
    LPDISPATCH result;
    InvokeHelper(0x60020042, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Charts::AddFromTemplate(const char* filename)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60020058, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        filename);
    return result;
}

LPDISPATCH Charts::Open(const char* filename, const VARIANT& AsReadOnly)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x60020072, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        filename, &AsReadOnly);
    return result;
}

void Charts::CloseAll()
{
    InvokeHelper(0x60020090, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long Charts::GetCount()
{
    long result;
    InvokeHelper(0x600200a6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH Charts::GetItem(const VARIANT& Index)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &Index);
    return result;
}

LPUNKNOWN Charts::Get_NewEnum()
{
    LPUNKNOWN result;
    InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Preferences properties

/////////////////////////////////////////////////////////////////////////////
// Preferences operations

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

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

void Preferences::SetAlignToRulers(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Preferences::GetAlignToRulers()
{
    short result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Preferences::SetChannelAlignment(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Preferences::GetChannelAlignment()
{
    BOOL result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Preferences::SetLineSpacingX(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Preferences::GetLineSpacingX()
{
    double result;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Preferences::SetLineSpacingY(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600100d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Preferences::GetLineSpacingY()
{
    double result;
    InvokeHelper(0x600100d2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Preferences::SetShapeSizing(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Preferences::GetShapeSizing()
{
    short result;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Preferences::SetShowRulers(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Preferences::GetShowRulers()
{
    BOOL result;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Preferences::SetSmartShapeSpacing(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Preferences::GetSmartShapeSpacing()
{
    BOOL result;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Preferences::SetSSSHorizontal(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Preferences::GetSSSHorizontal()
{
    double result;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Preferences::SetSSSVertical(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600101c2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Preferences::GetSSSVertical()
{
    double result;
    InvokeHelper(0x600101c2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Preferences::SetTouchAlignment(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600101f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Preferences::GetTouchAlignment()
{
    BOOL result;
    InvokeHelper(0x600101f2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Preferences::SetUnits(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010222, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Preferences::GetUnits()
{
    short result;
    InvokeHelper(0x60010222, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// PageLayout properties

/////////////////////////////////////////////////////////////////////////////
// PageLayout operations

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

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

void PageLayout::SetPageHeight(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetPageHeight()
{
    double result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double PageLayout::GetHeight()
{
    double result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void PageLayout::SetMarginBottom(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010088, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetMarginBottom()
{
    double result;
    InvokeHelper(0x60010088, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void PageLayout::SetMarginLeft(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600100ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetMarginLeft()
{
    double result;
    InvokeHelper(0x600100ba, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void PageLayout::SetMarginRight(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600100ea, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetMarginRight()
{
    double result;
    InvokeHelper(0x600100ea, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void PageLayout::SetMarginTop(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001011a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetMarginTop()
{
    double result;
    InvokeHelper(0x6001011a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void PageLayout::SetOrientation(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short PageLayout::GetOrientation()
{
    short result;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void PageLayout::SetPageOrder(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001017a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short PageLayout::GetPageOrder()
{
    short result;
    InvokeHelper(0x6001017a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void PageLayout::SetPaperSize(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600101aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString PageLayout::GetPaperSize()
{
    CString result;
    InvokeHelper(0x600101aa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void PageLayout::SetPrintBlankPages(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600101da, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL PageLayout::GetPrintBlankPages()
{
    BOOL result;
    InvokeHelper(0x600101da, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void PageLayout::SetPageWidth(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001020a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double PageLayout::GetPageWidth()
{
    double result;
    InvokeHelper(0x6001020a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double PageLayout::GetWidth()
{
    double result;
    InvokeHelper(0x6001023a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// MasterItems properties

/////////////////////////////////////////////////////////////////////////////
// MasterItems operations

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

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

LPDISPATCH MasterItems::GetChartName()
{
    LPDISPATCH result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetDate()
{
    LPDISPATCH result;
    InvokeHelper(0x60010058, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetLogo()
{
    LPDISPATCH result;
    InvokeHelper(0x6001006e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetPageNumber()
{
    LPDISPATCH result;
    InvokeHelper(0x60010084, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetText1()
{
    LPDISPATCH result;
    InvokeHelper(0x6001009a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetText2()
{
    LPDISPATCH result;
    InvokeHelper(0x600100b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH MasterItems::GetTime()
{
    LPDISPATCH result;
    InvokeHelper(0x600100c6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void MasterItems::SetDateStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100dc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short MasterItems::GetDateStyle()
{
    short result;
    InvokeHelper(0x600100dc, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void MasterItems::SetLogoPathname(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6001010c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString MasterItems::GetLogoPathname()
{
    CString result;
    InvokeHelper(0x6001010c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void MasterItems::SetRange(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001013c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short MasterItems::GetRange()
{
    short result;
    InvokeHelper(0x6001013c, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void MasterItems::SetChartNameShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001016c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetChartNameShown()
{
    BOOL result;
    InvokeHelper(0x6001016c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetDateShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001019c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetDateShown()
{
    BOOL result;
    InvokeHelper(0x6001019c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetLogoShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600101cc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetLogoShown()
{
    BOOL result;
    InvokeHelper(0x600101cc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetPageNumberShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600101fc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetPageNumberShown()
{
    BOOL result;
    InvokeHelper(0x600101fc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetTimeShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001022c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetTimeShown()
{
    BOOL result;
    InvokeHelper(0x6001022c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetText1Shown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001025c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetText1Shown()
{
    BOOL result;
    InvokeHelper(0x6001025c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::SetText2Shown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001028c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MasterItems::GetText2Shown()
{
    BOOL result;
    InvokeHelper(0x6001028c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MasterItems::HideAll()
{
    InvokeHelper(0x600102bc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void MasterItems::ShowAll()
{
    InvokeHelper(0x600102d2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void MasterItems::UpdateDateAndTime(const VARIANT& vDate, const VARIANT& vTime)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x600102e8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &vDate, &vTime);
}


/////////////////////////////////////////////////////////////////////////////
// Objects properties

/////////////////////////////////////////////////////////////////////////////
// Objects operations

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

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

long Objects::GetCount()
{
    long result;
    InvokeHelper(0x60020042, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromAttachments(LPDISPATCH Attachment1, const VARIANT& Attachment2)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x60020058, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Attachment1, &Attachment2);
    return result;
}

LPDISPATCH Objects::ItemFromAll()
{
    LPDISPATCH result;
    InvokeHelper(0x60020076, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromLines()
{
    LPDISPATCH result;
    InvokeHelper(0x6002008c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromUniqueID(long lUniqueID)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x600200a2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        lUniqueID);
    return result;
}

LPDISPATCH Objects::ItemFromNumber(const VARIANT& Number)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x600200bc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &Number);
    return result;
}

LPDISPATCH Objects::ItemFromText(const char* Text)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600200d6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Text);
    return result;
}

LPDISPATCH Objects::ItemFromSelection()
{
    LPDISPATCH result;
    InvokeHelper(0x600200f0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromShapes()
{
    LPDISPATCH result;
    InvokeHelper(0x60020106, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Objects::ItemFromFieldValue(LPDISPATCH FieldValue, const VARIANT& Value)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x6002011c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        FieldValue, &Value);
    return result;
}

void Objects::ResetSearch()
{
    InvokeHelper(0x6002013a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH Objects::GetItem(const VARIANT& Index)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &Index);
    return result;
}

LPUNKNOWN Objects::Get_NewEnum()
{
    LPUNKNOWN result;
    InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Object properties

/////////////////////////////////////////////////////////////////////////////
// Object operations

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

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

void Object::SetBottom(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetBottom()
{
    double result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Object::SetCenterX(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetCenterX()
{
    double result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Object::SetCenterY(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetCenterY()
{
    double result;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Object::SetColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x600100d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Object::GetColor()
{
    long result;
    InvokeHelper(0x600100d2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetFieldValues()
{
    LPDISPATCH result;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetFont()
{
    LPDISPATCH result;
    InvokeHelper(0x60010118, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Object::SetHeight(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001012e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetHeight()
{
    double result;
    InvokeHelper(0x6001012e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Object::SetLeft(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010160, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetLeft()
{
    double result;
    InvokeHelper(0x60010160, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetLine_()
{
    LPDISPATCH result;
    InvokeHelper(0x60010190, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetOle()
{
    LPDISPATCH result;
    InvokeHelper(0x600101a6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetTextBlock()
{
    LPDISPATCH result;
    InvokeHelper(0x600101bc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Object::SetRight(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x600101d2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetRight()
{
    double result;
    InvokeHelper(0x600101d2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Object::SetSelected(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010202, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Object::GetSelected()
{
    BOOL result;
    InvokeHelper(0x60010202, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::GetShape()
{
    LPDISPATCH result;
    InvokeHelper(0x60010232, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Object::SetStretchType(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010248, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Object::GetStretchType()
{
    short result;
    InvokeHelper(0x60010248, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Object::SetText(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6001027a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Object::GetText()
{
    CString result;
    InvokeHelper(0x6001027a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Object::SetTextLF(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600102aa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Object::GetTextLF()
{
    CString result;
    InvokeHelper(0x600102aa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Object::SetTextAlignment(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102da, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Object::GetTextAlignment()
{
    short result;
    InvokeHelper(0x600102da, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Object::SetTop(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001030a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetTop()
{
    double result;
    InvokeHelper(0x6001030a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

short Object::GetType()
{
    short result;
    InvokeHelper(0x6001033a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

long Object::GetUniqueID()
{
    long result;
    InvokeHelper(0x60010350, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL Object::GetValid()
{
    BOOL result;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Object::SetWidth(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x6001037c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Object::GetWidth()
{
    double result;
    InvokeHelper(0x6001037c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

BOOL Object::Clear_()
{
    BOOL result;
    InvokeHelper(0x600103ac, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Object::Duplicate()
{
    LPDISPATCH result;
    InvokeHelper(0x600103c2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Object::Repaint()
{
    InvokeHelper(0x600103d8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::RestorePicture()
{
    InvokeHelper(0x600103ee, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::ToBack()
{
    InvokeHelper(0x60010404, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Object::ToFront()
{
    InvokeHelper(0x6001041a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// Shape properties

/////////////////////////////////////////////////////////////////////////////
// Shape operations

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

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

BOOL Shape::GetIsLaunched()
{
    BOOL result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL Shape::GetIsLinked()
{
    BOOL result;
    InvokeHelper(0x60010058, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Shape::SetNumber(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6001006e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetNumber()
{
    CString result;
    InvokeHelper(0x6001006e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetNumberShown(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600100a0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Shape::GetNumberShown()
{
    BOOL result;
    InvokeHelper(0x600100a0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Shape::SetLaunchFlags(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100d0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetLaunchFlags()
{
    short result;
    InvokeHelper(0x600100d0, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Shape::SetLaunchCommand(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010100, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetLaunchCommand()
{
    CString result;
    InvokeHelper(0x60010100, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetLaunchStartDir(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010130, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetLaunchStartDir()
{
    CString result;
    InvokeHelper(0x60010130, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetLinkedChartName(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010160, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetLinkedChartName()
{
    CString result;
    InvokeHelper(0x60010160, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetLinkFields(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010190, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Shape::GetLinkFields()
{
    BOOL result;
    InvokeHelper(0x60010190, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Shape::GetNoteFont()
{
    LPDISPATCH result;
    InvokeHelper(0x600101c0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Shape::SetNoteText(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600101d6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetNoteText()
{
    CString result;
    InvokeHelper(0x600101d6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetNoteTextLF(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x60010206, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

CString Shape::GetNoteTextLF()
{
    CString result;
    InvokeHelper(0x60010206, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void Shape::SetShadowColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010236, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Shape::GetShadowColor()
{
    long result;
    InvokeHelper(0x60010236, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Shape::SetShadowStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010266, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetShadowStyle()
{
    short result;
    InvokeHelper(0x60010266, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Shape::SetShadowOffset(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010296, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetShadowOffset()
{
    short result;
    InvokeHelper(0x60010296, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Shape::SetBorderColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x600102c6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Shape::GetBorderColor()
{
    long result;
    InvokeHelper(0x600102c6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Shape::SetBorderStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102f6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetBorderStyle()
{
    short result;
    InvokeHelper(0x600102f6, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Shape::SetBorderWidth(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010326, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetBorderWidth()
{
    short result;
    InvokeHelper(0x60010326, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Shape::SetFillColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010356, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Shape::GetFillColor()
{
    long result;
    InvokeHelper(0x60010356, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Shape::SetFillPattern(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010386, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Shape::GetFillPattern()
{
    short result;
    InvokeHelper(0x60010386, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

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

void Shape::DeleteLines()
{
    InvokeHelper(0x600103cc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void Shape::FitShapeToText()
{
    InvokeHelper(0x600103e2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Shape::Launch()
{
    BOOL result;
    InvokeHelper(0x600103f8, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH Shape::Link()
{
    LPDISPATCH result;
    InvokeHelper(0x6001040e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Shape::Renumber()
{
    InvokeHelper(0x60010424, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL Shape::ReplaceShape(const VARIANT& ShapeType)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x6001043a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &ShapeType);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// Line_ properties

/////////////////////////////////////////////////////////////////////////////
// Line_ operations

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

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

void Line_::SetDestArrowColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Line_::GetDestArrowColor()
{
    long result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Line_::SetDestArrowSize(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetDestArrowSize()
{
    short result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetDestArrowStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetDestArrowStyle()
{
    short result;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetDestination(LPDISPATCH p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

LPDISPATCH Line_::GetDestination()
{
    LPDISPATCH result;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Line_::SetColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Line_::GetColor()
{
    long result;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Line_::SetSource(LPDISPATCH p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

LPDISPATCH Line_::GetSource()
{
    LPDISPATCH result;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void Line_::SetSourceDirection(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetSourceDirection()
{
    short result;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetDestinationDirection(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetDestinationDirection()
{
    short result;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetSourceArrowColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x600101c2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Line_::GetSourceArrowColor()
{
    long result;
    InvokeHelper(0x600101c2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Line_::SetSourceArrowSize(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600101f2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetSourceArrowSize()
{
    short result;
    InvokeHelper(0x600101f2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetSourceArrowStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010222, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetSourceArrowStyle()
{
    short result;
    InvokeHelper(0x60010222, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetStemColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010252, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Line_::GetStemColor()
{
    long result;
    InvokeHelper(0x60010252, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Line_::SetStemStyle(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010282, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetStemStyle()
{
    short result;
    InvokeHelper(0x60010282, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetStemWidth(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102b2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetStemWidth()
{
    short result;
    InvokeHelper(0x600102b2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void Line_::SetType(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600102e2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short Line_::GetType()
{
    short result;
    InvokeHelper(0x600102e2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

BOOL Line_::AttachText(LPDISPATCH TextObject, const VARIANT& Segment)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x60010312, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        TextObject, &Segment);
    return result;
}

BOOL Line_::ReconnectDest(LPDISPATCH Parent, const VARIANT& Direction)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x60010330, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Parent, &Direction);
    return result;
}

BOOL Line_::ReconnectSource(LPDISPATCH Parent, const VARIANT& Direction)
{
    BOOL result;
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x6001034e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Parent, &Direction);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// TextBlock properties

/////////////////////////////////////////////////////////////////////////////
// TextBlock operations

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

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

LPDISPATCH TextBlock::GetAttachedToLine()
{
    LPDISPATCH result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void TextBlock::UnattachFromLine()
{
    InvokeHelper(0x60010058, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// OLEClient properties

/////////////////////////////////////////////////////////////////////////////
// OLEClient operations

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

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

CString OLEClient::GetObjectType()
{
    CString result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void OLEClient::DoVerb(const VARIANT& iVerb)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x60010058, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &iVerb);
}

void OLEClient::RestorePicture()
{
    InvokeHelper(0x60010072, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// Font properties

/////////////////////////////////////////////////////////////////////////////
// Font operations

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

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

void Font::SetBold(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Font::GetBold()
{
    BOOL result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Font::SetColor(long p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I4;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

long Font::GetColor()
{
    long result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Font::SetItalic(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Font::GetItalic()
{
    BOOL result;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Font::SetName(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

void Font::SetOpaque(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Font::GetOpaque()
{
    BOOL result;
    InvokeHelper(0x60010102, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Font::SetSize(double p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_R8;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

double Font::GetSize()
{
    double result;
    InvokeHelper(0x60010132, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void Font::SetStrikethrough(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Font::GetStrikethrough()
{
    BOOL result;
    InvokeHelper(0x60010162, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void Font::SetUnderline(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL Font::GetUnderline()
{
    BOOL result;
    InvokeHelper(0x60010192, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldTemplates properties

/////////////////////////////////////////////////////////////////////////////
// FieldTemplates operations

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

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

LPDISPATCH FieldTemplates::Add(const char* bszName, const VARIANT& Type)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x60020042, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        bszName, &Type);
    return result;
}

void FieldTemplates::DeleteField(LPDISPATCH FieldTemplate)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x60020060, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         FieldTemplate);
}

long FieldTemplates::GetCount()
{
    long result;
    InvokeHelper(0x6002007a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH FieldTemplates::GetItem(const VARIANT& Index, const VARIANT& Type)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &Index, &Type);
    return result;
}

LPUNKNOWN FieldTemplates::Get_NewEnum()
{
    LPUNKNOWN result;
    InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldTemplate_ properties

/////////////////////////////////////////////////////////////////////////////
// FieldTemplate_ operations

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

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

void FieldTemplate_::SetName(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

void FieldTemplate_::SetType(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldTemplate_::GetType()
{
    short result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void FieldTemplate_::SetFormat(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldTemplate_::GetFormat()
{
    short result;
    InvokeHelper(0x600100a2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

double FieldTemplate_::GetAccumulation()
{
    double result;
    InvokeHelper(0x600100d2, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void FieldTemplate_::SetAccumulationMethod(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100e8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldTemplate_::GetAccumulationMethod()
{
    short result;
    InvokeHelper(0x600100e8, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void FieldTemplate_::SetHidden(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6001011a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL FieldTemplate_::GetHidden()
{
    BOOL result;
    InvokeHelper(0x6001011a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldValues properties

/////////////////////////////////////////////////////////////////////////////
// FieldValues operations

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

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

long FieldValues::GetCount()
{
    long result;
    InvokeHelper(0x60020042, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH FieldValues::GetItem(const VARIANT& Index, const VARIANT& FieldType)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &Index, &FieldType);
    return result;
}

LPUNKNOWN FieldValues::Get_NewEnum()
{
    LPUNKNOWN result;
    InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// FieldValue_ properties

/////////////////////////////////////////////////////////////////////////////
// FieldValue_ operations

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

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

BOOL FieldValue_::GetIsEmpty()
{
    BOOL result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH FieldValue_::GetFieldTemplate()
{
    LPDISPATCH result;
    InvokeHelper(0x60010058, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

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

short FieldValue_::GetType()
{
    short result;
    InvokeHelper(0x60010084, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void FieldValue_::SetValue(const VARIANT& p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &p0);
}

VARIANT FieldValue_::GetValue()
{
    VARIANT result;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void FieldValue_::SetDay(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100ca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldValue_::GetDay()
{
    short result;
    InvokeHelper(0x600100ca, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void FieldValue_::SetMonth(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x600100fa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldValue_::GetMonth()
{
    short result;
    InvokeHelper(0x600100fa, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void FieldValue_::SetYear(short p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_I2;
    InvokeHelper(0x6001012a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

short FieldValue_::GetYear()
{
    short result;
    InvokeHelper(0x6001012a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

CString FieldValue_::GetFormattedValue()
{
    CString result;
    InvokeHelper(0x6001015a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void FieldValue_::Empty()
{
    InvokeHelper(0x60010170, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// MenuItem properties

/////////////////////////////////////////////////////////////////////////////
// MenuItem operations

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

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

void MenuItem::SetChecked(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MenuItem::GetChecked()
{
    BOOL result;
    InvokeHelper(0x60010042, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MenuItem::SetEnabled(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

BOOL MenuItem::GetEnabled()
{
    BOOL result;
    InvokeHelper(0x60010072, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void MenuItem::SetText(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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


/////////////////////////////////////////////////////////////////////////////
// Menu properties

/////////////////////////////////////////////////////////////////////////////
// Menu operations

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

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

long Menu::GetCount()
{
    long result;
    InvokeHelper(0x60020042, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void Menu::SetText(const char* p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

void Menu::SetVisible(BOOL p0)
{
    static BYTE BASED_CODE parms[] =
        VTS_BOOL;
    InvokeHelper(0x60020088, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         p0);
}

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

LPDISPATCH Menu::AppendItem(const char* Text)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR;
    InvokeHelper(0x600200ba, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Text);
    return result;
}

void Menu::DeleteItem(LPDISPATCH MenuItem)
{
    static BYTE BASED_CODE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x600200d4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         MenuItem);
}

void Menu::DeleteAll()
{
    InvokeHelper(0x600200ee, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH Menu::InsertItem(const char* Text, const VARIANT& Idenitifer)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_BSTR VTS_VARIANT;
    InvokeHelper(0x60020104, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Text, &Idenitifer);
    return result;
}

LPDISPATCH Menu::GetItem(const VARIANT& Index)
{
    LPDISPATCH result;
    static BYTE BASED_CODE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x60020122, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &Index);
    return result;
}

LPUNKNOWN Menu::Get_NewEnum()
{
    LPUNKNOWN result;
    InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
    return result;
}