PC World Komputer 1998 November/pcwk_11_98a.iso/Wtestowe/SOFTSRC/vtrial15.exe/DATA.1/Vobjects.cpp

C/C++ Source or Header | 1997-10-08 | 455.4 KB | 21,490 lines

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

#include "stdafx.h"
#include "Vobjects.h"

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



/////////////////////////////////////////////////////////////////////////////
// IVdraft properties

LPDISPATCH IVdraft::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVdraft::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

CString IVdraft::GetFullName()
{
    CString result;
    GetProperty(0x3, VT_BSTR, (void*)&result);
    return result;
}

CString IVdraft::GetName()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

CString IVdraft::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

BOOL IVdraft::GetVisible()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void IVdraft::SetVisible(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

BOOL IVdraft::GetMinimized()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void IVdraft::SetMinimized(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

BOOL IVdraft::GetMaximized()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void IVdraft::SetMaximized(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

LPDISPATCH IVdraft::GetActiveDocument()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVdraft::GetDocuments()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVdraft::GetEvents()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

long IVdraft::GetWindowHandle()
{
    long result;
    GetProperty(0xe, VT_I4, (void*)&result);
    return result;
}

short IVdraft::GetVersionMajor()
{
    short result;
    GetProperty(0xf, VT_I2, (void*)&result);
    return result;
}

short IVdraft::GetVersionMinor()
{
    short result;
    GetProperty(0x10, VT_I2, (void*)&result);
    return result;
}

long IVdraft::GetSerialNumber()
{
    long result;
    GetProperty(0x11, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IVdraft operations

void IVdraft::Quit()
{
    InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IVdraft::NewVector(const VARIANT& x, const VARIANT& y, const VARIANT& z)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &x, &y, &z);
    return result;
}

LPDISPATCH IVdraft::NewMatrix()
{
    LPDISPATCH result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IVdraft::Dialog()
{
    InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents properties

LPDISPATCH IApplicationEvents::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IApplicationEvents::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents operations

BOOL IApplicationEvents::AddToolsCommand(long addonid, long menuid, LPCTSTR menutext, LPCTSTR statusbar)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR;
    InvokeHelper(0x1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, menuid, menutext, statusbar);
    return result;
}

BOOL IApplicationEvents::AddToolsOption(long addonid, long menuid, long eventid, LPCTSTR buttontext)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_BSTR;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, menuid, eventid, buttontext);
    return result;
}

BOOL IApplicationEvents::RemoveToolsOption(long addonid, long menuid, long eventid)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, menuid, eventid);
    return result;
}

BOOL IApplicationEvents::AddKeyboardCommand(long addonid, long eventid, LPCTSTR keystrokes)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, eventid, keystrokes);
    return result;
}

BOOL IApplicationEvents::RegisterControl(LPDISPATCH channel)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        channel);
    return result;
}

BOOL IApplicationEvents::UnregisterControl(long addonid)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDocuments properties

LPDISPATCH IDocuments::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocuments::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long IDocuments::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IDocuments operations

LPDISPATCH IDocuments::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IDocuments::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IDocuments::Add(const VARIANT& Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &Name);
    return result;
}

LPDISPATCH IDocuments::New(const VARIANT& Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        &Name);
    return result;
}

void IDocuments::Close()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocuments::CloseOut()
{
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocuments::Save()
{
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocuments::Print()
{
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocuments::PrintAll()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IDocument properties

LPDISPATCH IDocument::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

CString IDocument::GetFullName()
{
    CString result;
    GetProperty(0x3, VT_BSTR, (void*)&result);
    return result;
}

CString IDocument::GetName()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

CString IDocument::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

CString IDocument::GetPath()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDocument::GetSaved()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetEntitySnap()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetUnits()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetEntities()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetApplicationIDs()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetLayers()
{
    LPDISPATCH result;
    GetProperty(0xb, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetLinetypes()
{
    LPDISPATCH result;
    GetProperty(0xc, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetBlocks()
{
    LPDISPATCH result;
    GetProperty(0xd, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetDimStyles()
{
    LPDISPATCH result;
    GetProperty(0xe, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetTextStyles()
{
    LPDISPATCH result;
    GetProperty(0xf, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetUcses()
{
    LPDISPATCH result;
    GetProperty(0x10, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetNamedViews()
{
    LPDISPATCH result;
    GetProperty(0x11, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetViews()
{
    LPDISPATCH result;
    GetProperty(0x12, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetCommands()
{
    LPDISPATCH result;
    GetProperty(0x13, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetColors()
{
    LPDISPATCH result;
    GetProperty(0x14, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetSelection()
{
    LPDISPATCH result;
    GetProperty(0x15, VT_DISPATCH, (void*)&result);
    return result;
}

CString IDocument::GetStatusbar()
{
    CString result;
    GetProperty(0x16, VT_BSTR, (void*)&result);
    return result;
}

void IDocument::SetStatusbar(LPCTSTR propVal)
{
    SetProperty(0x16, VT_BSTR, propVal);
}

LPDISPATCH IDocument::GetHeader()
{
    LPDISPATCH result;
    GetProperty(0x17, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetPickEvents()
{
    LPDISPATCH result;
    GetProperty(0x18, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDocument::GetSelectionEvents()
{
    LPDISPATCH result;
    GetProperty(0x19, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDocument::GetVisible()
{
    BOOL result;
    GetProperty(0x27, VT_BOOL, (void*)&result);
    return result;
}

void IDocument::SetVisible(BOOL propVal)
{
    SetProperty(0x27, VT_BOOL, propVal);
}

BOOL IDocument::GetMinimized()
{
    BOOL result;
    GetProperty(0x28, VT_BOOL, (void*)&result);
    return result;
}

void IDocument::SetMinimized(BOOL propVal)
{
    SetProperty(0x28, VT_BOOL, propVal);
}

BOOL IDocument::GetMaximized()
{
    BOOL result;
    GetProperty(0x29, VT_BOOL, (void*)&result);
    return result;
}

void IDocument::SetMaximized(BOOL propVal)
{
    SetProperty(0x29, VT_BOOL, propVal);
}

long IDocument::GetWindowHandle()
{
    long result;
    GetProperty(0x2a, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IDocument operations

void IDocument::Activate()
{
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::Print(const VARIANT& copies)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &copies);
}

void IDocument::PrintOut(const VARIANT& copies)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &copies);
}

void IDocument::PrintSetup()
{
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::PrintPreview()
{
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::PrintPreviewClose()
{
    InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::Save()
{
    InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::SaveAs(LPCTSTR filename)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         filename);
}

void IDocument::Close(const VARIANT& savechanges, const VARIANT& filename)
{
    static BYTE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &savechanges, &filename);
}

void IDocument::CloseOut(const VARIANT& savechanges, const VARIANT& filename)
{
    static BYTE parms[] =
        VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &savechanges, &filename);
}

void IDocument::Redraw()
{
    InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDocument::Regen()
{
    InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDocument::NewEntitySet()
{
    LPDISPATCH result;
    InvokeHelper(0x26, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IDocument::Dialog()
{
    InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IVector properties

LPDISPATCH IVector::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVector::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

double IVector::GetX()
{
    double result;
    GetProperty(0x1, VT_R8, (void*)&result);
    return result;
}

void IVector::SetX(double propVal)
{
    SetProperty(0x1, VT_R8, propVal);
}

double IVector::GetY()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void IVector::SetY(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double IVector::GetZ()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void IVector::SetZ(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double IVector::GetLength()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

double IVector::GetLengthSquared()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

double IVector::GetAngle()
{
    double result;
    GetProperty(0x15, VT_R8, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IVector operations

void IVector::CopyFrom(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}

void IVector::AddIn(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}

void IVector::SubtractAway(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}

void IVector::MultiplyBy(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}

void IVector::DivideBy(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}

void IVector::ScaleBy(double factor)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         factor);
}

double IVector::Distance(LPDISPATCH vector)
{
    double result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        vector);
    return result;
}

BOOL IVector::Normalize()
{
    BOOL result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

double IVector::DotProduct(LPDISPATCH vector)
{
    double result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        vector);
    return result;
}

LPDISPATCH IVector::CrossProduct(LPDISPATCH vector)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vector);
    return result;
}

void IVector::Set(double x, double y, const VARIANT& z)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_VARIANT;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y, &z);
}

void IVector::Set2D(double x, double y)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y);
}

void IVector::Set3D(double x, double y, double z)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y, z);
}

void IVector::Detach()
{
    InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

CString IVector::Dump()
{
    CString result;
    InvokeHelper(0x14, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
    return result;
}

CString IVector::_Dump()
{
    CString result;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_BSTR, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IVectors properties

LPDISPATCH IVectors::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVectors::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long IVectors::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IVectors operations

LPDISPATCH IVectors::GetItem(long which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void IVectors::SetItem(long which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}

LPDISPATCH IVectors::Get_Item(long which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void IVectors::Set_Item(long which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}

void IVectors::Add(LPDISPATCH vector)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vector);
}


/////////////////////////////////////////////////////////////////////////////
// IMatrix properties

LPDISPATCH IMatrix::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IMatrix::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IMatrix operations

LPDISPATCH IMatrix::GetItem(long which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void IMatrix::SetItem(long which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}

LPDISPATCH IMatrix::Get_Item(long which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void IMatrix::Set_Item(long which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH;
    InvokeHelper(0x0, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}

void IMatrix::Id()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IMatrix::CopyFrom(LPDISPATCH matrix)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         matrix);
}

void IMatrix::ECStoWCS(LPDISPATCH normal)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         normal);
}

void IMatrix::WCStoECS(LPDISPATCH normal)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         normal);
}

void IMatrix::Translation(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

void IMatrix::Rotation(double Angle, const VARIANT& basepoint, const VARIANT& normal)
{
    static BYTE parms[] =
        VTS_R8 VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Angle, &basepoint, &normal);
}

void IMatrix::Scaling(LPDISPATCH factors, const VARIANT& basepoint, const VARIANT& normal)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         factors, &basepoint, &normal);
}

void IMatrix::Mirror(LPDISPATCH one, LPDISPATCH two, const VARIANT& normal)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         one, two, &normal);
}

void IMatrix::Transform(LPDISPATCH point)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point);
}


/////////////////////////////////////////////////////////////////////////////
// IHeader properties

LPDISPATCH IHeader::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IHeader::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IHeader::GetAttributeDialog()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetAttributeDialog(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

long IHeader::GetAttributeMode()
{
    long result;
    GetProperty(0x2, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetAttributeMode(long propVal)
{
    SetProperty(0x2, VT_I4, propVal);
}

BOOL IHeader::GetAttributeRequest()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetAttributeRequest(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IHeader::GetAxisMode()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetAxisMode(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

LPDISPATCH IHeader::GetAxisUnit()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IHeader::SetAxisUnit(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

BOOL IHeader::GetBlipMode()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetBlipMode(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

long IHeader::GetCirclePrecision()
{
    long result;
    GetProperty(0x7, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetCirclePrecision(long propVal)
{
    SetProperty(0x7, VT_I4, propVal);
}

long IHeader::GetCoordinateDisplay()
{
    long result;
    GetProperty(0x8, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetCoordinateDisplay(long propVal)
{
    SetProperty(0x8, VT_I4, propVal);
}

double IHeader::GetCurrentElevation()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetCurrentElevation(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

double IHeader::GetCurrentThickness()
{
    double result;
    GetProperty(0xa, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetCurrentThickness(double propVal)
{
    SetProperty(0xa, VT_R8, propVal);
}

long IHeader::GetDragMode()
{
    long result;
    GetProperty(0xb, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetDragMode(long propVal)
{
    SetProperty(0xb, VT_I4, propVal);
}

long IHeader::GetDrawingCodePage()
{
    long result;
    GetProperty(0xc, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetDrawingCodePage(long propVal)
{
    SetProperty(0xc, VT_I4, propVal);
}

BOOL IHeader::GetFastZoom()
{
    BOOL result;
    GetProperty(0xd, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetFastZoom(BOOL propVal)
{
    SetProperty(0xd, VT_BOOL, propVal);
}

BOOL IHeader::GetFillMode()
{
    BOOL result;
    GetProperty(0xe, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetFillMode(BOOL propVal)
{
    SetProperty(0xe, VT_BOOL, propVal);
}

BOOL IHeader::GetFlatLand()
{
    BOOL result;
    GetProperty(0xf, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetFlatLand(BOOL propVal)
{
    SetProperty(0xf, VT_BOOL, propVal);
}

BOOL IHeader::GetHandles()
{
    BOOL result;
    GetProperty(0x10, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetHandles(BOOL propVal)
{
    SetProperty(0x10, VT_BOOL, propVal);
}

CString IHeader::GetHandleSeed()
{
    CString result;
    GetProperty(0x11, VT_BSTR, (void*)&result);
    return result;
}

void IHeader::SetHandleSeed(LPCTSTR propVal)
{
    SetProperty(0x11, VT_BSTR, propVal);
}

LPDISPATCH IHeader::GetLimitsMax()
{
    LPDISPATCH result;
    GetProperty(0x12, VT_DISPATCH, (void*)&result);
    return result;
}

void IHeader::SetLimitsMax(LPDISPATCH propVal)
{
    SetProperty(0x12, VT_DISPATCH, propVal);
}

LPDISPATCH IHeader::GetLimitsMin()
{
    LPDISPATCH result;
    GetProperty(0x13, VT_DISPATCH, (void*)&result);
    return result;
}

void IHeader::SetLimitsMin(LPDISPATCH propVal)
{
    SetProperty(0x13, VT_DISPATCH, propVal);
}

BOOL IHeader::GetLimitsCheck()
{
    BOOL result;
    GetProperty(0x14, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetLimitsCheck(BOOL propVal)
{
    SetProperty(0x14, VT_BOOL, propVal);
}

long IHeader::GetMaxActiveViewports()
{
    long result;
    GetProperty(0x15, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetMaxActiveViewports(long propVal)
{
    SetProperty(0x15, VT_I4, propVal);
}

CString IHeader::GetMenuName()
{
    CString result;
    GetProperty(0x16, VT_BSTR, (void*)&result);
    return result;
}

void IHeader::SetMenuName(LPCTSTR propVal)
{
    SetProperty(0x16, VT_BSTR, propVal);
}

BOOL IHeader::GetMirrorText()
{
    BOOL result;
    GetProperty(0x17, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetMirrorText(BOOL propVal)
{
    SetProperty(0x17, VT_BOOL, propVal);
}

double IHeader::GetPaperSpaceElevation()
{
    double result;
    GetProperty(0x18, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetPaperSpaceElevation(double propVal)
{
    SetProperty(0x18, VT_R8, propVal);
}

LPDISPATCH IHeader::GetPaperSpaceLimitsMax()
{
    LPDISPATCH result;
    GetProperty(0x19, VT_DISPATCH, (void*)&result);
    return result;
}

void IHeader::SetPaperSpaceLimitsMax(LPDISPATCH propVal)
{
    SetProperty(0x19, VT_DISPATCH, propVal);
}

LPDISPATCH IHeader::GetPaperSpaceLimitsMin()
{
    LPDISPATCH result;
    GetProperty(0x1a, VT_DISPATCH, (void*)&result);
    return result;
}

void IHeader::SetPaperSpaceLimitsMin(LPDISPATCH propVal)
{
    SetProperty(0x1a, VT_DISPATCH, propVal);
}

BOOL IHeader::GetPaperSpaceLimitsCheck()
{
    BOOL result;
    GetProperty(0x1b, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetPaperSpaceLimitsCheck(BOOL propVal)
{
    SetProperty(0x1b, VT_BOOL, propVal);
}

long IHeader::GetPolylineLinetypePattern()
{
    long result;
    GetProperty(0x1c, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetPolylineLinetypePattern(long propVal)
{
    SetProperty(0x1c, VT_I4, propVal);
}

double IHeader::GetPolylineWidth()
{
    double result;
    GetProperty(0x1d, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetPolylineWidth(double propVal)
{
    SetProperty(0x1d, VT_R8, propVal);
}

long IHeader::GetQuickText()
{
    long result;
    GetProperty(0x1e, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetQuickText(long propVal)
{
    SetProperty(0x1e, VT_I4, propVal);
}

long IHeader::GetRegenMode()
{
    long result;
    GetProperty(0x1f, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetRegenMode(long propVal)
{
    SetProperty(0x1f, VT_I4, propVal);
}

long IHeader::GetShadeDiffuse()
{
    long result;
    GetProperty(0x20, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetShadeDiffuse(long propVal)
{
    SetProperty(0x20, VT_I4, propVal);
}

long IHeader::GetShadeEdge()
{
    long result;
    GetProperty(0x21, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetShadeEdge(long propVal)
{
    SetProperty(0x21, VT_I4, propVal);
}

double IHeader::GetSketchIncrement()
{
    double result;
    GetProperty(0x22, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetSketchIncrement(double propVal)
{
    SetProperty(0x22, VT_R8, propVal);
}

BOOL IHeader::GetSketchPolyline()
{
    BOOL result;
    GetProperty(0x23, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetSketchPolyline(BOOL propVal)
{
    SetProperty(0x23, VT_BOOL, propVal);
}

long IHeader::GetSplineFrame()
{
    long result;
    GetProperty(0x24, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSplineFrame(long propVal)
{
    SetProperty(0x24, VT_I4, propVal);
}

long IHeader::GetSplineSegments()
{
    long result;
    GetProperty(0x25, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSplineSegments(long propVal)
{
    SetProperty(0x25, VT_I4, propVal);
}

long IHeader::GetSplineType()
{
    long result;
    GetProperty(0x26, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSplineType(long propVal)
{
    SetProperty(0x26, VT_I4, propVal);
}

long IHeader::GetSurfaceDensityM()
{
    long result;
    GetProperty(0x27, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSurfaceDensityM(long propVal)
{
    SetProperty(0x27, VT_I4, propVal);
}

long IHeader::GetSurfaceDensityN()
{
    long result;
    GetProperty(0x28, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSurfaceDensityN(long propVal)
{
    SetProperty(0x28, VT_I4, propVal);
}

long IHeader::GetSurfaceTabulations1()
{
    long result;
    GetProperty(0x29, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSurfaceTabulations1(long propVal)
{
    SetProperty(0x29, VT_I4, propVal);
}

long IHeader::GetSurfaceTabulations2()
{
    long result;
    GetProperty(0x2a, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSurfaceTabulations2(long propVal)
{
    SetProperty(0x2a, VT_I4, propVal);
}

long IHeader::GetSurfaceType()
{
    long result;
    GetProperty(0x2b, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetSurfaceType(long propVal)
{
    SetProperty(0x2b, VT_I4, propVal);
}

double IHeader::GetTextSize()
{
    double result;
    GetProperty(0x2c, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetTextSize(double propVal)
{
    SetProperty(0x2c, VT_R8, propVal);
}

double IHeader::GetTraceSize()
{
    double result;
    GetProperty(0x2d, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetTraceSize(double propVal)
{
    SetProperty(0x2d, VT_R8, propVal);
}

long IHeader::GetTreeDepth()
{
    long result;
    GetProperty(0x2e, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetTreeDepth(long propVal)
{
    SetProperty(0x2e, VT_I4, propVal);
}

long IHeader::GetUCSIcon()
{
    long result;
    GetProperty(0x2f, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUCSIcon(long propVal)
{
    SetProperty(0x2f, VT_I4, propVal);
}

long IHeader::GetUnitMode()
{
    long result;
    GetProperty(0x30, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUnitMode(long propVal)
{
    SetProperty(0x30, VT_I4, propVal);
}

long IHeader::GetUserInteger1()
{
    long result;
    GetProperty(0x31, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserInteger1(long propVal)
{
    SetProperty(0x31, VT_I4, propVal);
}

long IHeader::GetUserInteger2()
{
    long result;
    GetProperty(0x32, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserInteger2(long propVal)
{
    SetProperty(0x32, VT_I4, propVal);
}

long IHeader::GetUserInteger3()
{
    long result;
    GetProperty(0x33, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserInteger3(long propVal)
{
    SetProperty(0x33, VT_I4, propVal);
}

long IHeader::GetUserInteger4()
{
    long result;
    GetProperty(0x34, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserInteger4(long propVal)
{
    SetProperty(0x34, VT_I4, propVal);
}

long IHeader::GetUserInteger5()
{
    long result;
    GetProperty(0x35, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserInteger5(long propVal)
{
    SetProperty(0x35, VT_I4, propVal);
}

long IHeader::GetUserReal1()
{
    long result;
    GetProperty(0x36, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserReal1(long propVal)
{
    SetProperty(0x36, VT_I4, propVal);
}

long IHeader::GetUserReal2()
{
    long result;
    GetProperty(0x37, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserReal2(long propVal)
{
    SetProperty(0x37, VT_I4, propVal);
}

long IHeader::GetUserReal3()
{
    long result;
    GetProperty(0x38, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserReal3(long propVal)
{
    SetProperty(0x38, VT_I4, propVal);
}

long IHeader::GetUserReal4()
{
    long result;
    GetProperty(0x39, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserReal4(long propVal)
{
    SetProperty(0x39, VT_I4, propVal);
}

long IHeader::GetUserReal5()
{
    long result;
    GetProperty(0x3a, VT_I4, (void*)&result);
    return result;
}

void IHeader::SetUserReal5(long propVal)
{
    SetProperty(0x3a, VT_I4, propVal);
}

BOOL IHeader::GetUserTimer()
{
    BOOL result;
    GetProperty(0x3b, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetUserTimer(BOOL propVal)
{
    SetProperty(0x3b, VT_BOOL, propVal);
}

BOOL IHeader::GetWorldView()
{
    BOOL result;
    GetProperty(0x3c, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetWorldView(BOOL propVal)
{
    SetProperty(0x3c, VT_BOOL, propVal);
}

double IHeader::GetFilletRadius()
{
    double result;
    GetProperty(0x3d, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetFilletRadius(double propVal)
{
    SetProperty(0x3d, VT_R8, propVal);
}

double IHeader::GetChamferDistanceA()
{
    double result;
    GetProperty(0x3e, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetChamferDistanceA(double propVal)
{
    SetProperty(0x3e, VT_R8, propVal);
}

double IHeader::GetChamferDistanceB()
{
    double result;
    GetProperty(0x3f, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetChamferDistanceB(double propVal)
{
    SetProperty(0x3f, VT_R8, propVal);
}

short IHeader::GetPointDisplayMode()
{
    short result;
    GetProperty(0x40, VT_I2, (void*)&result);
    return result;
}

void IHeader::SetPointDisplayMode(short propVal)
{
    SetProperty(0x40, VT_I2, propVal);
}

double IHeader::GetPointDisplaySize()
{
    double result;
    GetProperty(0x41, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetPointDisplaySize(double propVal)
{
    SetProperty(0x41, VT_R8, propVal);
}

BOOL IHeader::GetLengthSnap()
{
    BOOL result;
    GetProperty(0x42, VT_BOOL, (void*)&result);
    return result;
}

void IHeader::SetLengthSnap(BOOL propVal)
{
    SetProperty(0x42, VT_BOOL, propVal);
}

double IHeader::GetLengthSnapValue()
{
    double result;
    GetProperty(0x43, VT_R8, (void*)&result);
    return result;
}

void IHeader::SetLengthSnapValue(double propVal)
{
    SetProperty(0x43, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IHeader operations


/////////////////////////////////////////////////////////////////////////////
// IEntitySnap properties

LPDISPATCH IEntitySnap::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntitySnap::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IEntitySnap::GetSnap()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetSnap(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IEntitySnap::Get_Snap()
{
    BOOL result;
    GetProperty(0x0, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::Set_Snap(BOOL propVal)
{
    SetProperty(0x0, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetSnapToSelection()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetSnapToSelection(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetEndpoint()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetEndpoint(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetMidpoint()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetMidpoint(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetCenter()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetCenter(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetNearest()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetNearest(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetPointSnap()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetPointSnap(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetQuadrant()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetQuadrant(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetInsertion()
{
    BOOL result;
    GetProperty(0x9, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetInsertion(BOOL propVal)
{
    SetProperty(0x9, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetPerpendicular()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetPerpendicular(BOOL propVal)
{
    SetProperty(0xa, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetTangent()
{
    BOOL result;
    GetProperty(0xb, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetTangent(BOOL propVal)
{
    SetProperty(0xb, VT_BOOL, propVal);
}

BOOL IEntitySnap::GetIntersection()
{
    BOOL result;
    GetProperty(0xc, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySnap::SetIntersection(BOOL propVal)
{
    SetProperty(0xc, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IEntitySnap operations

void IEntitySnap::Dialog()
{
    InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IUnits properties

LPDISPATCH IUnits::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IUnits::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

short IUnits::GetLinear()
{
    short result;
    GetProperty(0x1, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetLinear(short propVal)
{
    SetProperty(0x1, VT_I2, propVal);
}

short IUnits::GetLinearDigits()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetLinearDigits(short propVal)
{
    SetProperty(0x2, VT_I2, propVal);
}

short IUnits::GetAngular()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetAngular(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

short IUnits::GetAngularDigits()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetAngularDigits(short propVal)
{
    SetProperty(0x4, VT_I2, propVal);
}

double IUnits::GetAngleBase()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void IUnits::SetAngleBase(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

BOOL IUnits::GetClockwise()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void IUnits::SetClockwise(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

short IUnits::GetScaleMethod()
{
    short result;
    GetProperty(0xd, VT_I2, (void*)&result);
    return result;
}

double IUnits::GetScaling()
{
    double result;
    GetProperty(0xe, VT_R8, (void*)&result);
    return result;
}

void IUnits::SetScaling(double propVal)
{
    SetProperty(0xe, VT_R8, propVal);
}

short IUnits::GetMetricUnits()
{
    short result;
    GetProperty(0xf, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetMetricUnits(short propVal)
{
    SetProperty(0xf, VT_I2, propVal);
}

short IUnits::GetDisplayUnits()
{
    short result;
    GetProperty(0x10, VT_I2, (void*)&result);
    return result;
}

void IUnits::SetDisplayUnits(short propVal)
{
    SetProperty(0x10, VT_I2, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IUnits operations

CString IUnits::PointToString(LPDISPATCH point)
{
    CString result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        point);
    return result;
}

CString IUnits::CoordinateToString(double value)
{
    CString result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        value);
    return result;
}

CString IUnits::AngleToString(double Angle)
{
    CString result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Angle);
    return result;
}

LPDISPATCH IUnits::StringToPoint(LPCTSTR string)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        string);
    return result;
}

double IUnits::StringToCoordinate(LPCTSTR string)
{
    double result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        string);
    return result;
}

double IUnits::StringToAngle(LPCTSTR string)
{
    double result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        string);
    return result;
}

void IUnits::Dialog()
{
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ICommands properties

LPDISPATCH ICommands::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ICommands::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long ICommands::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ICommands operations

CString ICommands::GetItem(long index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
        index);
    return result;
}

CString ICommands::Get_Item(long index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
        index);
    return result;
}

BOOL ICommands::Undo(const VARIANT& howmany)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &howmany);
    return result;
}

BOOL ICommands::Redo(const VARIANT& howmany)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &howmany);
    return result;
}

BOOL ICommands::Restart()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL ICommands::Do(LPCTSTR command)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        command);
    return result;
}

void ICommands::Group(LPCTSTR description)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         description);
}

void ICommands::EndGroup()
{
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICommands::KillUndoRedo()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICommands::Dialog()
{
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IPickEvents properties

LPDISPATCH IPickEvents::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPickEvents::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IPickEvents::GetName()
{
    CString result;
    GetProperty(0x1, VT_BSTR, (void*)&result);
    return result;
}

void IPickEvents::SetName(LPCTSTR propVal)
{
    SetProperty(0x1, VT_BSTR, propVal);
}

CString IPickEvents::GetStatusbar()
{
    CString result;
    GetProperty(0x2, VT_BSTR, (void*)&result);
    return result;
}

void IPickEvents::SetStatusbar(LPCTSTR propVal)
{
    SetProperty(0x2, VT_BSTR, propVal);
}

BOOL IPickEvents::GetNotifyDone()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IPickEvents::SetNotifyDone(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IPickEvents::GetNotifyProperties()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IPickEvents::SetNotifyProperties(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

BOOL IPickEvents::GetNotifyUndo()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void IPickEvents::SetNotifyUndo(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

long IPickEvents::GetHelpToken()
{
    long result;
    GetProperty(0x6, VT_I4, (void*)&result);
    return result;
}

void IPickEvents::SetHelpToken(long propVal)
{
    SetProperty(0x6, VT_I4, propVal);
}

LPDISPATCH IPickEvents::GetBasepoint()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

void IPickEvents::SetBasepoint(LPDISPATCH propVal)
{
    SetProperty(0x7, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPickEvents operations

BOOL IPickEvents::RequestPick(long addonid, const VARIANT& userinfo)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, &userinfo);
    return result;
}

void IPickEvents::SetCursorTips(LPCTSTR tip1, const VARIANT& tip2, const VARIANT& tip3, const VARIANT& tip4)
{
    static BYTE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         tip1, &tip2, &tip3, &tip4);
}

void IPickEvents::SetCursorTipInfo(short tipinfo, LPDISPATCH basepoint)
{
    static BYTE parms[] =
        VTS_I2 VTS_DISPATCH;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         tipinfo, basepoint);
}

BOOL IPickEvents::RequestDraw(long addonid, const VARIANT& userinfo)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, &userinfo);
    return result;
}

BOOL IPickEvents::TriggerPick(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPickEvents::TriggerPopup(short event)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        event);
    return result;
}

BOOL IPickEvents::TriggerLength(double Length)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Length);
    return result;
}

BOOL IPickEvents::TriggerAngle(double Angle)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Angle);
    return result;
}

BOOL IPickEvents::TriggerOffset(LPDISPATCH offset)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        offset);
    return result;
}

BOOL IPickEvents::TriggerScale(LPDISPATCH scale)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        scale);
    return result;
}

BOOL IPickEvents::TriggerHeight(double height)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        height);
    return result;
}

BOOL IPickEvents::TriggerWidth(double width)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        width);
    return result;
}

BOOL IPickEvents::TriggerRadius(double radius)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        radius);
    return result;
}

BOOL IPickEvents::TriggerDiameter(double diameter)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        diameter);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISelectionEvents properties

LPDISPATCH ISelectionEvents::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ISelectionEvents::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

CString ISelectionEvents::GetName()
{
    CString result;
    GetProperty(0x1, VT_BSTR, (void*)&result);
    return result;
}

void ISelectionEvents::SetName(LPCTSTR propVal)
{
    SetProperty(0x1, VT_BSTR, propVal);
}

CString ISelectionEvents::GetStatusbar()
{
    CString result;
    GetProperty(0x2, VT_BSTR, (void*)&result);
    return result;
}

void ISelectionEvents::SetStatusbar(LPCTSTR propVal)
{
    SetProperty(0x2, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ISelectionEvents operations

BOOL ISelectionEvents::RequestSelect(long addonid, const VARIANT& userinfo)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, &userinfo);
    return result;
}

BOOL ISelectionEvents::RequestSingleSelect(long addonid, const VARIANT& userinfo)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addonid, &userinfo);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IApplicationIDs properties

LPDISPATCH IApplicationIDs::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IApplicationIDs::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IApplicationIDs::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IApplicationIDs operations

LPDISPATCH IApplicationIDs::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL IApplicationIDs::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IApplicationIDs::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IApplicationIDs::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IApplicationID properties

LPDISPATCH IApplicationID::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IApplicationID::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IApplicationID::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void IApplicationID::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString IApplicationID::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void IApplicationID::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IApplicationID operations


/////////////////////////////////////////////////////////////////////////////
// ILayers properties

LPDISPATCH ILayers::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILayers::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long ILayers::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH ILayers::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ILayers::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILayers operations

LPDISPATCH ILayers::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL ILayers::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH ILayers::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void ILayers::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILayers::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILayers::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ILayers::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILayer properties

LPDISPATCH ILayer::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILayer::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString ILayer::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void ILayer::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString ILayer::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void ILayer::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

BOOL ILayer::GetOn()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void ILayer::SetOn(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

BOOL ILayer::GetFrozen()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void ILayer::SetFrozen(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

LPDISPATCH ILayer::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void ILayer::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

short ILayer::GetColorNumber()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

void ILayer::SetColorNumber(short propVal)
{
    SetProperty(0x4, VT_I2, propVal);
}

LPDISPATCH ILayer::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ILayer::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ILayer operations

BOOL ILayer::GetFrozenInView(LPDISPATCH view)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        view);
    return result;
}

void ILayer::SetFrozenInView(LPDISPATCH view, BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         view, bNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// ILinetypes properties

LPDISPATCH ILinetypes::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILinetypes::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long ILinetypes::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH ILinetypes::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ILinetypes::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

double ILinetypes::GetScaling()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

void ILinetypes::SetScaling(double propVal)
{
    SetProperty(0x6, VT_R8, propVal);
}

BOOL ILinetypes::GetPaperSpaceScaling()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void ILinetypes::SetPaperSpaceScaling(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

LPDISPATCH ILinetypes::GetSameAsLayer()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILinetypes::GetSameAsBlock()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ILinetypes operations

LPDISPATCH ILinetypes::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL ILinetypes::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH ILinetypes::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void ILinetypes::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILinetypes::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILinetypes::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ILinetypes::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILinetype properties

LPDISPATCH ILinetype::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILinetype::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString ILinetype::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void ILinetype::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString ILinetype::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void ILinetype::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

CString ILinetype::GetDescription()
{
    CString result;
    GetProperty(0x1, VT_BSTR, (void*)&result);
    return result;
}

void ILinetype::SetDescription(LPCTSTR propVal)
{
    SetProperty(0x1, VT_BSTR, propVal);
}

short ILinetype::GetCount()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ILinetype operations

double ILinetype::GetItem(short index)
{
    double result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
        index);
    return result;
}

void ILinetype::SetItem(short index, double newValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_R8;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         index, newValue);
}


/////////////////////////////////////////////////////////////////////////////
// IBlocks properties

LPDISPATCH IBlocks::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IBlocks::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IBlocks::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH IBlocks::GetInsertBase()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IBlocks::SetInsertBase(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH IBlocks::GetPaperSpaceInsertBase()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

void IBlocks::SetPaperSpaceInsertBase(LPDISPATCH propVal)
{
    SetProperty(0x7, VT_DISPATCH, propVal);
}

BOOL IBlocks::GetXrefVisibility()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void IBlocks::SetXrefVisibility(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IBlocks operations

LPDISPATCH IBlocks::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL IBlocks::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IBlocks::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void IBlocks::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IBlocks::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IBlocks::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IBlocks::Add(LPCTSTR Name, LPDISPATCH basepoint, const VARIANT& how)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name, basepoint, &how);
    return result;
}

LPDISPATCH IBlocks::Load(LPCTSTR filename, const VARIANT& asxref, const VARIANT& blockname)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        filename, &asxref, &blockname);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IBlock properties

LPDISPATCH IBlock::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IBlock::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IBlock::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void IBlock::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString IBlock::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void IBlock::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

LPDISPATCH IBlock::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IBlock::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IBlock::GetExtentsMin()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IBlock::GetExtentsMax()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IBlock::GetIsXref()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

BOOL IBlock::GetIsAnonymous()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

BOOL IBlock::GetHasAttributes()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IBlock::GetInserts()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IBlock operations

void IBlock::SaveAs(LPCTSTR filename)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         filename);
}

void IBlock::CopyToClipboard()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IBlock::XrefReload()
{
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IBlock::XrefDetach()
{
    InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IBlock::XrefBind()
{
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IDimStyles properties

LPDISPATCH IDimStyles::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimStyles::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IDimStyles::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH IDimStyles::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyles::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

LPDISPATCH IDimStyles::GetUnnamed()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IDimStyles operations

LPDISPATCH IDimStyles::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL IDimStyles::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IDimStyles::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void IDimStyles::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimStyles::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimStyles::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimStyles::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimStyle properties

LPDISPATCH IDimStyle::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimStyle::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IDimStyle::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void IDimStyle::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString IDimStyle::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void IDimStyle::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

double IDimStyle::GetExtensionAboveLine()
{
    double result;
    GetProperty(0x1, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetExtensionAboveLine(double propVal)
{
    SetProperty(0x1, VT_R8, propVal);
}

double IDimStyle::GetOffsetFromFeature()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetOffsetFromFeature(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

BOOL IDimStyle::GetExtension1Visibility()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetExtension1Visibility(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IDimStyle::GetExtension2Visibility()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetExtension2Visibility(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

double IDimStyle::GetCenterMarkSize()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetCenterMarkSize(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

LPDISPATCH IDimStyle::GetExtensionColor()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetExtensionColor(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

BOOL IDimStyle::GetCreateCenterLines()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetCreateCenterLines(BOOL propVal)
{
    SetProperty(0x7, VT_BOOL, propVal);
}

BOOL IDimStyle::GetForceInteriorLines()
{
    BOOL result;
    GetProperty(0x8, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetForceInteriorLines(BOOL propVal)
{
    SetProperty(0x8, VT_BOOL, propVal);
}

BOOL IDimStyle::GetBoxAroundText()
{
    BOOL result;
    GetProperty(0x9, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetBoxAroundText(BOOL propVal)
{
    SetProperty(0x9, VT_BOOL, propVal);
}

double IDimStyle::GetScaling()
{
    double result;
    GetProperty(0xa, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetScaling(double propVal)
{
    SetProperty(0xa, VT_R8, propVal);
}

double IDimStyle::GetBaselineIncrement()
{
    double result;
    GetProperty(0xb, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetBaselineIncrement(double propVal)
{
    SetProperty(0xb, VT_R8, propVal);
}

double IDimStyle::GetTextGap()
{
    double result;
    GetProperty(0xc, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetTextGap(double propVal)
{
    SetProperty(0xc, VT_R8, propVal);
}

LPDISPATCH IDimStyle::GetDimensionLineColor()
{
    LPDISPATCH result;
    GetProperty(0xd, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetDimensionLineColor(LPDISPATCH propVal)
{
    SetProperty(0xd, VT_DISPATCH, propVal);
}

double IDimStyle::GetTickExtension()
{
    double result;
    GetProperty(0xe, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetTickExtension(double propVal)
{
    SetProperty(0xe, VT_R8, propVal);
}

double IDimStyle::GetTickSize()
{
    double result;
    GetProperty(0xf, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetTickSize(double propVal)
{
    SetProperty(0xf, VT_R8, propVal);
}

double IDimStyle::GetArrowSize()
{
    double result;
    GetProperty(0x10, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetArrowSize(double propVal)
{
    SetProperty(0x10, VT_R8, propVal);
}

BOOL IDimStyle::GetSeparateArrowHeads()
{
    BOOL result;
    GetProperty(0x11, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetSeparateArrowHeads(BOOL propVal)
{
    SetProperty(0x11, VT_BOOL, propVal);
}

long IDimStyle::GetArrowsType()
{
    long result;
    GetProperty(0x12, VT_I4, (void*)&result);
    return result;
}

long IDimStyle::GetArrow1Type()
{
    long result;
    GetProperty(0x13, VT_I4, (void*)&result);
    return result;
}

long IDimStyle::GetArrow2Type()
{
    long result;
    GetProperty(0x14, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH IDimStyle::GetArrowsBlock()
{
    LPDISPATCH result;
    GetProperty(0x15, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetArrowsBlock(LPDISPATCH propVal)
{
    SetProperty(0x15, VT_DISPATCH, propVal);
}

LPDISPATCH IDimStyle::GetArrow1Block()
{
    LPDISPATCH result;
    GetProperty(0x16, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetArrow1Block(LPDISPATCH propVal)
{
    SetProperty(0x16, VT_DISPATCH, propVal);
}

LPDISPATCH IDimStyle::GetArrow2Block()
{
    LPDISPATCH result;
    GetProperty(0x17, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetArrow2Block(LPDISPATCH propVal)
{
    SetProperty(0x17, VT_DISPATCH, propVal);
}

double IDimStyle::GetTextHeight()
{
    double result;
    GetProperty(0x18, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetTextHeight(double propVal)
{
    SetProperty(0x18, VT_R8, propVal);
}

double IDimStyle::GetTextHeightValue()
{
    double result;
    GetProperty(0x19, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetTextHeightValue(double propVal)
{
    SetProperty(0x19, VT_R8, propVal);
}

double IDimStyle::GetVerticalPosition()
{
    double result;
    GetProperty(0x1a, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetVerticalPosition(double propVal)
{
    SetProperty(0x1a, VT_R8, propVal);
}

short IDimStyle::GetAlignment()
{
    short result;
    GetProperty(0x1b, VT_I2, (void*)&result);
    return result;
}

void IDimStyle::SetAlignment(short propVal)
{
    SetProperty(0x1b, VT_I2, propVal);
}

short IDimStyle::GetVertical()
{
    short result;
    GetProperty(0x1c, VT_I2, (void*)&result);
    return result;
}

void IDimStyle::SetVertical(short propVal)
{
    SetProperty(0x1c, VT_I2, propVal);
}

short IDimStyle::GetHorizontal()
{
    short result;
    GetProperty(0x1d, VT_I2, (void*)&result);
    return result;
}

void IDimStyle::SetHorizontal(short propVal)
{
    SetProperty(0x1d, VT_I2, propVal);
}

LPDISPATCH IDimStyle::GetTextColor()
{
    LPDISPATCH result;
    GetProperty(0x1e, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimStyle::SetTextColor(LPDISPATCH propVal)
{
    SetProperty(0x1e, VT_DISPATCH, propVal);
}

double IDimStyle::GetToleranceHeightScaling()
{
    double result;
    GetProperty(0x1f, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetToleranceHeightScaling(double propVal)
{
    SetProperty(0x1f, VT_R8, propVal);
}

double IDimStyle::GetRoundOff()
{
    double result;
    GetProperty(0x20, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetRoundOff(double propVal)
{
    SetProperty(0x20, VT_R8, propVal);
}

CString IDimStyle::GetPreText()
{
    CString result;
    GetProperty(0x21, VT_BSTR, (void*)&result);
    return result;
}

void IDimStyle::SetPreText(LPCTSTR propVal)
{
    SetProperty(0x21, VT_BSTR, propVal);
}

CString IDimStyle::GetPostText()
{
    CString result;
    GetProperty(0x22, VT_BSTR, (void*)&result);
    return result;
}

void IDimStyle::SetPostText(LPCTSTR propVal)
{
    SetProperty(0x22, VT_BSTR, propVal);
}

double IDimStyle::GetLengthScaling()
{
    double result;
    GetProperty(0x23, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetLengthScaling(double propVal)
{
    SetProperty(0x23, VT_R8, propVal);
}

short IDimStyle::GetTolerance()
{
    short result;
    GetProperty(0x24, VT_I2, (void*)&result);
    return result;
}

void IDimStyle::SetTolerance(short propVal)
{
    SetProperty(0x24, VT_I2, propVal);
}

double IDimStyle::GetUpper()
{
    double result;
    GetProperty(0x25, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetUpper(double propVal)
{
    SetProperty(0x25, VT_R8, propVal);
}

double IDimStyle::GetLower()
{
    double result;
    GetProperty(0x26, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetLower(double propVal)
{
    SetProperty(0x26, VT_R8, propVal);
}

BOOL IDimStyle::GetAlternateUnits()
{
    BOOL result;
    GetProperty(0x27, VT_BOOL, (void*)&result);
    return result;
}

void IDimStyle::SetAlternateUnits(BOOL propVal)
{
    SetProperty(0x27, VT_BOOL, propVal);
}

short IDimStyle::GetAlternatePrecision()
{
    short result;
    GetProperty(0x28, VT_I2, (void*)&result);
    return result;
}

void IDimStyle::SetAlternatePrecision(short propVal)
{
    SetProperty(0x28, VT_I2, propVal);
}

CString IDimStyle::GetAlternatePostText()
{
    CString result;
    GetProperty(0x29, VT_BSTR, (void*)&result);
    return result;
}

void IDimStyle::SetAlternatePostText(LPCTSTR propVal)
{
    SetProperty(0x29, VT_BSTR, propVal);
}

double IDimStyle::GetAlternateScaling()
{
    double result;
    GetProperty(0x2a, VT_R8, (void*)&result);
    return result;
}

void IDimStyle::SetAlternateScaling(double propVal)
{
    SetProperty(0x2a, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimStyle operations


/////////////////////////////////////////////////////////////////////////////
// ITextStyles properties

LPDISPATCH ITextStyles::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ITextStyles::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long ITextStyles::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH ITextStyles::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ITextStyles::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITextStyles operations

LPDISPATCH ITextStyles::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL ITextStyles::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH ITextStyles::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void ITextStyles::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITextStyles::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITextStyles::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ITextStyles::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITextStyle properties

LPDISPATCH ITextStyle::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ITextStyle::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString ITextStyle::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void ITextStyle::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString ITextStyle::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void ITextStyle::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

double ITextStyle::GetHeight()
{
    double result;
    GetProperty(0x1, VT_R8, (void*)&result);
    return result;
}

void ITextStyle::SetHeight(double propVal)
{
    SetProperty(0x1, VT_R8, propVal);
}

double ITextStyle::GetLastHeight()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void ITextStyle::SetLastHeight(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double ITextStyle::GetObliqueAngle()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void ITextStyle::SetObliqueAngle(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double ITextStyle::GetXScaling()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void ITextStyle::SetXScaling(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

BOOL ITextStyle::GetUpsideDown()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void ITextStyle::SetUpsideDown(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

BOOL ITextStyle::GetBackwards()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

void ITextStyle::SetBackwards(BOOL propVal)
{
    SetProperty(0x6, VT_BOOL, propVal);
}

CString ITextStyle::GetFont()
{
    CString result;
    GetProperty(0x7, VT_BSTR, (void*)&result);
    return result;
}

void ITextStyle::SetFont(LPCTSTR propVal)
{
    SetProperty(0x7, VT_BSTR, propVal);
}

CString ITextStyle::GetBigFont()
{
    CString result;
    GetProperty(0x8, VT_BSTR, (void*)&result);
    return result;
}

void ITextStyle::SetBigFont(LPCTSTR propVal)
{
    SetProperty(0x8, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ITextStyle operations


/////////////////////////////////////////////////////////////////////////////
// IUcses properties

LPDISPATCH IUcses::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IUcses::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IUcses::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH IUcses::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IUcses::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH IUcses::GetPaperSpace()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IUcses operations

LPDISPATCH IUcses::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL IUcses::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IUcses::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void IUcses::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IUcses::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IUcses::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IUcses::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}

void IUcses::Remove(LPDISPATCH entry)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         entry);
}


/////////////////////////////////////////////////////////////////////////////
// IUcs properties

LPDISPATCH IUcs::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IUcs::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IUcs::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void IUcs::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString IUcs::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void IUcs::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

LPDISPATCH IUcs::GetOrigin()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IUcs::SetOrigin(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IUcs::GetXAxis()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IUcs::SetXAxis(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IUcs::GetYAxis()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IUcs::SetYAxis(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IUcs operations


/////////////////////////////////////////////////////////////////////////////
// INamedViews properties

LPDISPATCH INamedViews::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH INamedViews::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long INamedViews::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// INamedViews operations

LPDISPATCH INamedViews::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

BOOL INamedViews::GetHasItem(const VARIANT& which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH INamedViews::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void INamedViews::Dialog()
{
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void INamedViews::Update()
{
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void INamedViews::UpdateNow()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH INamedViews::Add(LPCTSTR Name)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name);
    return result;
}

void INamedViews::Remove(LPDISPATCH entry)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         entry);
}


/////////////////////////////////////////////////////////////////////////////
// INamedView properties

LPDISPATCH INamedView::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH INamedView::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

CString INamedView::GetName()
{
    CString result;
    GetProperty(0x10001, VT_BSTR, (void*)&result);
    return result;
}

void INamedView::SetName(LPCTSTR propVal)
{
    SetProperty(0x10001, VT_BSTR, propVal);
}

CString INamedView::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

void INamedView::Set_Name(LPCTSTR propVal)
{
    SetProperty(0x0, VT_BSTR, propVal);
}

LPDISPATCH INamedView::GetCenter()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void INamedView::SetCenter(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH INamedView::GetDirection()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void INamedView::SetDirection(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH INamedView::GetTarget()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void INamedView::SetTarget(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

double INamedView::GetHeight()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetHeight(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double INamedView::GetWidth()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetWidth(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

double INamedView::GetTwist()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetTwist(double propVal)
{
    SetProperty(0x6, VT_R8, propVal);
}

double INamedView::GetLensLength()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetLensLength(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

double INamedView::GetFrontClip()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetFrontClip(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

double INamedView::GetBackClip()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void INamedView::SetBackClip(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

BOOL INamedView::GetUseFrontClip()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

void INamedView::SetUseFrontClip(BOOL propVal)
{
    SetProperty(0xa, VT_BOOL, propVal);
}

BOOL INamedView::GetUseBackClip()
{
    BOOL result;
    GetProperty(0xb, VT_BOOL, (void*)&result);
    return result;
}

void INamedView::SetUseBackClip(BOOL propVal)
{
    SetProperty(0xb, VT_BOOL, propVal);
}

BOOL INamedView::GetInPaperSpace()
{
    BOOL result;
    GetProperty(0xc, VT_BOOL, (void*)&result);
    return result;
}

void INamedView::SetInPaperSpace(BOOL propVal)
{
    SetProperty(0xc, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// INamedView operations


/////////////////////////////////////////////////////////////////////////////
// IColors properties

LPDISPATCH IColors::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IColors::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long IColors::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

LPDISPATCH IColors::GetActive()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IColors::SetActive(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IColors::GetSameAsLayer()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IColors::GetSameAsBlock()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IColors operations

LPDISPATCH IColors::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IColors::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void IColors::Dialog()
{
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IColor properties

LPDISPATCH IColor::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IColor::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

CString IColor::GetName()
{
    CString result;
    GetProperty(0x1, VT_BSTR, (void*)&result);
    return result;
}

CString IColor::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

short IColor::GetNumber()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

short IColor::GetRed()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

short IColor::GetGreen()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

short IColor::GetBlue()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IColor operations


/////////////////////////////////////////////////////////////////////////////
// IViews properties

LPDISPATCH IViews::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViews::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long IViews::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

BOOL IViews::GetHasPaperSpace()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

BOOL IViews::GetInPaperSpace()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IViews::SetInPaperSpace(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

BOOL IViews::GetInPaperPorts()
{
    BOOL result;
    GetProperty(0x5, VT_BOOL, (void*)&result);
    return result;
}

void IViews::SetInPaperPorts(BOOL propVal)
{
    SetProperty(0x5, VT_BOOL, propVal);
}

LPDISPATCH IViews::GetActiveView()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IViews::SetActiveView(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

LPDISPATCH IViews::GetPaperSpace()
{
    LPDISPATCH result;
    GetProperty(0x7, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViews::GetExtentsMax()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViews::GetExtentsMin()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViews::GetPaperSpaceExtentsMax()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViews::GetPaperSpaceExtentsMin()
{
    LPDISPATCH result;
    GetProperty(0xb, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IViews operations

LPDISPATCH IViews::GetItem(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH IViews::Get_Item(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH IViews::Add(LPDISPATCH corner1, LPDISPATCH corner2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        corner1, corner2);
    return result;
}

void IViews::Remove(LPDISPATCH entry)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         entry);
}

void IViews::Redraw()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViews::Regen()
{
    InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IView properties

LPDISPATCH IView::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetCenter()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IView::SetCenter(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IView::GetDirection()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IView::SetDirection(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IView::GetTarget()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IView::SetTarget(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

double IView::GetHeight()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void IView::SetHeight(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double IView::GetWidth()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void IView::SetWidth(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

double IView::GetTwist()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

void IView::SetTwist(double propVal)
{
    SetProperty(0x6, VT_R8, propVal);
}

double IView::GetLensLength()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void IView::SetLensLength(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

double IView::GetFrontClip()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void IView::SetFrontClip(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

double IView::GetBackClip()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void IView::SetBackClip(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

BOOL IView::GetUseFrontClip()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

void IView::SetUseFrontClip(BOOL propVal)
{
    SetProperty(0xa, VT_BOOL, propVal);
}

BOOL IView::GetUseBackClip()
{
    BOOL result;
    GetProperty(0xb, VT_BOOL, (void*)&result);
    return result;
}

void IView::SetUseBackClip(BOOL propVal)
{
    SetProperty(0xb, VT_BOOL, propVal);
}

LPDISPATCH IView::GetUpperRight()
{
    LPDISPATCH result;
    GetProperty(0xc, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetLowerLeft()
{
    LPDISPATCH result;
    GetProperty(0xd, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetGridSnap()
{
    LPDISPATCH result;
    GetProperty(0xe, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetAngleSnap()
{
    LPDISPATCH result;
    GetProperty(0xf, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IView::GetEntity()
{
    LPDISPATCH result;
    GetProperty(0x10, VT_DISPATCH, (void*)&result);
    return result;
}

double IView::GetPaperspaceScale()
{
    double result;
    GetProperty(0x24, VT_R8, (void*)&result);
    return result;
}

void IView::SetPaperspaceScale(double propVal)
{
    SetProperty(0x24, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IView operations

LPDISPATCH IView::TranslatePoint(LPDISPATCH point)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point);
    return result;
}

void IView::Redraw()
{
    InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::Regen()
{
    InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::Extents()
{
    InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::View(LPDISPATCH namedview)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         namedview);
}

void IView::ViewPoint(LPDISPATCH vpoint)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vpoint);
}

void IView::ZoomWindow(LPDISPATCH corner1, LPDISPATCH corner2)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         corner1, corner2);
}

void IView::PanWindow(LPDISPATCH point1, LPDISPATCH point2)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2);
}

void IView::ZoomFactor(double factor)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         factor);
}

void IView::PreTranslate(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

void IView::PostTranslate(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

void IView::PreScale(LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         scale);
}

void IView::PostScale(LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         scale);
}

void IView::PreRotate(double xangle, double yangle, double zangle)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         xangle, yangle, zangle);
}

void IView::PostRotate(double xangle, double yangle, double zangle)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         xangle, yangle, zangle);
}

void IView::CenterPreRotate(double xangle, double yangle, double zangle)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         xangle, yangle, zangle);
}

void IView::CenterPostRotate(double xangle, double yangle, double zangle)
{
    static BYTE parms[] =
        VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         xangle, yangle, zangle);
}

void IView::Update()
{
    InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::UpdateNow()
{
    InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::Plan()
{
    InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IView::LastView()
{
    InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IGridSnap properties

LPDISPATCH IGridSnap::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IGridSnap::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IGridSnap::GetSnap()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void IGridSnap::SetSnap(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IGridSnap::Get_Snap()
{
    BOOL result;
    GetProperty(0x0, VT_BOOL, (void*)&result);
    return result;
}

void IGridSnap::Set_Snap(BOOL propVal)
{
    SetProperty(0x0, VT_BOOL, propVal);
}

BOOL IGridSnap::GetDisplay()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void IGridSnap::SetDisplay(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IGridSnap::GetIsometric()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IGridSnap::SetIsometric(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

LPDISPATCH IGridSnap::GetSnapSpacing()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void IGridSnap::SetSnapSpacing(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH IGridSnap::GetDisplaySpacing()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IGridSnap::SetDisplaySpacing(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

LPDISPATCH IGridSnap::GetOrigin()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IGridSnap::SetOrigin(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

double IGridSnap::GetIsometricSpacing()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void IGridSnap::SetIsometricSpacing(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IGridSnap operations

void IGridSnap::Update()
{
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IGridSnap::UpdateNow()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IGridSnap::Dialog()
{
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IAngleSnap properties

LPDISPATCH IAngleSnap::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAngleSnap::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IAngleSnap::GetSnap()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void IAngleSnap::SetSnap(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IAngleSnap::Get_Snap()
{
    BOOL result;
    GetProperty(0x0, VT_BOOL, (void*)&result);
    return result;
}

void IAngleSnap::Set_Snap(BOOL propVal)
{
    SetProperty(0x0, VT_BOOL, propVal);
}

BOOL IAngleSnap::GetOrtho()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void IAngleSnap::SetOrtho(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

double IAngleSnap::GetAngle()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void IAngleSnap::SetAngle(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double IAngleSnap::GetBaseAngle()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void IAngleSnap::SetBaseAngle(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAngleSnap operations

void IAngleSnap::Dialog()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IEntities properties

LPDISPATCH IEntities::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntities::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x30002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntities::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntities::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x20001, VT_DISPATCH, propVal);
}

short IEntities::GetColorNumber()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

void IEntities::SetColorNumber(short propVal)
{
    SetProperty(0x20002, VT_I2, propVal);
}

LPDISPATCH IEntities::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x20003, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntities::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x20003, VT_DISPATCH, propVal);
}

LPDISPATCH IEntities::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x20004, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntities::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x20004, VT_DISPATCH, propVal);
}

double IEntities::GetThickness()
{
    double result;
    GetProperty(0x20005, VT_R8, (void*)&result);
    return result;
}

void IEntities::SetThickness(double propVal)
{
    SetProperty(0x20005, VT_R8, propVal);
}

BOOL IEntities::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x20006, VT_BOOL, (void*)&result);
    return result;
}

void IEntities::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x20006, VT_BOOL, propVal);
}

LPDISPATCH IEntities::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x20007, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntities::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x20007, VT_DISPATCH, propVal);
}

BOOL IEntities::GetHasItems()
{
    BOOL result;
    GetProperty(0x10001, VT_BOOL, (void*)&result);
    return result;
}

long IEntities::GetCount()
{
    long result;
    GetProperty(0x10002, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IEntities operations

void IEntities::Redraw()
{
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Regen()
{
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Erase()
{
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Delete()
{
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IEntities::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IEntities::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntities::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntities::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IEntities::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IEntities::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IEntities::Dialog()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntities::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IEntities::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IEntities::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IEntities::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IEntities::DisplayGrips()
{
    InvokeHelper(0x20018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::EraseGrips()
{
    InvokeHelper(0x20019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntities::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IEntities::GetLast()
{
    LPDISPATCH result;
    InvokeHelper(0x10004, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::GetFirst()
{
    LPDISPATCH result;
    InvokeHelper(0x10005, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::GetNext()
{
    LPDISPATCH result;
    InvokeHelper(0x10006, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IEntities::AddLine()
{
    LPDISPATCH result;
    InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddCircle()
{
    LPDISPATCH result;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddArc()
{
    LPDISPATCH result;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddFace()
{
    LPDISPATCH result;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddText()
{
    LPDISPATCH result;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddPoint()
{
    LPDISPATCH result;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddShape()
{
    LPDISPATCH result;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddTrace()
{
    LPDISPATCH result;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddSolid()
{
    LPDISPATCH result;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddPolyline(short vertices)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vertices);
    return result;
}

LPDISPATCH IEntities::Add3DPolyline(short vertices)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vertices);
    return result;
}

LPDISPATCH IEntities::AddPolymesh(short rows, short columns)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        rows, columns);
    return result;
}

LPDISPATCH IEntities::AddPolyface(short vertices, short faces)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vertices, faces);
    return result;
}

LPDISPATCH IEntities::AddAttdef()
{
    LPDISPATCH result;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddDimension()
{
    LPDISPATCH result;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntities::AddInsert(LPCTSTR blockname)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        blockname);
    return result;
}

void IEntities::DrawLines()
{
    InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawLine()
{
    InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawDoubleLines()
{
    InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw2DPolyline()
{
    InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3DPolyline()
{
    InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawCircle()
{
    InvokeHelper(0x18, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw2PointCircle()
{
    InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3PointCircle()
{
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3PointArcs()
{
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3PointArc()
{
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawCenterStartEndArc()
{
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawStartCenterEndArc()
{
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawStartEndCenterArc()
{
    InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawStartDirectionEndArc()
{
    InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawFace()
{
    InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawPoint()
{
    InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawSolid()
{
    InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawTrace()
{
    InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawText()
{
    InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawAttdef()
{
    InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawInsert(const VARIANT& which)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &which);
}

void IEntities::Draw2DSpline()
{
    InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3DSpline()
{
    InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw2DQuadraticSpline()
{
    InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3DQuadraticSpline()
{
    InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw2DCubicSpline()
{
    InvokeHelper(0x2c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3DCubicSpline()
{
    InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw2PointRectangle()
{
    InvokeHelper(0x2e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::Draw3PointRectangle()
{
    InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawCenterVertexPolygon()
{
    InvokeHelper(0x30, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawCenterMidpointPolygon()
{
    InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawEdgePolygon()
{
    InvokeHelper(0x32, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawDonut()
{
    InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawHorizontalDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawVerticalDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawAlignedDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawRotatedDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawAngularDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::Draw4PointAngularDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x39, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawRadiusDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawDiameterDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawOrdinateXDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawOrdinateYDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawBaselineDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawContinuousDim(const VARIANT& what)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x3f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &what);
}

void IEntities::DrawLeader()
{
    InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntities::DrawViewport()
{
    InvokeHelper(0x41, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ISelection properties

LPDISPATCH ISelection::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ISelection::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x30002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ISelection::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

void ISelection::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x20001, VT_DISPATCH, propVal);
}

short ISelection::GetColorNumber()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

void ISelection::SetColorNumber(short propVal)
{
    SetProperty(0x20002, VT_I2, propVal);
}

LPDISPATCH ISelection::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x20003, VT_DISPATCH, (void*)&result);
    return result;
}

void ISelection::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x20003, VT_DISPATCH, propVal);
}

LPDISPATCH ISelection::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x20004, VT_DISPATCH, (void*)&result);
    return result;
}

void ISelection::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x20004, VT_DISPATCH, propVal);
}

double ISelection::GetThickness()
{
    double result;
    GetProperty(0x20005, VT_R8, (void*)&result);
    return result;
}

void ISelection::SetThickness(double propVal)
{
    SetProperty(0x20005, VT_R8, propVal);
}

BOOL ISelection::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x20006, VT_BOOL, (void*)&result);
    return result;
}

void ISelection::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x20006, VT_BOOL, propVal);
}

LPDISPATCH ISelection::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x20007, VT_DISPATCH, (void*)&result);
    return result;
}

void ISelection::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x20007, VT_DISPATCH, propVal);
}

BOOL ISelection::GetHasItems()
{
    BOOL result;
    GetProperty(0x10001, VT_BOOL, (void*)&result);
    return result;
}

long ISelection::GetCount()
{
    long result;
    GetProperty(0x10002, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ISelection operations

void ISelection::Redraw()
{
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::Regen()
{
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::Erase()
{
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::Delete()
{
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH ISelection::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void ISelection::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ISelection::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ISelection::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void ISelection::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH ISelection::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void ISelection::Dialog()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISelection::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH ISelection::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH ISelection::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH ISelection::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void ISelection::DisplayGrips()
{
    InvokeHelper(0x20018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::EraseGrips()
{
    InvokeHelper(0x20019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISelection::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH ISelection::GetLast()
{
    LPDISPATCH result;
    InvokeHelper(0x10004, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH ISelection::GetFirst()
{
    LPDISPATCH result;
    InvokeHelper(0x10005, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH ISelection::GetNext()
{
    LPDISPATCH result;
    InvokeHelper(0x10006, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH ISelection::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void ISelection::Add(LPDISPATCH Entity)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Entity);
}

void ISelection::Remove(LPDISPATCH Entity)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Entity);
}

void ISelection::RemoveAll()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::AddAll()
{
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::AddPrevious()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::CrossingWindow(LPDISPATCH corner1, LPDISPATCH corner2)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         corner1, corner2);
}

void ISelection::ContainingWindow(LPDISPATCH corner1, LPDISPATCH corner2)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         corner1, corner2);
}

void ISelection::PickSingle(LPDISPATCH point)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point);
}

void ISelection::CopyToClipboard(const VARIANT& basepoint)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &basepoint);
}

void ISelection::CutToClipboard(const VARIANT& basepoint)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         &basepoint);
}

void ISelection::WindowToClipboard()
{
    InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISelection::TextToClipboard()
{
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IEntitySet properties

LPDISPATCH IEntitySet::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntitySet::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x30002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntitySet::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntitySet::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x20001, VT_DISPATCH, propVal);
}

short IEntitySet::GetColorNumber()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

void IEntitySet::SetColorNumber(short propVal)
{
    SetProperty(0x20002, VT_I2, propVal);
}

LPDISPATCH IEntitySet::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x20003, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntitySet::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x20003, VT_DISPATCH, propVal);
}

LPDISPATCH IEntitySet::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x20004, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntitySet::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x20004, VT_DISPATCH, propVal);
}

double IEntitySet::GetThickness()
{
    double result;
    GetProperty(0x20005, VT_R8, (void*)&result);
    return result;
}

void IEntitySet::SetThickness(double propVal)
{
    SetProperty(0x20005, VT_R8, propVal);
}

BOOL IEntitySet::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x20006, VT_BOOL, (void*)&result);
    return result;
}

void IEntitySet::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x20006, VT_BOOL, propVal);
}

LPDISPATCH IEntitySet::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x20007, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntitySet::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x20007, VT_DISPATCH, propVal);
}

BOOL IEntitySet::GetHasItems()
{
    BOOL result;
    GetProperty(0x10001, VT_BOOL, (void*)&result);
    return result;
}

long IEntitySet::GetCount()
{
    long result;
    GetProperty(0x10002, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IEntitySet operations

void IEntitySet::Redraw()
{
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::Regen()
{
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::Erase()
{
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::Delete()
{
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IEntitySet::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IEntitySet::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntitySet::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntitySet::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IEntitySet::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IEntitySet::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IEntitySet::Dialog()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntitySet::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IEntitySet::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IEntitySet::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x20016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IEntitySet::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x20017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IEntitySet::DisplayGrips()
{
    InvokeHelper(0x20018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::EraseGrips()
{
    InvokeHelper(0x20019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntitySet::GetItem(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x10003, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

LPDISPATCH IEntitySet::GetLast()
{
    LPDISPATCH result;
    InvokeHelper(0x10004, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntitySet::GetFirst()
{
    LPDISPATCH result;
    InvokeHelper(0x10005, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntitySet::GetNext()
{
    LPDISPATCH result;
    InvokeHelper(0x10006, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IEntitySet::Get_Item(const VARIANT& which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        &which);
    return result;
}

void IEntitySet::Add(LPDISPATCH Entity)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Entity);
}

void IEntitySet::Remove(LPDISPATCH Entity)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Entity);
}

void IEntitySet::RemoveAll()
{
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntitySet::AddAll()
{
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IXData properties

LPDISPATCH IXData::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IXData::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

short IXData::GetGroup()
{
    short result;
    GetProperty(0x1, VT_I2, (void*)&result);
    return result;
}

short IXData::GetType()
{
    short result;
    GetProperty(0x2, VT_I2, (void*)&result);
    return result;
}

short IXData::GetIndex()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void IXData::SetIndex(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

CString IXData::GetString()
{
    CString result;
    GetProperty(0x4, VT_BSTR, (void*)&result);
    return result;
}

void IXData::SetString(LPCTSTR propVal)
{
    SetProperty(0x4, VT_BSTR, propVal);
}

short IXData::GetControl()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

void IXData::SetControl(short propVal)
{
    SetProperty(0x5, VT_I2, propVal);
}

LPDISPATCH IXData::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IXData::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

CString IXData::GetHandle()
{
    CString result;
    GetProperty(0x7, VT_BSTR, (void*)&result);
    return result;
}

void IXData::SetHandle(LPCTSTR propVal)
{
    SetProperty(0x7, VT_BSTR, propVal);
}

LPDISPATCH IXData::GetVector()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

void IXData::SetVector(LPDISPATCH propVal)
{
    SetProperty(0x8, VT_DISPATCH, propVal);
}

double IXData::GetDouble()
{
    double result;
    GetProperty(0x9, VT_R8, (void*)&result);
    return result;
}

void IXData::SetDouble(double propVal)
{
    SetProperty(0x9, VT_R8, propVal);
}

short IXData::GetShort()
{
    short result;
    GetProperty(0xa, VT_I2, (void*)&result);
    return result;
}

void IXData::SetShort(short propVal)
{
    SetProperty(0xa, VT_I2, propVal);
}

long IXData::GetLong()
{
    long result;
    GetProperty(0xb, VT_I4, (void*)&result);
    return result;
}

void IXData::SetLong(long propVal)
{
    SetProperty(0xb, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IXData operations

BOOL IXData::Next()
{
    BOOL result;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IXData::Add(short Group, const VARIANT& data)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I2 VTS_VARIANT;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Group, &data);
    return result;
}

BOOL IXData::Remove()
{
    BOOL result;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IXData::FindApplicationID(LPCTSTR appname)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        appname);
    return result;
}

BOOL IXData::AddApplicationID(LPCTSTR appname)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        appname);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IEntity properties

LPDISPATCH IEntity::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntity::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IEntity::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntity::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IEntity::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IEntity::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IEntity::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntity::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IEntity::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntity::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IEntity::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IEntity::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IEntity::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IEntity::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IEntity::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IEntity::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IEntity::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IEntity::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IEntity::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IEntity::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IEntity::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IEntity::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IEntity::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IEntity operations

void IEntity::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IEntity::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IEntity::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntity::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IEntity::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IEntity::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IEntity::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IEntity::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntity::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IEntity::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IEntity::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IEntity::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IEntity::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IEntity::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IEntity::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IEntity::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IEntity::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IEntity::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IEntity::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IEntity::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IEntity::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IEntity::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ILine properties

LPDISPATCH ILine::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILine::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ILine::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short ILine::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void ILine::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH ILine::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH ILine::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double ILine::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void ILine::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL ILine::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void ILine::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH ILine::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString ILine::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short ILine::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString ILine::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL ILine::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH ILine::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL ILine::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void ILine::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString ILine::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH ILine::GetWhere1()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetWhere1(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH ILine::GetWhere2()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetWhere2(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

double ILine::GetLength()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

LPDISPATCH ILine::GetStartPoint()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetStartPoint(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH ILine::GetEndpoint()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ILine::SetEndpoint(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

double ILine::GetAngle()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ILine operations

void ILine::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH ILine::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void ILine::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ILine::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ILine::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void ILine::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH ILine::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void ILine::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ILine::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH ILine::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH ILine::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH ILine::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void ILine::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ILine::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ILine::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ILine::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ILine::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL ILine::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ILine::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ILine::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void ILine::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ILine::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

short ILine::Fillet(LPDISPATCH Entity, LPDISPATCH pick1, LPDISPATCH pick2)
{
    short result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
        Entity, pick1, pick2);
    return result;
}

short ILine::Chamfer(LPDISPATCH Entity, LPDISPATCH pick1, LPDISPATCH pick2)
{
    short result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
        Entity, pick1, pick2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPoint properties

LPDISPATCH IPoint::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPoint::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPoint::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IPoint::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IPoint::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IPoint::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IPoint::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IPoint::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IPoint::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IPoint::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IPoint::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IPoint::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IPoint::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IPoint::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IPoint::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IPoint::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IPoint::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IPoint::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IPoint::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IPoint::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IPoint::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IPoint::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IPoint::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IPoint::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IPoint::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IPoint::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double IPoint::GetRotation()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void IPoint::SetRotation(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IPoint operations

void IPoint::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IPoint::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IPoint::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPoint::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPoint::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IPoint::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IPoint::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IPoint::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPoint::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IPoint::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IPoint::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IPoint::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IPoint::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPoint::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPoint::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPoint::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPoint::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IPoint::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPoint::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPoint::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IPoint::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPoint::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ICircle properties

LPDISPATCH ICircle::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ICircle::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ICircle::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short ICircle::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void ICircle::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH ICircle::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH ICircle::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double ICircle::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void ICircle::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL ICircle::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void ICircle::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH ICircle::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString ICircle::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short ICircle::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString ICircle::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL ICircle::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH ICircle::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL ICircle::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void ICircle::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString ICircle::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH ICircle::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double ICircle::GetRadius()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void ICircle::SetRadius(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double ICircle::GetCircumference()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

double ICircle::GetArea()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

LPDISPATCH ICircle::GetCenter()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void ICircle::SetCenter(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// ICircle operations

void ICircle::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH ICircle::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void ICircle::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ICircle::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ICircle::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void ICircle::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH ICircle::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void ICircle::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ICircle::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH ICircle::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH ICircle::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH ICircle::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void ICircle::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ICircle::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ICircle::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ICircle::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ICircle::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL ICircle::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ICircle::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ICircle::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void ICircle::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ICircle::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IShape properties

LPDISPATCH IShape::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IShape::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IShape::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IShape::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IShape::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IShape::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IShape::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IShape::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IShape::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IShape::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IShape::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IShape::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IShape::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IShape::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IShape::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IShape::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IShape::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IShape::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IShape::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IShape::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IShape::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

CString IShape::GetShapeName()
{
    CString result;
    GetProperty(0x2, VT_BSTR, (void*)&result);
    return result;
}

void IShape::SetShapeName(LPCTSTR propVal)
{
    SetProperty(0x2, VT_BSTR, propVal);
}

short IShape::GetShapeNumber()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void IShape::SetShapeNumber(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

double IShape::GetRotation()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void IShape::SetRotation(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double IShape::GetSize()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void IShape::SetSize(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

LPDISPATCH IShape::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x6, VT_DISPATCH, (void*)&result);
    return result;
}

void IShape::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x6, VT_DISPATCH, propVal);
}

double IShape::GetXScaling()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void IShape::SetXScaling(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IShape operations

void IShape::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IShape::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IShape::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IShape::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IShape::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IShape::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IShape::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IShape::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IShape::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IShape::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IShape::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IShape::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IShape::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IShape::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IShape::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IShape::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IShape::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IShape::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IShape::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IShape::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IShape::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IShape::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IArc properties

LPDISPATCH IArc::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IArc::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IArc::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IArc::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IArc::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IArc::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IArc::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IArc::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IArc::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IArc::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IArc::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IArc::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IArc::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IArc::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IArc::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IArc::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IArc::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double IArc::GetRadius()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void IArc::SetRadius(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double IArc::GetStartAngle()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void IArc::SetStartAngle(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double IArc::GetEndAngle()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void IArc::SetEndAngle(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double IArc::GetLength()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

double IArc::GetChordedArea()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

double IArc::GetPieArea()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetWhere1()
{
    LPDISPATCH result;
    GetProperty(0x8, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetWhere2()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetStartPoint()
{
    LPDISPATCH result;
    GetProperty(0xa, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetEndpoint()
{
    LPDISPATCH result;
    GetProperty(0xb, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IArc::GetCenter()
{
    LPDISPATCH result;
    GetProperty(0xc, VT_DISPATCH, (void*)&result);
    return result;
}

void IArc::SetCenter(LPDISPATCH propVal)
{
    SetProperty(0xc, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IArc operations

void IArc::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IArc::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IArc::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IArc::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IArc::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IArc::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IArc::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IArc::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IArc::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IArc::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IArc::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IArc::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IArc::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IArc::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IArc::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IArc::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IArc::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IArc::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IArc::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IArc::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IArc::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IArc::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ISolid properties

LPDISPATCH ISolid::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ISolid::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ISolid::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void ISolid::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short ISolid::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void ISolid::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH ISolid::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void ISolid::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH ISolid::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void ISolid::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double ISolid::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void ISolid::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL ISolid::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void ISolid::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH ISolid::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void ISolid::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString ISolid::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short ISolid::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString ISolid::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL ISolid::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH ISolid::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL ISolid::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void ISolid::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double ISolid::GetCircumference()
{
    double result;
    GetProperty(0x10002, VT_R8, (void*)&result);
    return result;
}

double ISolid::GetArea()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

CString ISolid::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ISolid operations

void ISolid::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH ISolid::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void ISolid::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ISolid::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ISolid::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void ISolid::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH ISolid::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void ISolid::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISolid::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH ISolid::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH ISolid::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH ISolid::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void ISolid::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISolid::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ISolid::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ISolid::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ISolid::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL ISolid::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ISolid::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ISolid::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void ISolid::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ISolid::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ISolid::GetWhere(short which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x10001, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void ISolid::SetWhere(short which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_DISPATCH;
    InvokeHelper(0x10001, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}


/////////////////////////////////////////////////////////////////////////////
// ITrace properties

LPDISPATCH ITrace::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ITrace::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH ITrace::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void ITrace::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short ITrace::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void ITrace::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH ITrace::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void ITrace::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH ITrace::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void ITrace::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double ITrace::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void ITrace::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL ITrace::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void ITrace::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH ITrace::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void ITrace::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString ITrace::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short ITrace::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString ITrace::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL ITrace::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH ITrace::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL ITrace::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void ITrace::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double ITrace::GetCircumference()
{
    double result;
    GetProperty(0x10002, VT_R8, (void*)&result);
    return result;
}

double ITrace::GetArea()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

CString ITrace::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// ITrace operations

void ITrace::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH ITrace::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void ITrace::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ITrace::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void ITrace::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void ITrace::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH ITrace::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void ITrace::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ITrace::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH ITrace::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH ITrace::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH ITrace::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void ITrace::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ITrace::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH ITrace::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ITrace::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH ITrace::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL ITrace::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ITrace::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL ITrace::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void ITrace::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void ITrace::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH ITrace::GetWhere(short which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x10001, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void ITrace::SetWhere(short which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_DISPATCH;
    InvokeHelper(0x10001, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}


/////////////////////////////////////////////////////////////////////////////
// IFace properties

LPDISPATCH IFace::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IFace::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IFace::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IFace::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IFace::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IFace::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IFace::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IFace::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IFace::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IFace::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IFace::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IFace::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IFace::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IFace::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IFace::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IFace::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IFace::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IFace::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IFace::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IFace::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IFace::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IFace::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IFace::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IFace::GetCircumference()
{
    double result;
    GetProperty(0x10002, VT_R8, (void*)&result);
    return result;
}

double IFace::GetArea()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

CString IFace::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IFace operations

void IFace::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IFace::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IFace::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IFace::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IFace::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IFace::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IFace::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IFace::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IFace::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IFace::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IFace::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IFace::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IFace::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IFace::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFace::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IFace::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IFace::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IFace::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IFace::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IFace::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IFace::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFace::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IFace::GetWhere(short which)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x10001, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        which);
    return result;
}

void IFace::SetWhere(short which, LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_DISPATCH;
    InvokeHelper(0x10001, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         which, newValue);
}

BOOL IFace::GetVisible(short which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        which);
    return result;
}

void IFace::SetVisible(short which, BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         which, bNewValue);
}


/////////////////////////////////////////////////////////////////////////////
// IInsert properties

LPDISPATCH IInsert::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IInsert::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IInsert::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IInsert::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IInsert::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IInsert::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IInsert::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IInsert::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IInsert::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IInsert::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IInsert::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IInsert::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IInsert::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IInsert::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IInsert::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IInsert::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IInsert::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IInsert::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IInsert::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IInsert::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IInsert::GetBlock()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IInsert::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IInsert::GetScaling()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IInsert::SetScaling(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

double IInsert::GetRotation()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void IInsert::SetRotation(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

short IInsert::GetColumns()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

void IInsert::SetColumns(short propVal)
{
    SetProperty(0x5, VT_I2, propVal);
}

short IInsert::GetRows()
{
    short result;
    GetProperty(0x6, VT_I2, (void*)&result);
    return result;
}

void IInsert::SetRows(short propVal)
{
    SetProperty(0x6, VT_I2, propVal);
}

double IInsert::GetColumnSpacing()
{
    double result;
    GetProperty(0x7, VT_R8, (void*)&result);
    return result;
}

void IInsert::SetColumnSpacing(double propVal)
{
    SetProperty(0x7, VT_R8, propVal);
}

double IInsert::GetRowSpacing()
{
    double result;
    GetProperty(0x8, VT_R8, (void*)&result);
    return result;
}

void IInsert::SetRowSpacing(double propVal)
{
    SetProperty(0x8, VT_R8, propVal);
}

LPDISPATCH IInsert::GetAttributes()
{
    LPDISPATCH result;
    GetProperty(0x9, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IInsert::GetHasAttributes()
{
    BOOL result;
    GetProperty(0xa, VT_BOOL, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IInsert operations

void IInsert::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IInsert::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IInsert::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IInsert::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IInsert::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IInsert::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IInsert::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IInsert::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IInsert::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IInsert::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IInsert::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IInsert::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IInsert::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IInsert::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IInsert::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IInsert::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IInsert::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IInsert::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IInsert::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IInsert::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IInsert::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IInsert::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IInsert::Explode()
{
    BOOL result;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IText properties

LPDISPATCH IText::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IText::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IText::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IText::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IText::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IText::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IText::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IText::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IText::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IText::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IText::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IText::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IText::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IText::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IText::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IText::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IText::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IText::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IText::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

LPDISPATCH IText::GetAlignPoint()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetAlignPoint(LPDISPATCH propVal)
{
    SetProperty(0x10001, VT_DISPATCH, propVal);
}

BOOL IText::GetBackwards()
{
    BOOL result;
    GetProperty(0x10002, VT_BOOL, (void*)&result);
    return result;
}

void IText::SetBackwards(BOOL propVal)
{
    SetProperty(0x10002, VT_BOOL, propVal);
}

double IText::GetHeight()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

void IText::SetHeight(double propVal)
{
    SetProperty(0x10003, VT_R8, propVal);
}

short IText::GetHorizontal()
{
    short result;
    GetProperty(0x10004, VT_I2, (void*)&result);
    return result;
}

void IText::SetHorizontal(short propVal)
{
    SetProperty(0x10004, VT_I2, propVal);
}

double IText::GetObliqueAngle()
{
    double result;
    GetProperty(0x10005, VT_R8, (void*)&result);
    return result;
}

void IText::SetObliqueAngle(double propVal)
{
    SetProperty(0x10005, VT_R8, propVal);
}

double IText::GetRotation()
{
    double result;
    GetProperty(0x10006, VT_R8, (void*)&result);
    return result;
}

void IText::SetRotation(double propVal)
{
    SetProperty(0x10006, VT_R8, propVal);
}

LPDISPATCH IText::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IText::GetWhereJustified()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetWhereJustified(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

CString IText::GetText()
{
    CString result;
    GetProperty(0x10009, VT_BSTR, (void*)&result);
    return result;
}

void IText::SetText(LPCTSTR propVal)
{
    SetProperty(0x10009, VT_BSTR, propVal);
}

LPDISPATCH IText::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000a, VT_DISPATCH, (void*)&result);
    return result;
}

void IText::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000a, VT_DISPATCH, propVal);
}

BOOL IText::GetUpsideDown()
{
    BOOL result;
    GetProperty(0x1000b, VT_BOOL, (void*)&result);
    return result;
}

void IText::SetUpsideDown(BOOL propVal)
{
    SetProperty(0x1000b, VT_BOOL, propVal);
}

short IText::GetVertical()
{
    short result;
    GetProperty(0x1000c, VT_I2, (void*)&result);
    return result;
}

void IText::SetVertical(short propVal)
{
    SetProperty(0x1000c, VT_I2, propVal);
}

double IText::GetXScaling()
{
    double result;
    GetProperty(0x1000d, VT_R8, (void*)&result);
    return result;
}

void IText::SetXScaling(double propVal)
{
    SetProperty(0x1000d, VT_R8, propVal);
}

CString IText::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IText operations

void IText::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IText::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IText::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IText::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IText::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IText::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IText::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IText::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IText::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IText::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IText::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IText::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IText::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IText::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IText::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IText::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IText::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IText::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IText::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IText::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IText::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IText::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IAttdef properties

LPDISPATCH IAttdef::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAttdef::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAttdef::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IAttdef::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IAttdef::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IAttdef::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IAttdef::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IAttdef::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IAttdef::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IAttdef::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IAttdef::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IAttdef::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IAttdef::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IAttdef::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IAttdef::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IAttdef::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IAttdef::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

LPDISPATCH IAttdef::GetAlignPoint()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetAlignPoint(LPDISPATCH propVal)
{
    SetProperty(0x10001, VT_DISPATCH, propVal);
}

BOOL IAttdef::GetBackwards()
{
    BOOL result;
    GetProperty(0x10002, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetBackwards(BOOL propVal)
{
    SetProperty(0x10002, VT_BOOL, propVal);
}

double IAttdef::GetHeight()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

void IAttdef::SetHeight(double propVal)
{
    SetProperty(0x10003, VT_R8, propVal);
}

short IAttdef::GetHorizontal()
{
    short result;
    GetProperty(0x10004, VT_I2, (void*)&result);
    return result;
}

void IAttdef::SetHorizontal(short propVal)
{
    SetProperty(0x10004, VT_I2, propVal);
}

double IAttdef::GetObliqueAngle()
{
    double result;
    GetProperty(0x10005, VT_R8, (void*)&result);
    return result;
}

void IAttdef::SetObliqueAngle(double propVal)
{
    SetProperty(0x10005, VT_R8, propVal);
}

double IAttdef::GetRotation()
{
    double result;
    GetProperty(0x10006, VT_R8, (void*)&result);
    return result;
}

void IAttdef::SetRotation(double propVal)
{
    SetProperty(0x10006, VT_R8, propVal);
}

LPDISPATCH IAttdef::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IAttdef::GetWhereJustified()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetWhereJustified(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

CString IAttdef::GetText()
{
    CString result;
    GetProperty(0x10009, VT_BSTR, (void*)&result);
    return result;
}

void IAttdef::SetText(LPCTSTR propVal)
{
    SetProperty(0x10009, VT_BSTR, propVal);
}

LPDISPATCH IAttdef::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000a, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttdef::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000a, VT_DISPATCH, propVal);
}

BOOL IAttdef::GetUpsideDown()
{
    BOOL result;
    GetProperty(0x1000b, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetUpsideDown(BOOL propVal)
{
    SetProperty(0x1000b, VT_BOOL, propVal);
}

short IAttdef::GetVertical()
{
    short result;
    GetProperty(0x1000c, VT_I2, (void*)&result);
    return result;
}

void IAttdef::SetVertical(short propVal)
{
    SetProperty(0x1000c, VT_I2, propVal);
}

double IAttdef::GetXScaling()
{
    double result;
    GetProperty(0x1000d, VT_R8, (void*)&result);
    return result;
}

void IAttdef::SetXScaling(double propVal)
{
    SetProperty(0x1000d, VT_R8, propVal);
}

CString IAttdef::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

BOOL IAttdef::GetVisible()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetVisible(BOOL propVal)
{
    SetProperty(0x1, VT_BOOL, propVal);
}

BOOL IAttdef::GetConstant()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetConstant(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IAttdef::GetVerify()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetVerify(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

BOOL IAttdef::GetPreset()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

void IAttdef::SetPreset(BOOL propVal)
{
    SetProperty(0x4, VT_BOOL, propVal);
}

CString IAttdef::GetTag()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

void IAttdef::SetTag(LPCTSTR propVal)
{
    SetProperty(0x5, VT_BSTR, propVal);
}

CString IAttdef::GetPrompt()
{
    CString result;
    GetProperty(0x6, VT_BSTR, (void*)&result);
    return result;
}

void IAttdef::SetPrompt(LPCTSTR propVal)
{
    SetProperty(0x6, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAttdef operations

void IAttdef::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IAttdef::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IAttdef::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IAttdef::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IAttdef::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IAttdef::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IAttdef::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IAttdef::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IAttdef::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IAttdef::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IAttdef::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IAttdef::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IAttdef::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IAttdef::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttdef::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IAttdef::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IAttdef::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IAttdef::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IAttdef::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IAttdef::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IAttdef::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttdef::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IAttributes properties

LPDISPATCH IAttributes::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAttributes::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

long IAttributes::GetCount()
{
    long result;
    GetProperty(0x1, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IAttributes operations

LPDISPATCH IAttributes::GetItem(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH IAttributes::Get_Item(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IAttribute properties

LPDISPATCH IAttribute::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAttribute::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IAttribute::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IAttribute::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IAttribute::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IAttribute::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IAttribute::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IAttribute::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IAttribute::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IAttribute::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IAttribute::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IAttribute::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IAttribute::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IAttribute::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IAttribute::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IAttribute::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IAttribute::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IAttribute::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IAttribute::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

LPDISPATCH IAttribute::GetAlignPoint()
{
    LPDISPATCH result;
    GetProperty(0x10001, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetAlignPoint(LPDISPATCH propVal)
{
    SetProperty(0x10001, VT_DISPATCH, propVal);
}

BOOL IAttribute::GetBackwards()
{
    BOOL result;
    GetProperty(0x10002, VT_BOOL, (void*)&result);
    return result;
}

void IAttribute::SetBackwards(BOOL propVal)
{
    SetProperty(0x10002, VT_BOOL, propVal);
}

double IAttribute::GetHeight()
{
    double result;
    GetProperty(0x10003, VT_R8, (void*)&result);
    return result;
}

void IAttribute::SetHeight(double propVal)
{
    SetProperty(0x10003, VT_R8, propVal);
}

short IAttribute::GetHorizontal()
{
    short result;
    GetProperty(0x10004, VT_I2, (void*)&result);
    return result;
}

void IAttribute::SetHorizontal(short propVal)
{
    SetProperty(0x10004, VT_I2, propVal);
}

double IAttribute::GetObliqueAngle()
{
    double result;
    GetProperty(0x10005, VT_R8, (void*)&result);
    return result;
}

void IAttribute::SetObliqueAngle(double propVal)
{
    SetProperty(0x10005, VT_R8, propVal);
}

double IAttribute::GetRotation()
{
    double result;
    GetProperty(0x10006, VT_R8, (void*)&result);
    return result;
}

void IAttribute::SetRotation(double propVal)
{
    SetProperty(0x10006, VT_R8, propVal);
}

LPDISPATCH IAttribute::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IAttribute::GetWhereJustified()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetWhereJustified(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

CString IAttribute::GetText()
{
    CString result;
    GetProperty(0x10009, VT_BSTR, (void*)&result);
    return result;
}

void IAttribute::SetText(LPCTSTR propVal)
{
    SetProperty(0x10009, VT_BSTR, propVal);
}

LPDISPATCH IAttribute::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000a, VT_DISPATCH, (void*)&result);
    return result;
}

void IAttribute::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000a, VT_DISPATCH, propVal);
}

BOOL IAttribute::GetUpsideDown()
{
    BOOL result;
    GetProperty(0x1000b, VT_BOOL, (void*)&result);
    return result;
}

void IAttribute::SetUpsideDown(BOOL propVal)
{
    SetProperty(0x1000b, VT_BOOL, propVal);
}

short IAttribute::GetVertical()
{
    short result;
    GetProperty(0x1000c, VT_I2, (void*)&result);
    return result;
}

void IAttribute::SetVertical(short propVal)
{
    SetProperty(0x1000c, VT_I2, propVal);
}

double IAttribute::GetXScaling()
{
    double result;
    GetProperty(0x1000d, VT_R8, (void*)&result);
    return result;
}

void IAttribute::SetXScaling(double propVal)
{
    SetProperty(0x1000d, VT_R8, propVal);
}

CString IAttribute::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

BOOL IAttribute::GetVisible()
{
    BOOL result;
    GetProperty(0x1, VT_BOOL, (void*)&result);
    return result;
}

BOOL IAttribute::GetConstant()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

BOOL IAttribute::GetVerify()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

BOOL IAttribute::GetPreset()
{
    BOOL result;
    GetProperty(0x4, VT_BOOL, (void*)&result);
    return result;
}

CString IAttribute::GetTag()
{
    CString result;
    GetProperty(0x5, VT_BSTR, (void*)&result);
    return result;
}

void IAttribute::SetTag(LPCTSTR propVal)
{
    SetProperty(0x5, VT_BSTR, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IAttribute operations

void IAttribute::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IAttribute::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IAttribute::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IAttribute::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IAttribute::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IAttribute::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IAttribute::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IAttribute::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IAttribute::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IAttribute::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IAttribute::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IAttribute::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IAttribute::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IAttribute::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IAttribute::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IAttribute::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IAttribute::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IAttribute::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IAttribute::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IAttribute::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IAttribute::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAttribute::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// I2DPolyline properties

LPDISPATCH I2DPolyline::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I2DPolyline::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I2DPolyline::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DPolyline::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short I2DPolyline::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void I2DPolyline::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH I2DPolyline::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DPolyline::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH I2DPolyline::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DPolyline::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double I2DPolyline::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void I2DPolyline::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL I2DPolyline::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void I2DPolyline::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH I2DPolyline::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DPolyline::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString I2DPolyline::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short I2DPolyline::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString I2DPolyline::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL I2DPolyline::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH I2DPolyline::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL I2DPolyline::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void I2DPolyline::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString I2DPolyline::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH I2DPolyline::GetVertices()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL I2DPolyline::GetClosed()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void I2DPolyline::SetClosed(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

short I2DPolyline::GetCurve()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void I2DPolyline::SetCurve(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

double I2DPolyline::GetEndWidth()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void I2DPolyline::SetEndWidth(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double I2DPolyline::GetStartWidth()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void I2DPolyline::SetStartWidth(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

double I2DPolyline::GetLength()
{
    double result;
    GetProperty(0x6, VT_R8, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// I2DPolyline operations

void I2DPolyline::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH I2DPolyline::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void I2DPolyline::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I2DPolyline::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I2DPolyline::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void I2DPolyline::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH I2DPolyline::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void I2DPolyline::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I2DPolyline::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH I2DPolyline::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH I2DPolyline::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH I2DPolyline::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void I2DPolyline::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I2DPolyline::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I2DPolyline::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I2DPolyline::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL I2DPolyline::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I2DPolyline::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I2DPolyline::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void I2DPolyline::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DPolyline::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL I2DPolyline::Explode()
{
    BOOL result;
    InvokeHelper(0x10001, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

short I2DPolyline::Fillet()
{
    short result;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
    return result;
}

short I2DPolyline::Chamfer()
{
    short result;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// I3DPolyline properties

LPDISPATCH I3DPolyline::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I3DPolyline::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I3DPolyline::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void I3DPolyline::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short I3DPolyline::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void I3DPolyline::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH I3DPolyline::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void I3DPolyline::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH I3DPolyline::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void I3DPolyline::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double I3DPolyline::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void I3DPolyline::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL I3DPolyline::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void I3DPolyline::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH I3DPolyline::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void I3DPolyline::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString I3DPolyline::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short I3DPolyline::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString I3DPolyline::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL I3DPolyline::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH I3DPolyline::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL I3DPolyline::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void I3DPolyline::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString I3DPolyline::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH I3DPolyline::GetVertices()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL I3DPolyline::GetClosed()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void I3DPolyline::SetClosed(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

short I3DPolyline::GetCurve()
{
    short result;
    GetProperty(0x3, VT_I2, (void*)&result);
    return result;
}

void I3DPolyline::SetCurve(short propVal)
{
    SetProperty(0x3, VT_I2, propVal);
}

double I3DPolyline::GetLength()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// I3DPolyline operations

void I3DPolyline::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH I3DPolyline::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void I3DPolyline::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I3DPolyline::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I3DPolyline::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void I3DPolyline::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH I3DPolyline::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void I3DPolyline::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I3DPolyline::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH I3DPolyline::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH I3DPolyline::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH I3DPolyline::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void I3DPolyline::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I3DPolyline::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I3DPolyline::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I3DPolyline::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL I3DPolyline::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I3DPolyline::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I3DPolyline::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void I3DPolyline::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I3DPolyline::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL I3DPolyline::Explode()
{
    BOOL result;
    InvokeHelper(0x10001, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPolymesh properties

LPDISPATCH IPolymesh::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPolymesh::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPolymesh::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolymesh::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IPolymesh::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IPolymesh::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IPolymesh::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolymesh::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IPolymesh::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolymesh::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IPolymesh::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IPolymesh::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IPolymesh::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IPolymesh::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IPolymesh::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolymesh::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IPolymesh::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IPolymesh::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IPolymesh::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IPolymesh::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IPolymesh::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IPolymesh::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IPolymesh::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IPolymesh::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IPolymesh::GetVertices()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IPolymesh::GetColumnClosed()
{
    BOOL result;
    GetProperty(0x2, VT_BOOL, (void*)&result);
    return result;
}

void IPolymesh::SetColumnClosed(BOOL propVal)
{
    SetProperty(0x2, VT_BOOL, propVal);
}

BOOL IPolymesh::GetRowClosed()
{
    BOOL result;
    GetProperty(0x3, VT_BOOL, (void*)&result);
    return result;
}

void IPolymesh::SetRowClosed(BOOL propVal)
{
    SetProperty(0x3, VT_BOOL, propVal);
}

short IPolymesh::GetColumnSize()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

short IPolymesh::GetRowSize()
{
    short result;
    GetProperty(0x5, VT_I2, (void*)&result);
    return result;
}

short IPolymesh::GetColumnCurve()
{
    short result;
    GetProperty(0x6, VT_I2, (void*)&result);
    return result;
}

short IPolymesh::GetRowCurve()
{
    short result;
    GetProperty(0x7, VT_I2, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IPolymesh operations

void IPolymesh::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IPolymesh::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IPolymesh::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPolymesh::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPolymesh::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IPolymesh::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IPolymesh::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IPolymesh::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPolymesh::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IPolymesh::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IPolymesh::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IPolymesh::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IPolymesh::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPolymesh::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolymesh::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPolymesh::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPolymesh::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IPolymesh::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPolymesh::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPolymesh::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IPolymesh::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolymesh::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPolymesh::Explode()
{
    BOOL result;
    InvokeHelper(0x10001, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPolyface properties

LPDISPATCH IPolyface::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPolyface::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPolyface::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolyface::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IPolyface::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IPolyface::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IPolyface::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolyface::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IPolyface::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolyface::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IPolyface::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IPolyface::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IPolyface::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IPolyface::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IPolyface::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IPolyface::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IPolyface::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IPolyface::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IPolyface::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IPolyface::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IPolyface::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IPolyface::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IPolyface::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IPolyface::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IPolyface::GetVertices()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IPolyface::GetFaceVertices()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IPolyface operations

void IPolyface::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IPolyface::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IPolyface::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPolyface::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IPolyface::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IPolyface::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IPolyface::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IPolyface::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPolyface::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IPolyface::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IPolyface::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IPolyface::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IPolyface::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IPolyface::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IPolyface::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPolyface::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IPolyface::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IPolyface::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPolyface::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IPolyface::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IPolyface::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IPolyface::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPolyface::Explode()
{
    BOOL result;
    InvokeHelper(0x10001, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// I2DVertices properties

LPDISPATCH I2DVertices::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I2DVertices::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long I2DVertices::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// I2DVertices operations

LPDISPATCH I2DVertices::GetItem(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH I2DVertices::Get_Item(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IVertices properties

LPDISPATCH IVertices::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVertices::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IVertices::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IVertices operations

LPDISPATCH IVertices::GetItem(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH IVertices::Get_Item(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IFaceVertices properties

LPDISPATCH IFaceVertices::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x20001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IFaceVertices::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x20002, VT_DISPATCH, (void*)&result);
    return result;
}

long IFaceVertices::GetCount()
{
    long result;
    GetProperty(0x10001, VT_I4, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IFaceVertices operations

LPDISPATCH IFaceVertices::GetItem(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x10002, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}

LPDISPATCH IFaceVertices::Get_Item(long index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
        index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// I2DVertex properties

LPDISPATCH I2DVertex::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I2DVertex::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH I2DVertex::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DVertex::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short I2DVertex::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void I2DVertex::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH I2DVertex::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DVertex::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH I2DVertex::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DVertex::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double I2DVertex::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void I2DVertex::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL I2DVertex::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void I2DVertex::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH I2DVertex::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DVertex::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString I2DVertex::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short I2DVertex::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString I2DVertex::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL I2DVertex::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH I2DVertex::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL I2DVertex::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void I2DVertex::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString I2DVertex::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH I2DVertex::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void I2DVertex::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double I2DVertex::GetEndWidth()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void I2DVertex::SetEndWidth(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double I2DVertex::GetStartWidth()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void I2DVertex::SetStartWidth(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

double I2DVertex::GetBulge()
{
    double result;
    GetProperty(0x4, VT_R8, (void*)&result);
    return result;
}

void I2DVertex::SetBulge(double propVal)
{
    SetProperty(0x4, VT_R8, propVal);
}

double I2DVertex::GetTangent()
{
    double result;
    GetProperty(0x5, VT_R8, (void*)&result);
    return result;
}

void I2DVertex::SetTangent(double propVal)
{
    SetProperty(0x5, VT_R8, propVal);
}

BOOL I2DVertex::GetControlPoint()
{
    BOOL result;
    GetProperty(0x6, VT_BOOL, (void*)&result);
    return result;
}

BOOL I2DVertex::GetCurveFit()
{
    BOOL result;
    GetProperty(0x7, VT_BOOL, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// I2DVertex operations

void I2DVertex::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH I2DVertex::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void I2DVertex::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I2DVertex::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void I2DVertex::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void I2DVertex::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH I2DVertex::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void I2DVertex::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I2DVertex::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH I2DVertex::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH I2DVertex::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH I2DVertex::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void I2DVertex::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH I2DVertex::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH I2DVertex::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I2DVertex::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH I2DVertex::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL I2DVertex::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I2DVertex::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL I2DVertex::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void I2DVertex::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void I2DVertex::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IVertex properties

LPDISPATCH IVertex::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVertex::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IVertex::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IVertex::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IVertex::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IVertex::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IVertex::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IVertex::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IVertex::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IVertex::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IVertex::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IVertex::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IVertex::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IVertex::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IVertex::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IVertex::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IVertex::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IVertex::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IVertex::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IVertex::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IVertex::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IVertex::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IVertex::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IVertex::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IVertex::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IVertex::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IVertex operations

void IVertex::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IVertex::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IVertex::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IVertex::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IVertex::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IVertex::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IVertex::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IVertex::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IVertex::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IVertex::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IVertex::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IVertex::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IVertex::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IVertex::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IVertex::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IVertex::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IVertex::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IVertex::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IVertex::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IVertex::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IVertex::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IVertex::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IFaceVertex properties

LPDISPATCH IFaceVertex::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IFaceVertex::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IFaceVertex::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IFaceVertex::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IFaceVertex::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IFaceVertex::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IFaceVertex::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IFaceVertex::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IFaceVertex::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IFaceVertex::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IFaceVertex::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IFaceVertex::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IFaceVertex::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IFaceVertex::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IFaceVertex::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IFaceVertex::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IFaceVertex::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IFaceVertex::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IFaceVertex::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IFaceVertex::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IFaceVertex::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IFaceVertex::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IFaceVertex::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IFaceVertex::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IFaceVertex operations

void IFaceVertex::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IFaceVertex::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IFaceVertex::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IFaceVertex::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IFaceVertex::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IFaceVertex::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IFaceVertex::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IFaceVertex::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IFaceVertex::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IFaceVertex::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IFaceVertex::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IFaceVertex::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IFaceVertex::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IFaceVertex::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IFaceVertex::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IFaceVertex::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IFaceVertex::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IFaceVertex::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IFaceVertex::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IFaceVertex::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IFaceVertex::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

short IFaceVertex::GetCorner(short which)
{
    short result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, parms,
        which);
    return result;
}

void IFaceVertex::SetCorner(short which, short nNewValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_I2;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         which, nNewValue);
}

BOOL IFaceVertex::GetVisible(short which)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
        which);
    return result;
}

void IFaceVertex::SetVisible(short which, BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         which, bNewValue);
}

void IFaceVertex::SetCorners(short val1, short val2, short val3, short val4)
{
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_I2;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         val1, val2, val3, val4);
}

void IFaceVertex::SetVisibility(BOOL flag1, BOOL flag2, BOOL flag3, BOOL flag4)
{
    static BYTE parms[] =
        VTS_BOOL VTS_BOOL VTS_BOOL VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         flag1, flag2, flag3, flag4);
}


/////////////////////////////////////////////////////////////////////////////
// IDimension properties

LPDISPATCH IDimension::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimension::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimension::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IDimension::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IDimension::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IDimension::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IDimension::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IDimension::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IDimension::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IDimension::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IDimension::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IDimension::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IDimension::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDimension::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDimension::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDimension::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IDimension::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IDimension::GetAngle()
{
    double result;
    GetProperty(0x10001, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetAngle(double propVal)
{
    SetProperty(0x10001, VT_R8, propVal);
}

LPDISPATCH IDimension::GetDxf10()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf10(LPDISPATCH propVal)
{
    SetProperty(0x10002, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf11()
{
    LPDISPATCH result;
    GetProperty(0x10003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf11(LPDISPATCH propVal)
{
    SetProperty(0x10003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf12()
{
    LPDISPATCH result;
    GetProperty(0x10004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf12(LPDISPATCH propVal)
{
    SetProperty(0x10004, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf13()
{
    LPDISPATCH result;
    GetProperty(0x10005, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf13(LPDISPATCH propVal)
{
    SetProperty(0x10005, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf14()
{
    LPDISPATCH result;
    GetProperty(0x10006, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf14(LPDISPATCH propVal)
{
    SetProperty(0x10006, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf15()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf15(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IDimension::GetDxf16()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetDxf16(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

double IDimension::GetHorizontalAngle()
{
    double result;
    GetProperty(0x10009, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetHorizontalAngle(double propVal)
{
    SetProperty(0x10009, VT_R8, propVal);
}

double IDimension::GetLeaderLength()
{
    double result;
    GetProperty(0x1000a, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetLeaderLength(double propVal)
{
    SetProperty(0x1000a, VT_R8, propVal);
}

double IDimension::GetObliqueAngle()
{
    double result;
    GetProperty(0x1000b, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetObliqueAngle(double propVal)
{
    SetProperty(0x1000b, VT_R8, propVal);
}

LPDISPATCH IDimension::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000c, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimension::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000c, VT_DISPATCH, propVal);
}

CString IDimension::GetString()
{
    CString result;
    GetProperty(0x1000d, VT_BSTR, (void*)&result);
    return result;
}

void IDimension::SetString(LPCTSTR propVal)
{
    SetProperty(0x1000d, VT_BSTR, propVal);
}

double IDimension::GetTextAngle()
{
    double result;
    GetProperty(0x1000e, VT_R8, (void*)&result);
    return result;
}

void IDimension::SetTextAngle(double propVal)
{
    SetProperty(0x1000e, VT_R8, propVal);
}

BOOL IDimension::GetTextHomePosition()
{
    BOOL result;
    GetProperty(0x1000f, VT_BOOL, (void*)&result);
    return result;
}

void IDimension::SetTextHomePosition(BOOL propVal)
{
    SetProperty(0x1000f, VT_BOOL, propVal);
}

CString IDimension::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

/////////////////////////////////////////////////////////////////////////////
// IDimension operations

void IDimension::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IDimension::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IDimension::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimension::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimension::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IDimension::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IDimension::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IDimension::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimension::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IDimension::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IDimension::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IDimension::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IDimension::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimension::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimension::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimension::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimension::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IDimension::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimension::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimension::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IDimension::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimension::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimension::Explode()
{
    BOOL result;
    InvokeHelper(0x10010, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimHorizontal properties

LPDISPATCH IDimHorizontal::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimHorizontal::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimHorizontal::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IDimHorizontal::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IDimHorizontal::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IDimHorizontal::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IDimHorizontal::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IDimHorizontal::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IDimHorizontal::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IDimHorizontal::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IDimHorizontal::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IDimHorizontal::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IDimHorizontal::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDimHorizontal::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDimHorizontal::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDimHorizontal::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IDimHorizontal::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IDimHorizontal::GetAngle()
{
    double result;
    GetProperty(0x10001, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetAngle(double propVal)
{
    SetProperty(0x10001, VT_R8, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf10()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf10(LPDISPATCH propVal)
{
    SetProperty(0x10002, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf11()
{
    LPDISPATCH result;
    GetProperty(0x10003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf11(LPDISPATCH propVal)
{
    SetProperty(0x10003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf12()
{
    LPDISPATCH result;
    GetProperty(0x10004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf12(LPDISPATCH propVal)
{
    SetProperty(0x10004, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf13()
{
    LPDISPATCH result;
    GetProperty(0x10005, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf13(LPDISPATCH propVal)
{
    SetProperty(0x10005, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf14()
{
    LPDISPATCH result;
    GetProperty(0x10006, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf14(LPDISPATCH propVal)
{
    SetProperty(0x10006, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf15()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf15(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDxf16()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDxf16(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

double IDimHorizontal::GetHorizontalAngle()
{
    double result;
    GetProperty(0x10009, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetHorizontalAngle(double propVal)
{
    SetProperty(0x10009, VT_R8, propVal);
}

double IDimHorizontal::GetLeaderLength()
{
    double result;
    GetProperty(0x1000a, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetLeaderLength(double propVal)
{
    SetProperty(0x1000a, VT_R8, propVal);
}

double IDimHorizontal::GetObliqueAngle()
{
    double result;
    GetProperty(0x1000b, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetObliqueAngle(double propVal)
{
    SetProperty(0x1000b, VT_R8, propVal);
}

LPDISPATCH IDimHorizontal::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000c, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000c, VT_DISPATCH, propVal);
}

CString IDimHorizontal::GetString()
{
    CString result;
    GetProperty(0x1000d, VT_BSTR, (void*)&result);
    return result;
}

void IDimHorizontal::SetString(LPCTSTR propVal)
{
    SetProperty(0x1000d, VT_BSTR, propVal);
}

double IDimHorizontal::GetTextAngle()
{
    double result;
    GetProperty(0x1000e, VT_R8, (void*)&result);
    return result;
}

void IDimHorizontal::SetTextAngle(double propVal)
{
    SetProperty(0x1000e, VT_R8, propVal);
}

BOOL IDimHorizontal::GetTextHomePosition()
{
    BOOL result;
    GetProperty(0x1000f, VT_BOOL, (void*)&result);
    return result;
}

void IDimHorizontal::SetTextHomePosition(BOOL propVal)
{
    SetProperty(0x1000f, VT_BOOL, propVal);
}

CString IDimHorizontal::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IDimHorizontal::GetTextPosition()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetTextPosition(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetTranslationVector()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetTranslationVector(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetDimensionLine()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetDimensionLine(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetFirstExtension()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetFirstExtension(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH IDimHorizontal::GetSecondExtension()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimHorizontal::SetSecondExtension(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimHorizontal operations

void IDimHorizontal::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IDimHorizontal::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IDimHorizontal::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimHorizontal::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimHorizontal::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IDimHorizontal::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IDimHorizontal::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IDimHorizontal::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimHorizontal::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IDimHorizontal::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IDimHorizontal::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IDimHorizontal::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IDimHorizontal::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimHorizontal::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimHorizontal::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimHorizontal::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IDimHorizontal::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimHorizontal::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimHorizontal::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IDimHorizontal::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimHorizontal::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimHorizontal::Explode()
{
    BOOL result;
    InvokeHelper(0x10010, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimVertical properties

LPDISPATCH IDimVertical::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimVertical::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimVertical::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IDimVertical::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IDimVertical::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IDimVertical::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IDimVertical::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IDimVertical::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IDimVertical::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IDimVertical::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IDimVertical::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IDimVertical::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IDimVertical::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDimVertical::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDimVertical::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDimVertical::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IDimVertical::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IDimVertical::GetAngle()
{
    double result;
    GetProperty(0x10001, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetAngle(double propVal)
{
    SetProperty(0x10001, VT_R8, propVal);
}

LPDISPATCH IDimVertical::GetDxf10()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf10(LPDISPATCH propVal)
{
    SetProperty(0x10002, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf11()
{
    LPDISPATCH result;
    GetProperty(0x10003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf11(LPDISPATCH propVal)
{
    SetProperty(0x10003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf12()
{
    LPDISPATCH result;
    GetProperty(0x10004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf12(LPDISPATCH propVal)
{
    SetProperty(0x10004, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf13()
{
    LPDISPATCH result;
    GetProperty(0x10005, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf13(LPDISPATCH propVal)
{
    SetProperty(0x10005, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf14()
{
    LPDISPATCH result;
    GetProperty(0x10006, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf14(LPDISPATCH propVal)
{
    SetProperty(0x10006, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf15()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf15(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDxf16()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDxf16(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

double IDimVertical::GetHorizontalAngle()
{
    double result;
    GetProperty(0x10009, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetHorizontalAngle(double propVal)
{
    SetProperty(0x10009, VT_R8, propVal);
}

double IDimVertical::GetLeaderLength()
{
    double result;
    GetProperty(0x1000a, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetLeaderLength(double propVal)
{
    SetProperty(0x1000a, VT_R8, propVal);
}

double IDimVertical::GetObliqueAngle()
{
    double result;
    GetProperty(0x1000b, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetObliqueAngle(double propVal)
{
    SetProperty(0x1000b, VT_R8, propVal);
}

LPDISPATCH IDimVertical::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000c, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000c, VT_DISPATCH, propVal);
}

CString IDimVertical::GetString()
{
    CString result;
    GetProperty(0x1000d, VT_BSTR, (void*)&result);
    return result;
}

void IDimVertical::SetString(LPCTSTR propVal)
{
    SetProperty(0x1000d, VT_BSTR, propVal);
}

double IDimVertical::GetTextAngle()
{
    double result;
    GetProperty(0x1000e, VT_R8, (void*)&result);
    return result;
}

void IDimVertical::SetTextAngle(double propVal)
{
    SetProperty(0x1000e, VT_R8, propVal);
}

BOOL IDimVertical::GetTextHomePosition()
{
    BOOL result;
    GetProperty(0x1000f, VT_BOOL, (void*)&result);
    return result;
}

void IDimVertical::SetTextHomePosition(BOOL propVal)
{
    SetProperty(0x1000f, VT_BOOL, propVal);
}

CString IDimVertical::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IDimVertical::GetTextPosition()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetTextPosition(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetTranslationVector()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetTranslationVector(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetDimensionLine()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetDimensionLine(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetFirstExtension()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetFirstExtension(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH IDimVertical::GetSecondExtension()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimVertical::SetSecondExtension(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimVertical operations

void IDimVertical::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IDimVertical::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IDimVertical::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimVertical::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimVertical::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IDimVertical::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IDimVertical::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IDimVertical::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimVertical::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IDimVertical::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IDimVertical::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IDimVertical::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IDimVertical::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimVertical::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimVertical::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimVertical::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimVertical::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IDimVertical::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimVertical::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimVertical::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IDimVertical::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimVertical::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimVertical::Explode()
{
    BOOL result;
    InvokeHelper(0x10010, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimAligned properties

LPDISPATCH IDimAligned::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimAligned::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimAligned::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IDimAligned::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IDimAligned::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IDimAligned::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IDimAligned::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IDimAligned::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IDimAligned::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IDimAligned::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IDimAligned::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IDimAligned::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IDimAligned::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDimAligned::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDimAligned::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDimAligned::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IDimAligned::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IDimAligned::GetAngle()
{
    double result;
    GetProperty(0x10001, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetAngle(double propVal)
{
    SetProperty(0x10001, VT_R8, propVal);
}

LPDISPATCH IDimAligned::GetDxf10()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf10(LPDISPATCH propVal)
{
    SetProperty(0x10002, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf11()
{
    LPDISPATCH result;
    GetProperty(0x10003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf11(LPDISPATCH propVal)
{
    SetProperty(0x10003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf12()
{
    LPDISPATCH result;
    GetProperty(0x10004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf12(LPDISPATCH propVal)
{
    SetProperty(0x10004, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf13()
{
    LPDISPATCH result;
    GetProperty(0x10005, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf13(LPDISPATCH propVal)
{
    SetProperty(0x10005, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf14()
{
    LPDISPATCH result;
    GetProperty(0x10006, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf14(LPDISPATCH propVal)
{
    SetProperty(0x10006, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf15()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf15(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDxf16()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDxf16(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

double IDimAligned::GetHorizontalAngle()
{
    double result;
    GetProperty(0x10009, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetHorizontalAngle(double propVal)
{
    SetProperty(0x10009, VT_R8, propVal);
}

double IDimAligned::GetLeaderLength()
{
    double result;
    GetProperty(0x1000a, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetLeaderLength(double propVal)
{
    SetProperty(0x1000a, VT_R8, propVal);
}

double IDimAligned::GetObliqueAngle()
{
    double result;
    GetProperty(0x1000b, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetObliqueAngle(double propVal)
{
    SetProperty(0x1000b, VT_R8, propVal);
}

LPDISPATCH IDimAligned::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000c, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000c, VT_DISPATCH, propVal);
}

CString IDimAligned::GetString()
{
    CString result;
    GetProperty(0x1000d, VT_BSTR, (void*)&result);
    return result;
}

void IDimAligned::SetString(LPCTSTR propVal)
{
    SetProperty(0x1000d, VT_BSTR, propVal);
}

double IDimAligned::GetTextAngle()
{
    double result;
    GetProperty(0x1000e, VT_R8, (void*)&result);
    return result;
}

void IDimAligned::SetTextAngle(double propVal)
{
    SetProperty(0x1000e, VT_R8, propVal);
}

BOOL IDimAligned::GetTextHomePosition()
{
    BOOL result;
    GetProperty(0x1000f, VT_BOOL, (void*)&result);
    return result;
}

void IDimAligned::SetTextHomePosition(BOOL propVal)
{
    SetProperty(0x1000f, VT_BOOL, propVal);
}

CString IDimAligned::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IDimAligned::GetTextPosition()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetTextPosition(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetTranslationVector()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetTranslationVector(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetDimensionLine()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetDimensionLine(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetFirstExtension()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetFirstExtension(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH IDimAligned::GetSecondExtension()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimAligned::SetSecondExtension(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimAligned operations

void IDimAligned::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IDimAligned::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IDimAligned::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimAligned::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimAligned::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IDimAligned::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IDimAligned::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IDimAligned::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimAligned::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IDimAligned::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IDimAligned::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IDimAligned::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IDimAligned::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimAligned::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimAligned::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimAligned::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimAligned::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IDimAligned::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimAligned::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimAligned::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IDimAligned::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimAligned::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimAligned::Explode()
{
    BOOL result;
    InvokeHelper(0x10010, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimRotated properties

LPDISPATCH IDimRotated::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimRotated::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IDimRotated::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IDimRotated::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IDimRotated::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IDimRotated::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IDimRotated::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IDimRotated::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IDimRotated::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IDimRotated::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IDimRotated::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IDimRotated::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IDimRotated::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IDimRotated::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IDimRotated::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IDimRotated::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IDimRotated::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

double IDimRotated::GetAngle()
{
    double result;
    GetProperty(0x10001, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetAngle(double propVal)
{
    SetProperty(0x10001, VT_R8, propVal);
}

LPDISPATCH IDimRotated::GetDxf10()
{
    LPDISPATCH result;
    GetProperty(0x10002, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf10(LPDISPATCH propVal)
{
    SetProperty(0x10002, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf11()
{
    LPDISPATCH result;
    GetProperty(0x10003, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf11(LPDISPATCH propVal)
{
    SetProperty(0x10003, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf12()
{
    LPDISPATCH result;
    GetProperty(0x10004, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf12(LPDISPATCH propVal)
{
    SetProperty(0x10004, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf13()
{
    LPDISPATCH result;
    GetProperty(0x10005, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf13(LPDISPATCH propVal)
{
    SetProperty(0x10005, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf14()
{
    LPDISPATCH result;
    GetProperty(0x10006, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf14(LPDISPATCH propVal)
{
    SetProperty(0x10006, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf15()
{
    LPDISPATCH result;
    GetProperty(0x10007, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf15(LPDISPATCH propVal)
{
    SetProperty(0x10007, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDxf16()
{
    LPDISPATCH result;
    GetProperty(0x10008, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDxf16(LPDISPATCH propVal)
{
    SetProperty(0x10008, VT_DISPATCH, propVal);
}

double IDimRotated::GetHorizontalAngle()
{
    double result;
    GetProperty(0x10009, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetHorizontalAngle(double propVal)
{
    SetProperty(0x10009, VT_R8, propVal);
}

double IDimRotated::GetLeaderLength()
{
    double result;
    GetProperty(0x1000a, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetLeaderLength(double propVal)
{
    SetProperty(0x1000a, VT_R8, propVal);
}

double IDimRotated::GetObliqueAngle()
{
    double result;
    GetProperty(0x1000b, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetObliqueAngle(double propVal)
{
    SetProperty(0x1000b, VT_R8, propVal);
}

LPDISPATCH IDimRotated::GetStyle()
{
    LPDISPATCH result;
    GetProperty(0x1000c, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetStyle(LPDISPATCH propVal)
{
    SetProperty(0x1000c, VT_DISPATCH, propVal);
}

CString IDimRotated::GetString()
{
    CString result;
    GetProperty(0x1000d, VT_BSTR, (void*)&result);
    return result;
}

void IDimRotated::SetString(LPCTSTR propVal)
{
    SetProperty(0x1000d, VT_BSTR, propVal);
}

double IDimRotated::GetTextAngle()
{
    double result;
    GetProperty(0x1000e, VT_R8, (void*)&result);
    return result;
}

void IDimRotated::SetTextAngle(double propVal)
{
    SetProperty(0x1000e, VT_R8, propVal);
}

BOOL IDimRotated::GetTextHomePosition()
{
    BOOL result;
    GetProperty(0x1000f, VT_BOOL, (void*)&result);
    return result;
}

void IDimRotated::SetTextHomePosition(BOOL propVal)
{
    SetProperty(0x1000f, VT_BOOL, propVal);
}

CString IDimRotated::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IDimRotated::GetTextPosition()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetTextPosition(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetTranslationVector()
{
    LPDISPATCH result;
    GetProperty(0x2, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetTranslationVector(LPDISPATCH propVal)
{
    SetProperty(0x2, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetDimensionLine()
{
    LPDISPATCH result;
    GetProperty(0x3, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetDimensionLine(LPDISPATCH propVal)
{
    SetProperty(0x3, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetFirstExtension()
{
    LPDISPATCH result;
    GetProperty(0x4, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetFirstExtension(LPDISPATCH propVal)
{
    SetProperty(0x4, VT_DISPATCH, propVal);
}

LPDISPATCH IDimRotated::GetSecondExtension()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IDimRotated::SetSecondExtension(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IDimRotated operations

void IDimRotated::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IDimRotated::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IDimRotated::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimRotated::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IDimRotated::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IDimRotated::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IDimRotated::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IDimRotated::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimRotated::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IDimRotated::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IDimRotated::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IDimRotated::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IDimRotated::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IDimRotated::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IDimRotated::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimRotated::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IDimRotated::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IDimRotated::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimRotated::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IDimRotated::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IDimRotated::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IDimRotated::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimRotated::Explode()
{
    BOOL result;
    InvokeHelper(0x10010, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IViewport properties

LPDISPATCH IViewport::GetApplication()
{
    LPDISPATCH result;
    GetProperty(0x40001, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViewport::GetParent()
{
    LPDISPATCH result;
    GetProperty(0x40002, VT_DISPATCH, (void*)&result);
    return result;
}

LPDISPATCH IViewport::GetColor()
{
    LPDISPATCH result;
    GetProperty(0x30001, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetColor(LPDISPATCH propVal)
{
    SetProperty(0x30001, VT_DISPATCH, propVal);
}

short IViewport::GetColorNumber()
{
    short result;
    GetProperty(0x30002, VT_I2, (void*)&result);
    return result;
}

void IViewport::SetColorNumber(short propVal)
{
    SetProperty(0x30002, VT_I2, propVal);
}

LPDISPATCH IViewport::GetLayer()
{
    LPDISPATCH result;
    GetProperty(0x30003, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetLayer(LPDISPATCH propVal)
{
    SetProperty(0x30003, VT_DISPATCH, propVal);
}

LPDISPATCH IViewport::GetLinetype()
{
    LPDISPATCH result;
    GetProperty(0x30004, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetLinetype(LPDISPATCH propVal)
{
    SetProperty(0x30004, VT_DISPATCH, propVal);
}

double IViewport::GetThickness()
{
    double result;
    GetProperty(0x30005, VT_R8, (void*)&result);
    return result;
}

void IViewport::SetThickness(double propVal)
{
    SetProperty(0x30005, VT_R8, propVal);
}

BOOL IViewport::GetPaperSpace()
{
    BOOL result;
    GetProperty(0x30006, VT_BOOL, (void*)&result);
    return result;
}

void IViewport::SetPaperSpace(BOOL propVal)
{
    SetProperty(0x30006, VT_BOOL, propVal);
}

LPDISPATCH IViewport::GetNormal()
{
    LPDISPATCH result;
    GetProperty(0x30007, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetNormal(LPDISPATCH propVal)
{
    SetProperty(0x30007, VT_DISPATCH, propVal);
}

CString IViewport::GetName()
{
    CString result;
    GetProperty(0x20001, VT_BSTR, (void*)&result);
    return result;
}

short IViewport::GetType()
{
    short result;
    GetProperty(0x20002, VT_I2, (void*)&result);
    return result;
}

CString IViewport::GetHandle()
{
    CString result;
    GetProperty(0x20003, VT_BSTR, (void*)&result);
    return result;
}

BOOL IViewport::GetHasXData()
{
    BOOL result;
    GetProperty(0x20004, VT_BOOL, (void*)&result);
    return result;
}

LPDISPATCH IViewport::GetXData()
{
    LPDISPATCH result;
    GetProperty(0x20005, VT_DISPATCH, (void*)&result);
    return result;
}

BOOL IViewport::GetAutoDraw()
{
    BOOL result;
    GetProperty(0x20015, VT_BOOL, (void*)&result);
    return result;
}

void IViewport::SetAutoDraw(BOOL propVal)
{
    SetProperty(0x20015, VT_BOOL, propVal);
}

CString IViewport::Get_Name()
{
    CString result;
    GetProperty(0x0, VT_BSTR, (void*)&result);
    return result;
}

LPDISPATCH IViewport::GetWhere()
{
    LPDISPATCH result;
    GetProperty(0x1, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetWhere(LPDISPATCH propVal)
{
    SetProperty(0x1, VT_DISPATCH, propVal);
}

double IViewport::GetWidth()
{
    double result;
    GetProperty(0x2, VT_R8, (void*)&result);
    return result;
}

void IViewport::SetWidth(double propVal)
{
    SetProperty(0x2, VT_R8, propVal);
}

double IViewport::GetHeight()
{
    double result;
    GetProperty(0x3, VT_R8, (void*)&result);
    return result;
}

void IViewport::SetHeight(double propVal)
{
    SetProperty(0x3, VT_R8, propVal);
}

short IViewport::GetStatus()
{
    short result;
    GetProperty(0x4, VT_I2, (void*)&result);
    return result;
}

void IViewport::SetStatus(short propVal)
{
    SetProperty(0x4, VT_I2, propVal);
}

LPDISPATCH IViewport::GetCenter()
{
    LPDISPATCH result;
    GetProperty(0x5, VT_DISPATCH, (void*)&result);
    return result;
}

void IViewport::SetCenter(LPDISPATCH propVal)
{
    SetProperty(0x5, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// IViewport operations

void IViewport::Redraw()
{
    InvokeHelper(0x30008, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::Regen()
{
    InvokeHelper(0x30009, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::Erase()
{
    InvokeHelper(0x3000a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::Delete()
{
    InvokeHelper(0x3000b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::Move(LPDISPATCH offset)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         offset);
}

LPDISPATCH IViewport::Copy(LPDISPATCH offset)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        offset);
    return result;
}

void IViewport::scale(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IViewport::ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x3000f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, scale);
}

void IViewport::Rotate(LPDISPATCH basepoint, double Angle)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_R8;
    InvokeHelper(0x30010, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         basepoint, Angle);
}

void IViewport::Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30011, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         point1, point2, &MirrorText);
}

LPDISPATCH IViewport::MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30012, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        point1, point2, &MirrorText);
    return result;
}

void IViewport::Dialog()
{
    InvokeHelper(0x30013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IViewport::Offset(LPDISPATCH vec, const VARIANT& Distance)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30014, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        vec, &Distance);
    return result;
}

LPDISPATCH IViewport::Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30015, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, rowspacing, colspacing, Rotation);
    return result;
}

LPDISPATCH IViewport::Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_I2 VTS_R8 VTS_R8 VTS_R8 VTS_R8;
    InvokeHelper(0x30016, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numrows, numcols, numlevels, rowspacing, colspacing, levelspacing, Rotation);
    return result;
}

LPDISPATCH IViewport::PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2 VTS_R8 VTS_R8 VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x30017, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numitems, fillangle, angletween, Center, &refpoint);
    return result;
}

void IViewport::DisplayGrips()
{
    InvokeHelper(0x30018, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::EraseGrips()
{
    InvokeHelper(0x30019, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

LPDISPATCH IViewport::Snap2Endpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20006, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Midpoint(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20007, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Center(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20008, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Nearest(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20009, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Point(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Quadrant(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Insertion(LPDISPATCH closeto)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2000c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto);
    return result;
}

LPDISPATCH IViewport::Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IViewport::Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x2000e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        closeto, prevpoint);
    return result;
}

LPDISPATCH IViewport::Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT VTS_VARIANT;
    InvokeHelper(0x2000f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Entity, &infinite1, &infinite2);
    return result;
}

BOOL IViewport::ExtendToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20010, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IViewport::TrimToSet(LPDISPATCH point)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x20011, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point);
    return result;
}

BOOL IViewport::Break(LPDISPATCH point1, LPDISPATCH point2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x20012, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        point1, point2);
    return result;
}

void IViewport::Update()
{
    InvokeHelper(0x20013, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IViewport::UpdateNow()
{
    InvokeHelper(0x20014, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}