The Houseplan Collection/HRCD2005.ISO/data1.cab/Zusatz/3DS/DATA2.Z/arcon.cpp

C/C++ Source or Header | 1998-06-10 | 241KB | 10,613 lines

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

#include "stdafx.h"
#include "arcon.h"

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



/////////////////////////////////////////////////////////////////////////////
// IArCon properties

/////////////////////////////////////////////////////////////////////////////
// IArCon operations

void IArCon::SetAllFloorsVisible(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IArCon::GetAllFloorsVisible()
{
    BOOL result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

CString IArCon::GetArConDirectory()
{
    CString result;
    InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

BOOL IArCon::GetAutoLoaded()
{
    BOOL result;
    InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableChimneys()
{
    long result;
    InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableDoors()
{
    long result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableGauben()
{
    long result;
    InvokeHelper(0x90, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableStairCases()
{
    long result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableWindows()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableWalls()
{
    long result;
    InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableRoofWindows()
{
    long result;
    InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetAvailableSupports()
{
    long result;
    InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

long IArCon::GetConstructedWindows()
{
    long result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IArCon::GetConstructedRoofWindows()
{
    long result;
    InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IArCon::SetCurrentStory(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

LPDISPATCH IArCon::GetCurrentStory()
{
    LPDISPATCH result;
    InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetCuts()
{
    LPDISPATCH result;
    InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDesignObjectConstructors()
{
    LPDISPATCH result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDesignObjects()
{
    LPDISPATCH result;
    InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDimensions()
{
    LPDISPATCH result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetGlobalTerrain()
{
    LPDISPATCH result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

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

LPDISPATCH IArCon::GetGuides()
{
    LPDISPATCH result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

long IArCon::GetInternalMode()
{
    long result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetLabelings()
{
    LPDISPATCH result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IArCon::SetMode(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IArCon::GetMode()
{
    long result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IArCon::SetMultiUserMode(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IArCon::GetMultiUserMode()
{
    long result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL IArCon::GetRunning()
{
    BOOL result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

long IArCon::GetStartupMenuID()
{
    long result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IArCon::SetState(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IArCon::GetState()
{
    long result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IArCon::AttachDialog(long ArConDlg, long hWnd, long icon, long helpContext, BOOL isActive, BOOL exclusive)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL;
    InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         ArConDlg, hWnd, icon, helpContext, isActive, exclusive);
}

BOOL IArCon::CloseProject()
{
    BOOL result;
    InvokeHelper(0x37, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::CreateBuilding(short initialFloorType)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x32, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        initialFloorType);
    return result;
}

long IArCon::CreateMenuItem(long parentMenu, long beforeId, LPCTSTR Name, LPCTSTR description, long modes, long picture, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4;
    InvokeHelper(0x28, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        parentMenu, beforeId, Name, description, modes, picture, helpId);
    return result;
}

long IArCon::CreateMenuSeparator(long menu, long before, long modes)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4;
    InvokeHelper(0x29, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        menu, before, modes);
    return result;
}

void IArCon::CreateProject(LPDISPATCH aProject)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         aProject);
}

long IArCon::DefButton(const VARIANT& pic, long Info, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_VARIANT VTS_I4 VTS_BSTR VTS_I4;
    InvokeHelper(0x55, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        &pic, Info, str, helpId);
    return result;
}

long IArCon::DefButtonRes(long id, long hInst, long Info, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
    InvokeHelper(0x56, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        id, hInst, Info, str, helpId);
    return result;
}

long IArCon::DefHowButton(long MultiButtonVariantID, const VARIANT& pic, long Info, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT VTS_I4 VTS_BSTR VTS_I4;
    InvokeHelper(0x5a, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        MultiButtonVariantID, &pic, Info, str, helpId);
    return result;
}

long IArCon::DefHowButtonRes(long MultiButtonVariantID, long id, long hInst, long Info, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
    InvokeHelper(0x5b, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        MultiButtonVariantID, id, hInst, Info, str, helpId);
    return result;
}

long IArCon::DefMultiButton(long Info)
{
    long result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x57, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Info);
    return result;
}

long IArCon::DefMultiButtonVariant(long MultiButtonID, const VARIANT& pic, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT VTS_BSTR VTS_I4;
    InvokeHelper(0x58, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        MultiButtonID, &pic, str, helpId);
    return result;
}

long IArCon::DefMultiButtonVariantRes(long MultiButtonID, long id, long hInst, LPCTSTR str, long helpId)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
    InvokeHelper(0x59, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        MultiButtonID, id, hInst, str, helpId);
    return result;
}

BOOL IArCon::DeleteButton(long btnId)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x5e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        btnId);
    return result;
}

CString IArCon::DoorName(long DoorTypeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x43, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        DoorTypeIndex);
    return result;
}

CString IArCon::WallName(long WallType)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x85, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        WallType);
    return result;
}

BOOL IArCon::DragEnd(long x, long y, BOOL canceld)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BOOL;
    InvokeHelper(0x7f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y, canceld);
    return result;
}

void IArCon::DragMove(long x, long y)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x7d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y);
}

void IArCon::DragRButtonPressed(long x, long y, BOOL down)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BOOL;
    InvokeHelper(0x7e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y, down);
}

BOOL IArCon::DragTextureStart(LPCTSTR FileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x7c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        FileName);
    return result;
}

BOOL IArCon::EnableMenuItem(long id, BOOL enable)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BOOL;
    InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        id, enable);
    return result;
}

BOOL IArCon::EndArCon()
{
    BOOL result;
    InvokeHelper(0x25, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IArCon::EndMe()
{
    InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IArCon::EndModalDialog()
{
    BOOL result;
    InvokeHelper(0x53, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IArCon::GetButtonState(long btnId, long* selected, BOOL* pressed, BOOL* visible, BOOL* enabled)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_PI4 VTS_PBOOL VTS_PBOOL VTS_PBOOL;
    InvokeHelper(0x5d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        btnId, selected, pressed, visible, enabled);
    return result;
}

LPDISPATCH IArCon::GetDefaultCeiling()
{
    LPDISPATCH result;
    InvokeHelper(0x6a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDefaultChimney(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x68, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::GetDefaultDimension()
{
    LPDISPATCH result;
    InvokeHelper(0x66, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDefaultDoor(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::GetDefaultGuide()
{
    LPDISPATCH result;
    InvokeHelper(0x67, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDefaultHedge(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::GetDefaultHole()
{
    LPDISPATCH result;
    InvokeHelper(0x6e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDefaultLabeling()
{
    LPDISPATCH result;
    InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::GetDefaultSupport(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x69, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::GetDefaultTerrain(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::GetDefaultUnterUeberzug(BOOL Ueberzug)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x73, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Ueberzug);
    return result;
}

LPDISPATCH IArCon::GetDefaultWall(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x64, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

VARIANT IArCon::GetDialogData(long token, long subObjectNo, long dataId)
{
    VARIANT result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4;
    InvokeHelper(0x5f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
        token, subObjectNo, dataId);
    return result;
}

void IArCon::GetOneClick(LPCTSTR message, const VARIANT& picture, long id)
{
    static BYTE parms[] =
        VTS_BSTR VTS_VARIANT VTS_I4;
    InvokeHelper(0x4d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         message, &picture, id);
}

float IArCon::GetTerrainHeight(float x, float y)
{
    float result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x48, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
        x, y);
    return result;
}

LPDISPATCH IArCon::GroupDesignObjects(LPCTSTR Name, long NumOfObjects, const VARIANT& ObjectArray)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_VARIANT;
    InvokeHelper(0x77, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Name, NumOfObjects, &ObjectArray);
    return result;
}

LPDISPATCH IArCon::ImportFolie(long layer, BSTR* FileName, float* minX, float* minY, float* maxX, float* maxY)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4 VTS_PBSTR VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x78, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer, FileName, minX, minY, maxX, maxY);
    return result;
}

LPDISPATCH IArCon::LoadObjectConstructor(LPCTSTR FileName, long Duration)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4;
    InvokeHelper(0x76, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        FileName, Duration);
    return result;
}

BOOL IArCon::LoadProject(LPCTSTR FileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x35, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        FileName);
    return result;
}

LPDISPATCH IArCon::NewCeiling()
{
    LPDISPATCH result;
    InvokeHelper(0x3e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewCeilingOpening()
{
    LPDISPATCH result;
    InvokeHelper(0x3f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewChimney(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::NewDimension()
{
    LPDISPATCH result;
    InvokeHelper(0x3a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewDoor(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x42, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::NewGuide()
{
    LPDISPATCH result;
    InvokeHelper(0x3b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewHedge(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::newHole()
{
    LPDISPATCH result;
    InvokeHelper(0x63, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewHolePolygon(LPDISPATCH Points)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x7a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Points);
    return result;
}

LPDISPATCH IArCon::NewImage(long layer)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x51, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer);
    return result;
}

LPDISPATCH IArCon::NewLabel(long layer)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer);
    return result;
}

LPDISPATCH IArCon::NewLabeling()
{
    LPDISPATCH result;
    InvokeHelper(0x39, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewLine(long layer)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x50, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer);
    return result;
}

LPDISPATCH IArCon::NewMaterial()
{
    LPDISPATCH result;
    InvokeHelper(0x6f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewObjectConstructor(float epsilon, float sharpAngle)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x70, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        epsilon, sharpAngle);
    return result;
}

LPDISPATCH IArCon::NewObjectTransformerCollection()
{
    LPDISPATCH result;
    InvokeHelper(0x72, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewPoint2DCollection()
{
    LPDISPATCH result;
    InvokeHelper(0x7b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewPolygon2D(long layer)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer);
    return result;
}

LPDISPATCH IArCon::NewProject()
{
    LPDISPATCH result;
    InvokeHelper(0x33, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewRoof()
{
    LPDISPATCH result;
    InvokeHelper(0x45, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewShape(long layer)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        layer);
    return result;
}

LPDISPATCH IArCon::NewStairCase()
{
    LPDISPATCH result;
    InvokeHelper(0x44, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewSupport(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::NewTerrain(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x46, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::NewTexture()
{
    LPDISPATCH result;
    InvokeHelper(0x4c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IArCon::NewTextureCollection(long numElements)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x75, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        numElements);
    return result;
}

LPDISPATCH IArCon::NewUnterUeberzug(BOOL Ueberzug)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x74, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Ueberzug);
    return result;
}

LPDISPATCH IArCon::NewWall(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x38, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

LPDISPATCH IArCon::NewWindow(long Type)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x40, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type);
    return result;
}

BOOL IArCon::PlaceTerrain(LPDISPATCH aTerrain, LPDISPATCH aPolygon)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x47, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aTerrain, aPolygon);
    return result;
}

BOOL IArCon::ReadChunk(long ChunkID, LPCTSTR FileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x62, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        ChunkID, FileName);
    return result;
}

void IArCon::Redraw3DViews()
{
    InvokeHelper(0x71, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IArCon::RemoveAnyMenuItem(long id)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        id);
    return result;
}

BOOL IArCon::RemoveMenuItem(long id)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        id);
    return result;
}

BOOL IArCon::SaveProject(BOOL mayAskForName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x54, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        mayAskForName);
    return result;
}

BOOL IArCon::SaveProjectAs(LPCTSTR FileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x36, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        FileName);
    return result;
}

BOOL IArCon::SetButtonState(long btnId, long selectedIndex, BOOL pressed, BOOL visible, BOOL enabled)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_BOOL;
    InvokeHelper(0x5c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        btnId, selectedIndex, pressed, visible, enabled);
    return result;
}

BOOL IArCon::SetDialogData(long token, long subObjectNo, long dataId, const VARIANT& value)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT;
    InvokeHelper(0x60, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        token, subObjectNo, dataId, &value);
    return result;
}

void IArCon::SetInputMode(long newMode)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         newMode);
}

void IArCon::SetProgressbarSubTitle(LPCTSTR subTitle)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x30, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         subTitle);
}

void IArCon::SetProgressbarValue(long percent)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         percent);
}

void IArCon::SetStatusText(LPCTSTR msg)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         msg);
}

BOOL IArCon::SetTerrainHeight(float x, float y, float Height)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x49, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y, Height);
    return result;
}

BOOL IArCon::ShowAll()
{
    BOOL result;
    InvokeHelper(0x24, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IArCon::StartMe(long hWnd, LPCTSTR helpFileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x27, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        hWnd, helpFileName);
    return result;
}

BOOL IArCon::StartModalDialog(long hWnd)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x52, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        hWnd);
    return result;
}

void IArCon::StartProgressbar(LPCTSTR title, long percent)
{
    static BYTE parms[] =
        VTS_BSTR VTS_I4;
    InvokeHelper(0x2e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         title, percent);
}

void IArCon::StopProgressbar()
{
    InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

CString IArCon::WindowName(long WindowTypeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x41, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        WindowTypeIndex);
    return result;
}

CString IArCon::RoofWindowName(long WindowTypeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8d, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        WindowTypeIndex);
    return result;
}

BOOL IArCon::WriteChunk(long ChunkID, LPCTSTR FileName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x61, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        ChunkID, FileName);
    return result;
}

BOOL IArCon::NotifyOnChange(LPDISPATCH anyObject, long events)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_I4;
    InvokeHelper(0x80, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        anyObject, events);
    return result;
}

CString IArCon::GetStairCaseName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x81, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

CString IArCon::GetRoofWindowName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x82, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

CString IArCon::GetChimneyName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x88, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

CString IArCon::GetSupportName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8a, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

CString IArCon::GetWindowName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8b, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

CString IArCon::GetDoorName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8c, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

LPDISPATCH IArCon::NewRoofConstruction()
{
    LPDISPATCH result;
    InvokeHelper(0x8e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IArCon::ShowWaitCursor(BOOL Hourglass)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Hourglass);
}

CString IArCon::GetGaubenName(long typeIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x91, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        typeIndex);
    return result;
}

void IArCon::GetGaubenConstructionRange(long typeIndex, long* minConturPoints, long* maxConturPoints)
{
    static BYTE parms[] =
        VTS_I4 VTS_PI4 VTS_PI4;
    InvokeHelper(0x92, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         typeIndex, minConturPoints, maxConturPoints);
}


/////////////////////////////////////////////////////////////////////////////
// IBuildingCollection properties

/////////////////////////////////////////////////////////////////////////////
// IBuildingCollection operations

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

LPDISPATCH IBuildingCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IBuilding properties

/////////////////////////////////////////////////////////////////////////////
// IBuilding operations

float IBuilding::GetArea()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long IBuilding::GetId()
{
    long result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IBuilding::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

void IBuilding::SetRemark(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IBuilding::GetRemark()
{
    CString result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IBuilding::SetRotation(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IBuilding::GetRotation()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

float IBuilding::GetVolume()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

LPDISPATCH IBuilding::CreateStory(BOOL aboveCurrent, short floorType)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BOOL VTS_I2;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        aboveCurrent, floorType);
    return result;
}

void IBuilding::Delete()
{
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IBuilding::GetHeight(BOOL addEindeckung, float x, float y, LPDISPATCH* foundRoof, float* foundZ, float* dirX_x, float* dirX_y, float* dirX_z, float* dirY_x, float* dirY_y, float* dirY_z)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BOOL VTS_R4 VTS_R4 VTS_PDISPATCH VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        addEindeckung, x, y, foundRoof, foundZ, dirX_x, dirX_y, dirX_z, dirY_x, dirY_y, dirY_z);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IIDHistory properties

/////////////////////////////////////////////////////////////////////////////
// IIDHistory operations

long IIDHistory::GetCurrentID()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

long IIDHistory::GetPreviousID()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString IIDHistory::GetPreviousProjectName()
{
    CString result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStoryCollection properties

/////////////////////////////////////////////////////////////////////////////
// IStoryCollection operations

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

LPDISPATCH IStoryCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStory properties

/////////////////////////////////////////////////////////////////////////////
// IStory operations

void IStory::SetBaseHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetBaseHeight()
{
    float result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStory::GetBruttoGeschossflaeche()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IStory::GetBruttoGeschossflaechenFormel()
{
    CString result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

float IStory::GetBruttoRauminhalt()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IStory::GetBruttoRauminhaltsFormel()
{
    CString result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

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

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

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

void IStory::SetDistanceStoryBelow(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetDistanceStoryBelow()
{
    float result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStory::SetFussboden(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetFussboden()
{
    float result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

LPDISPATCH IStory::GetGraphics2D()
{
    LPDISPATCH result;
    InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IStory::GetHistory()
{
    LPDISPATCH result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

long IStory::GetId()
{
    long result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IStory::SetLichteHoehe(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetLichteHoehe()
{
    float result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStory::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

void IStory::SetPlasterName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IStory::GetPlasterName()
{
    CString result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IStory::SetPlasterThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetPlasterThickness()
{
    float result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStory::SetRemark(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IStory::GetRemark()
{
    CString result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IStory::SetRohdecke(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetRohdecke()
{
    float result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

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

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

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

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

void IStory::SetUnterbau(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStory::GetUnterbau()
{
    float result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

LPDISPATCH IStory::GetVirtualWalls()
{
    LPDISPATCH result;
    InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IStory::GetGauben()
{
    LPDISPATCH result;
    InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IStory::FindChimney(float x, float y)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x2d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        x, y);
    return result;
}

LPDISPATCH IStory::FindRoom(float x, float y)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        x, y);
    return result;
}

LPDISPATCH IStory::FindSupport(float x, float y)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x2c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        x, y);
    return result;
}

LPDISPATCH IStory::FindUnterUeberzug(float x, float y)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x2e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        x, y);
    return result;
}

LPDISPATCH IStory::FindWall(float x, float y)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x20, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IStory::Label(LPDISPATCH aLabeling, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x21, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aLabeling, x, y);
    return result;
}

BOOL IStory::PlaceCeiling(LPDISPATCH aCeiling, LPDISPATCH aPolygon)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x26, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aCeiling, aPolygon);
    return result;
}

BOOL IStory::PlaceCeilingOpening(LPDISPATCH opening, LPDISPATCH aPolygon)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH;
    InvokeHelper(0x27, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        opening, aPolygon);
    return result;
}

BOOL IStory::PlaceChimney(LPDISPATCH aChimney, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x24, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aChimney, x, y);
    return result;
}

BOOL IStory::PlaceDimension(LPDISPATCH aDimension, float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x22, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aDimension, x1, y1, x2, y2);
    return result;
}

BOOL IStory::PlaceGuide(LPDISPATCH aGuide, float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x23, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aGuide, x1, y1, x2, y2);
    return result;
}

BOOL IStory::PlaceRoof(LPDISPATCH aRoof, LPDISPATCH aPolygon, BOOL withDialog)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0x29, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aRoof, aPolygon, withDialog);
    return result;
}

BOOL IStory::PlaceRoofAutomatic(LPDISPATCH aRoof, float x, float y, BOOL withDialog)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4 VTS_BOOL;
    InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aRoof, x, y, withDialog);
    return result;
}

BOOL IStory::PlaceStairCase(LPDISPATCH stair, BOOL withDialog)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0x28, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        stair, withDialog);
    return result;
}

BOOL IStory::PlaceSupport(LPDISPATCH aSupport, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x25, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aSupport, x, y);
    return result;
}

BOOL IStory::PlaceUnterUeberzug(LPDISPATCH UnterUeberzug, float x1, float y1, float x2, float y2, float X3, float Y3, float x4, float y4)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        UnterUeberzug, x1, y1, x2, y2, X3, Y3, x4, y4);
    return result;
}

BOOL IStory::PlaceWall(LPDISPATCH aWall, float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x1f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aWall, x1, y1, x2, y2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICeilingOpeningsCollection properties

/////////////////////////////////////////////////////////////////////////////
// ICeilingOpeningsCollection operations

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

LPDISPATCH ICeilingOpeningsCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICeilingOpening properties

/////////////////////////////////////////////////////////////////////////////
// ICeilingOpening operations

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

long ICeilingOpening::GetId()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ICeilingOpening::SetPolygon(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void ICeilingOpening::Delete()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IPolygon2D properties

/////////////////////////////////////////////////////////////////////////////
// IPolygon2D operations

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

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

void IPolygon2D::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IPolygon2D::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IPolygon2D::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IPolygon2D::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void IPolygon2D::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IPolygon2D::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IPolygon2D::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IPolygon2D::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IPolygon2D::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long IPolygon2D::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void IPolygon2D::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IPolygon2D::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void IPolygon2D::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void IPolygon2D::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}

void IPolygon2D::SetBackColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IPolygon2D::GetBackColor()
{
    long result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetBackStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IPolygon2D::GetBackStyle()
{
    short result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetBorderColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IPolygon2D::SetBorderStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IPolygon2D::SetBorderWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IPolygon2D::GetBorderWidth()
{
    float result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

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

void IPolygon2D::SetDrawMode(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IPolygon2D::GetDrawMode()
{
    short result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetFillColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IPolygon2D::SetFillStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IPolygon2D::GetFillStyle()
{
    short result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

LPDISPATCH IPolygon2D::GetPoints()
{
    LPDISPATCH result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IPolygon2D::SetPoints(long numPoints, const VARIANT& Points)
{
    static BYTE parms[] =
        VTS_I4 VTS_VARIANT;
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         numPoints, &Points);
}


/////////////////////////////////////////////////////////////////////////////
// IGraphics2DObject properties

/////////////////////////////////////////////////////////////////////////////
// IGraphics2DObject operations

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

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

void IGraphics2DObject::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IGraphics2DObject::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IGraphics2DObject::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IGraphics2DObject::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IGraphics2DObject::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IGraphics2DObject::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IGraphics2DObject::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void IGraphics2DObject::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IGraphics2DObject::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IGraphics2DObject::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IGraphics2DObject::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IGraphics2DObject::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long IGraphics2DObject::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void IGraphics2DObject::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IGraphics2DObject::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void IGraphics2DObject::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void IGraphics2DObject::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}


/////////////////////////////////////////////////////////////////////////////
// IPoint2DCollection properties

/////////////////////////////////////////////////////////////////////////////
// IPoint2DCollection operations

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

void IPoint2DCollection::Add(LPDISPATCH aPoint)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         aPoint);
}

void IPoint2DCollection::AddPoint(float x, float y)
{
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y);
}

LPDISPATCH IPoint2DCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IPoint2D properties

/////////////////////////////////////////////////////////////////////////////
// IPoint2D operations

void IPoint2D::SetX(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IPoint2D::GetX()
{
    float result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IPoint2D::SetY(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IPoint2D::GetY()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICut properties

/////////////////////////////////////////////////////////////////////////////
// ICut operations

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

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

long ICut::GetId()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

BOOL ICut::GetReferenceLine(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGraphics2DCollection properties

/////////////////////////////////////////////////////////////////////////////
// IGraphics2DCollection operations

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

BOOL IGraphics2DCollection::Add(LPDISPATCH gr2DObj)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        gr2DObj);
    return result;
}

void IGraphics2DCollection::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

LPDISPATCH IGraphics2DCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}

BOOL IGraphics2DCollection::Remove(LPDISPATCH gr2DObj)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        gr2DObj);
    return result;
}

void IGraphics2DCollection::Sort(BOOL increasingZOrder)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         increasingZOrder);
}


/////////////////////////////////////////////////////////////////////////////
// ICeilingCollection properties

/////////////////////////////////////////////////////////////////////////////
// ICeilingCollection operations

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

LPDISPATCH ICeilingCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICeiling properties

/////////////////////////////////////////////////////////////////////////////
// ICeiling operations

void ICeiling::SetEdgeTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

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

long ICeiling::GetId()
{
    long result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ICeiling::SetLowerSurfaceTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void ICeiling::SetPolygon(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void ICeiling::SetUpperSurfaceTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

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

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

void ICeiling::Delete()
{
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// ITexture properties

/////////////////////////////////////////////////////////////////////////////
// ITexture operations

void ITexture::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITexture::GetAngle()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITexture::SetColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void ITexture::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITexture::GetHeight()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITexture::SetMixColorAndTexture(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ITexture::GetMixColorAndTexture()
{
    BOOL result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ITexture::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

void ITexture::SetUseOriginalSize(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ITexture::GetUseOriginalSize()
{
    BOOL result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ITexture::SetUseTexture(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ITexture::GetUseTexture()
{
    BOOL result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ITexture::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITexture::GetWidth()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITexture::SetXRaport(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITexture::GetXRaport()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITexture::SetYRaport(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITexture::GetYRaport()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IChimneyCollection properties

/////////////////////////////////////////////////////////////////////////////
// IChimneyCollection operations

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

LPDISPATCH IChimneyCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IChimney properties

/////////////////////////////////////////////////////////////////////////////
// IChimney operations

void IChimney::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IChimney::GetAngle()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IChimney::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IChimney::GetHeight()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long IChimney::GetId()
{
    long result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString IChimney::GetRemark()
{
    CString result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

void IChimney::SetThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IChimney::GetThickness()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IChimney::SetToCeiling(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IChimney::GetToCeiling()
{
    BOOL result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IChimney::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IChimney::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IChimney::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IChimney::GetWidth()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IChimney::Delete()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IChimney::GetPos(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IChimney::SetPos(float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IConturCollection properties

/////////////////////////////////////////////////////////////////////////////
// IConturCollection operations

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

LPDISPATCH IConturCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IContur properties

/////////////////////////////////////////////////////////////////////////////
// IContur operations

BOOL IContur::GetInner()
{
    BOOL result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

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


/////////////////////////////////////////////////////////////////////////////
// IRoom properties

/////////////////////////////////////////////////////////////////////////////
// IRoom operations

void IRoom::SetAngle(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IRoom::GetAngle()
{
    long result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

float IRoom::GetBodenflaeche()
{
    float result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoom::GetBodenflaechenFormel()
{
    CString result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

float IRoom::GetDeckenflaeche()
{
    float result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoom::GetDeckenflaechenFormel()
{
    CString result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoom::SetFlags(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IRoom::GetFlags()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoom::SetFont(const VARIANT& newValue)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &newValue);
}

VARIANT IRoom::GetFont()
{
    VARIANT result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoom::GetHistory()
{
    LPDISPATCH result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

long IRoom::GetId()
{
    long result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoom::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

float IRoom::GetNettoDeckenflaeche()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoom::GetNettoDeckenflaechenFormel()
{
    CString result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

float IRoom::GetNettoGrundflaeche()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoom::GetNettoGrundflaechenFormel()
{
    CString result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoom::SetNutzflaechenart(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IRoom::GetNutzflaechenart()
{
    CString result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoom::SetOrdnungszahl(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IRoom::GetOrdnungszahl()
{
    CString result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoom::SetPlasterName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IRoom::GetPlasterName()
{
    CString result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoom::SetPlasterThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IRoom::GetPlasterThickness()
{
    float result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IRoom::SetRemark(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IRoom::GetRemark()
{
    CString result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

void IRoom::SetUmschliessungsart(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IRoom::GetUmschliessungsart()
{
    short result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

float IRoom::GetVolumen()
{
    float result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoom::GetVolumenFormel()
{
    CString result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoom::GetFloorTexture()
{
    LPDISPATCH result;
    InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoom::GetCeilingTexture()
{
    LPDISPATCH result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoom::GetRoofAreas()
{
    LPDISPATCH result;
    InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

BOOL IRoom::AddHolePolygon(LPDISPATCH thePolygon, BOOL holeInCeiling)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        thePolygon, holeInCeiling);
    return result;
}

BOOL IRoom::RemoveHolePolygon(LPDISPATCH thePolygon, BOOL holeInCeiling)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        thePolygon, holeInCeiling);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISupportCollection properties

/////////////////////////////////////////////////////////////////////////////
// ISupportCollection operations

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

LPDISPATCH ISupportCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ISupport properties

/////////////////////////////////////////////////////////////////////////////
// ISupport operations

void ISupport::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ISupport::GetAngle()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ISupport::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ISupport::GetHeight()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long ISupport::GetId()
{
    long result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString ISupport::GetRemark()
{
    CString result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

void ISupport::SetThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ISupport::GetThickness()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ISupport::SetToCeiling(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ISupport::GetToCeiling()
{
    BOOL result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ISupport::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ISupport::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ISupport::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ISupport::GetWidth()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ISupport::Delete()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ISupport::GetPos(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL ISupport::SetPos(float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofAreaCollection properties

/////////////////////////////////////////////////////////////////////////////
// IRoofAreaCollection operations

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

LPDISPATCH IRoofAreaCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofArea properties

/////////////////////////////////////////////////////////////////////////////
// IRoofArea operations

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

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

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

BOOL IRoofArea::GetOutside()
{
    BOOL result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofArea::SetOutside(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

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

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

long IRoofArea::GetId()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

float IRoofArea::GetArea()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoofArea::GetAreaFormula()
{
    CString result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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


/////////////////////////////////////////////////////////////////////////////
// IRoof properties

/////////////////////////////////////////////////////////////////////////////
// IRoof operations

double IRoof::GetDachSummeFirstlaenge()
{
    double result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummeFlaeche()
{
    double result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummeGratlaenge()
{
    double result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummeKehlenlaenge()
{
    double result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummeOrtganglaenge()
{
    double result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummePultdachFirstlaenge()
{
    double result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetDachSummeTrauflaenge()
{
    double result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetFlaecheDerEindeckungUebermessen()
{
    double result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeFirstlaenge()
{
    double result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeFlaeche()
{
    double result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeGratlaenge()
{
    double result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeKehlenlaenge()
{
    double result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeOrtganglaenge()
{
    double result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummePultdachFirstlaenge()
{
    double result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetGaubenSummeTrauflaenge()
{
    double result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

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

long IRoof::GetId()
{
    long result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

double IRoof::GetTotalSummeFirstlaenge()
{
    double result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummeFlaeche()
{
    double result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummeGratlaenge()
{
    double result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummeKehlenlaenge()
{
    double result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummeOrtganglaenge()
{
    double result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummePultdachFirstlaenge()
{
    double result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

double IRoof::GetTotalSummeTrauflaenge()
{
    double result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

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

LPDISPATCH IRoof::GetRoofAreas()
{
    LPDISPATCH result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoof::GetGauben()
{
    LPDISPATCH result;
    InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoof::GetConstruction()
{
    LPDISPATCH result;
    InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

long IRoof::GetTextureCount()
{
    long result;
    InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoof::Delete()
{
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IRoof::Edit()
{
    BOOL result;
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

LPDISPATCH IRoof::CreateGaube(long Type, LPDISPATCH Contur)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH;
    InvokeHelper(0x22, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Type, Contur);
    return result;
}

LPDISPATCH IRoof::GetWoodConstruction(BOOL collapse, float epsilon)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_BOOL VTS_R4;
    InvokeHelper(0x23, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        collapse, epsilon);
    return result;
}

BOOL IRoof::SetTexture(long Index, LPCTSTR TextureName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x25, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, TextureName);
    return result;
}

CString IRoof::GetTexture(long Index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x26, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWindowCollection properties

/////////////////////////////////////////////////////////////////////////////
// IWindowCollection operations

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

LPDISPATCH IWindowCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGaubenCollection properties

/////////////////////////////////////////////////////////////////////////////
// IGaubenCollection operations

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

LPDISPATCH IGaubenCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGaube properties

/////////////////////////////////////////////////////////////////////////////
// IGaube operations

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

long IGaube::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

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

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

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

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

long IGaube::GetId()
{
    long result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IGaube::GetTextureCount()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL IGaube::SetTexture(long Index, LPCTSTR TextureName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, TextureName);
    return result;
}

CString IGaube::GetTexture(long Index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWall properties

/////////////////////////////////////////////////////////////////////////////
// IWall operations

float IWall::GetAverageArea()
{
    float result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IWall::GetAverageAreaFormula()
{
    CString result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

float IWall::GetAverageLength()
{
    float result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

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

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

long IWall::GetId()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IWall::SetThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IWall::GetThickness()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IWall::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IWall::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

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

void IWall::Delete()
{
    InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IWall::GetPos(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IWall::SetPos(float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IWall::PlaceDoor(LPDISPATCH aDoor, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aDoor, x, y);
    return result;
}

BOOL IWall::PlaceHole(LPDISPATCH aHole, LPDISPATCH aPolygon, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aHole, aPolygon, x, y);
    return result;
}

BOOL IWall::PlaceWindow(LPDISPATCH aWindow, float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_R4 VTS_R4;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aWindow, x, y);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDoorCollection properties

/////////////////////////////////////////////////////////////////////////////
// IDoorCollection operations

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

LPDISPATCH IDoorCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDoor properties

/////////////////////////////////////////////////////////////////////////////
// IDoor operations

float IDoor::GetArea()
{
    float result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IDoor::GetAreaFormula()
{
    CString result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IDoor::SetFrameTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IDoor::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IDoor::GetHeight()
{
    float result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

void IDoor::SetHungLeft(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IDoor::GetHungLeft()
{
    BOOL result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

long IDoor::GetId()
{
    long result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IDoor::SetLeftWingAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IDoor::GetLeftWingAngle()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IDoor::SetLeftWingTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IDoor::SetLeftWingType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IDoor::GetLeftWingType()
{
    long result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IDoor::SetOpensInwards(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IDoor::GetOpensInwards()
{
    BOOL result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

CString IDoor::GetRemark()
{
    CString result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

void IDoor::SetRightWingAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IDoor::GetRightWingAngle()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IDoor::SetRightWingTexture(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IDoor::SetRightWingType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IDoor::GetRightWingType()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IDoor::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IDoor::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IDoor::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IDoor::GetWidth()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IDoor::Delete()
{
    InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDoor::GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PDISPATCH VTS_PDISPATCH VTS_PR4 VTS_PR4;
    InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        leftPolygon, rightPolygon, leftDepth, rightDepth);
    return result;
}

BOOL IDoor::GetPos(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IDoor::SetPos(float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWallSegment properties

/////////////////////////////////////////////////////////////////////////////
// IWallSegment operations

float IWallSegment::GetArea()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IWallSegment::GetAreaFormula()
{
    CString result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

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

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

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

long IWallSegment::GetId()
{
    long result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IWallSegment::SetMaterialFromBelow(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IWallSegment::GetMaterialFromBelow()
{
    BOOL result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

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

long IWallSegment::GetVisMode()
{
    long result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

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

long IWallSegment::GetWallSide()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

float IWallSegment::GetZBottom()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IWallSegment::GetZTop()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

BOOL IWallSegment::AddHolePolygon(LPDISPATCH thePolygon)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        thePolygon);
    return result;
}

BOOL IWallSegment::GetPos(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IWallSegment::RemoveHolePolygon(LPDISPATCH thePolygon)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        thePolygon);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IHoleCollection properties

/////////////////////////////////////////////////////////////////////////////
// IHoleCollection operations

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

LPDISPATCH IHoleCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IHole properties

/////////////////////////////////////////////////////////////////////////////
// IHole operations

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

long IHole::GetId()
{
    long result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IHole::SetLeftAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetLeftAngle()
{
    float result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetLeftBase(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetLeftBase()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetLeftHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetLeftHeight()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetLeftToTop(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IHole::GetLeftToTop()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IHole::SetPolygon(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IHole::SetRightAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetRightAngle()
{
    float result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetRightBase(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetRightBase()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetRightHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetRightHeight()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::SetRightToTop(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IHole::GetRightToTop()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IHole::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHole::GetWidth()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHole::Delete()
{
    InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IHole::GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PDISPATCH VTS_PDISPATCH VTS_PR4 VTS_PR4;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        leftPolygon, rightPolygon, leftDepth, rightDepth);
    return result;
}

BOOL IHole::SetPos(float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IHole::GetPos(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILambdaHCollection properties

/////////////////////////////////////////////////////////////////////////////
// ILambdaHCollection operations

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

LPDISPATCH ILambdaHCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILambdaH properties

/////////////////////////////////////////////////////////////////////////////
// ILambdaH operations

float ILambdaH::GetHeight()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float ILambdaH::GetLambda()
{
    float result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IHolePolygon properties

/////////////////////////////////////////////////////////////////////////////
// IHolePolygon operations

BOOL IHolePolygon::AddHole(LPDISPATCH newHole)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newHole);
    return result;
}

BOOL IHolePolygon::RemoveHole(LPDISPATCH removedHole)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        removedHole);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWallSegmentCollection properties

/////////////////////////////////////////////////////////////////////////////
// IWallSegmentCollection operations

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

LPDISPATCH IWallSegmentCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IVirtualWall properties

/////////////////////////////////////////////////////////////////////////////
// IVirtualWall operations

void IVirtualWall::SetWithHoles(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IVirtualWall::GetWithHoles()
{
    BOOL result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IVirtualWall::SetThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IVirtualWall::GetThickness()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IVirtualWall::SetStyle(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IVirtualWall::GetStyle()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IVirtualWall::SetColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

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

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

long IVirtualWall::GetId()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

BOOL IVirtualWall::Delete()
{
    BOOL result;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IVirtualWall::GetPos(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IVirtualWall::SetPos(float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofConstruction properties

/////////////////////////////////////////////////////////////////////////////
// IRoofConstruction operations

double IRoofConstruction::GetDickeEindeckung()
{
    double result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetDickeEindeckung(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetDickeKonstruktion()
{
    double result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetDickeKonstruktion(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetDachrinnenDurchmesser()
{
    double result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetDachrinnenDurchmesser(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

BOOL IRoofConstruction::GetEindeckungTransparent()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetEindeckungTransparent(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetDachHorizontalBegrenzen()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetDachHorizontalBegrenzen(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

double IRoofConstruction::GetSchnittHoehe()
{
    double result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetSchnittHoehe(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

BOOL IRoofConstruction::GetMitDachrinne()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitDachrinne(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetMitTraufDetails()
{
    BOOL result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitTraufDetails(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

long IRoofConstruction::GetTraufDetailTyp()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetTraufDetailTyp(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

BOOL IRoofConstruction::GetMitFirstSteinen()
{
    BOOL result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitFirstSteinen(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetPfettenKoepfeSichtbar()
{
    BOOL result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetPfettenKoepfeSichtbar(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

double IRoofConstruction::GetSparrenKopfLaenge()
{
    double result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetSparrenKopfLaenge(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetSparrenKopfTiefe()
{
    double result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetSparrenKopfTiefe(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetGesimsHoeheStirn()
{
    double result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetGesimsHoeheStirn(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetGesimsNeigungStirn()
{
    double result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetGesimsNeigungStirn(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

BOOL IRoofConstruction::GetMitSparren()
{
    BOOL result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitSparren(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetMitKehlbalken()
{
    BOOL result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitKehlbalken(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetMitGratsparren()
{
    BOOL result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitGratsparren(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetMitFusspfetten()
{
    BOOL result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitFusspfetten(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofConstruction::GetMitFirstpfetten()
{
    BOOL result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitFirstpfetten(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

double IRoofConstruction::GetHoeheUKMittelpfetten()
{
    double result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetHoeheUKMittelpfetten(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetHoeheUKKehlbalken()
{
    double result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetHoeheUKKehlbalken(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetMaxSparrenAbstand()
{
    double result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMaxSparrenAbstand(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetAbstandOrtgangSparren()
{
    double result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetAbstandOrtgangSparren(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetMaxUeberstandEindeckung()
{
    double result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMaxUeberstandEindeckung(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetSparrenBreite()
{
    double result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetSparrenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetSparrenDicke()
{
    double result;
    InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetSparrenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetKehlbalkenBreite()
{
    double result;
    InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetKehlbalkenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetKehlbalkenDicke()
{
    double result;
    InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetKehlbalkenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetGratsparrenBreite()
{
    double result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetGratsparrenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetGratsparrenDicke()
{
    double result;
    InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetGratsparrenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetFusspfettenBreite()
{
    double result;
    InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetFusspfettenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetFusspfettenDicke()
{
    double result;
    InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetFusspfettenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetMittelpfettenBreite()
{
    double result;
    InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMittelpfettenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetMittelpfettenDicke()
{
    double result;
    InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMittelpfettenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetFirstpfettenBreite()
{
    double result;
    InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetFirstpfettenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetFirstpfettenDicke()
{
    double result;
    InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetFirstpfettenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetKehlbohlenBreite()
{
    double result;
    InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetKehlbohlenBreite(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

double IRoofConstruction::GetKehlbohlenDicke()
{
    double result;
    InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetKehlbohlenDicke(double newValue)
{
    static BYTE parms[] =
        VTS_R8;
    InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

BOOL IRoofConstruction::GetMitMittelpfetten()
{
    BOOL result;
    InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IRoofConstruction::SetMitMittelpfetten(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x36, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

LPDISPATCH IRoofConstruction::CreateRoof(LPDISPATCH aStory)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        aStory);
    return result;
}

BOOL IRoofConstruction::SetzeAnzahlKonturPunkte(long AnzahlSeiten)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x29, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        AnzahlSeiten);
    return result;
}

BOOL IRoofConstruction::SetzeKonturPunkt(long seite, double x, double y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_R8 VTS_R8;
    InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, x, y);
    return result;
}

BOOL IRoofConstruction::SetzeUeberstand(long seite, double ueberstand)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_R8;
    InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, ueberstand);
    return result;
}

BOOL IRoofConstruction::SetzeAnzahlKnicke(long seite, long anzahlKnicke)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, anzahlKnicke);
    return result;
}

BOOL IRoofConstruction::SetzeKnickNeigung(long seite, long knick, double neigung)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_R8;
    InvokeHelper(0x2d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, knick, neigung);
    return result;
}

BOOL IRoofConstruction::SetzeKnickHoehe(long seite, long knick, double hoehe)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_R8;
    InvokeHelper(0x2e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, knick, hoehe);
    return result;
}

BOOL IRoofConstruction::HoleAnzahlKonturPunkte(long* AnzahlSeiten)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PI4;
    InvokeHelper(0x2f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        AnzahlSeiten);
    return result;
}

BOOL IRoofConstruction::HoleKonturPunkt(long seite, double* x, double* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_PR8 VTS_PR8;
    InvokeHelper(0x30, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, x, y);
    return result;
}

BOOL IRoofConstruction::HoleUeberstand(long seite, double* ueberstand)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_PR8;
    InvokeHelper(0x31, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, ueberstand);
    return result;
}

BOOL IRoofConstruction::HoleAnzahlKnicke(long seite, long* anzahlKnicke)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_PI4;
    InvokeHelper(0x32, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, anzahlKnicke);
    return result;
}

BOOL IRoofConstruction::HoleKnickNeigung(long seite, long knick, double* neigung)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_PR8;
    InvokeHelper(0x33, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, knick, neigung);
    return result;
}

BOOL IRoofConstruction::HoleKnickHoehe(long seite, long knick, double* hoehe)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_PR8;
    InvokeHelper(0x34, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        seite, knick, hoehe);
    return result;
}

long IRoofConstruction::GetAnzahlFlaechen()
{
    long result;
    InvokeHelper(0x38, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

long IRoofConstruction::GetFlaechenTyp(long Index)
{
    long result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x39, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Index);
    return result;
}

double IRoofConstruction::GetFlaechenNeigung(long Index)
{
    double result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3a, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        Index);
    return result;
}

double IRoofConstruction::GetFlaechenRichtung(long Index)
{
    double result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3b, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
        Index);
    return result;
}

long IRoofConstruction::GetFlaechenVater(long Index)
{
    long result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3c, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Index);
    return result;
}

long IRoofConstruction::GetAnzahlKanten(long Index)
{
    long result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3d, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Index);
    return result;
}

long IRoofConstruction::GetDachkantenTyp(long Index, long kantenIndex)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x3e, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Index, kantenIndex);
    return result;
}

BOOL IRoofConstruction::GetDachkanteAktiv(long Index, long kantenIndex)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x3f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, kantenIndex);
    return result;
}

long IRoofConstruction::GetDachkantenNachbarflaeche(long Index, long kantenIndex)
{
    long result;
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x40, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        Index, kantenIndex);
    return result;
}

BOOL IRoofConstruction::GetDachkantenPunktAnfang(long Index, long kantenIndex, float* x, float* y, float* z)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x41, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, kantenIndex, x, y, z);
    return result;
}

BOOL IRoofConstruction::GetDachkantenPunktEnde(long Index, long kantenIndex, float* x, float* y, float* z)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x37, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, kantenIndex, x, y, z);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofWoodCollection properties

/////////////////////////////////////////////////////////////////////////////
// IRoofWoodCollection operations

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

LPDISPATCH IRoofWoodCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}

void IRoofWoodCollection::Sort(long criteria)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         criteria);
}


/////////////////////////////////////////////////////////////////////////////
// IRoofWood properties

/////////////////////////////////////////////////////////////////////////////
// IRoofWood operations

long IRoofWood::GetType()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IRoofWood::GetNumber()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

float IRoofWood::GetWidth()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IRoofWood::GetHeight()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IRoofWood::GetLength()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofCollection properties

/////////////////////////////////////////////////////////////////////////////
// IRoofCollection operations

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

LPDISPATCH IRoofCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoomCollection properties

/////////////////////////////////////////////////////////////////////////////
// IRoomCollection operations

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

LPDISPATCH IRoomCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStairCaseCollection properties

/////////////////////////////////////////////////////////////////////////////
// IStairCaseCollection operations

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

LPDISPATCH IStairCaseCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IStairCase properties

/////////////////////////////////////////////////////////////////////////////
// IStairCase operations

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

long IStairCase::GetId()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IStairCase::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IStairCase::GetType()
{
    long result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetX1(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetX1()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetX2(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetX2()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetX3(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetX3()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetY1(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetY1()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetY2(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetY2()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IStairCase::SetY3(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IStairCase::GetY3()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetLaufLaenge()
{
    float result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetLaufBreiteAussen()
{
    float result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetLaufPlattenDicke()
{
    float result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetHoehe()
{
    float result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetAuftrittsBreite()
{
    float result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetSteigung()
{
    float result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetGelaenderLaengeLinks()
{
    float result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetGelaenderLaengeRechts()
{
    float result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetGelaenderHoeheLinks()
{
    float result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float IStairCase::GetGelaenderHoeheRechts()
{
    float result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

long IStairCase::GetTextureCount()
{
    long result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IStairCase::Delete()
{
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

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

BOOL IStairCase::SetTexture(long Index, LPCTSTR TextureName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, TextureName);
    return result;
}

CString IStairCase::GetTexture(long Index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzugCollection properties

/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzugCollection operations

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

LPDISPATCH IUnterUeberzugCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzug properties

/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzug operations

void IUnterUeberzug::SetDeckelTextur(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IUnterUeberzug::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IUnterUeberzug::GetHeight()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetLength(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IUnterUeberzug::GetLength()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSchraffur(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSchraffur()
{
    long result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSchraffurFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSchraffurFarbe()
{
    long result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg1LinienFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg1LinienFarbe()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg1LinienTyp(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg1LinienTyp()
{
    long result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg1Textur(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IUnterUeberzug::SetSeg2LinienFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg2LinienFarbe()
{
    long result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg2LinienTyp(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg2LinienTyp()
{
    long result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg2Textur(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IUnterUeberzug::SetSeg3LinienFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg3LinienFarbe()
{
    long result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg3LinienTyp(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg3LinienTyp()
{
    long result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg3Textur(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

void IUnterUeberzug::SetSeg4LinienFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg4LinienFarbe()
{
    long result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg4LinienTyp(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IUnterUeberzug::GetSeg4LinienTyp()
{
    long result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetSeg4Textur(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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

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

void IUnterUeberzug::SetThickness(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IUnterUeberzug::GetThickness()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IUnterUeberzug::SetUeberzug(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IUnterUeberzug::GetUeberzug()
{
    BOOL result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

long IUnterUeberzug::GetId()
{
    long result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL IUnterUeberzug::Delete()
{
    BOOL result;
    InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IUnterUeberzug::GetPos(float* x1, float* y1, float* x2, float* y2, float* X3, float* Y3, float* x4, float* y4)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2, X3, Y3, x4, y4);
    return result;
}

BOOL IUnterUeberzug::SetPos(float x1, float y1, float x2, float y2, float X3, float Y3, float x4, float y4)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2, X3, Y3, x4, y4);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWallCollection properties

/////////////////////////////////////////////////////////////////////////////
// IWallCollection operations

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

LPDISPATCH IWallCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IVirtualWallCollection properties

/////////////////////////////////////////////////////////////////////////////
// IVirtualWallCollection operations

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

LPDISPATCH IVirtualWallCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILabeling properties

/////////////////////////////////////////////////////////////////////////////
// ILabeling operations

void ILabeling::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabeling::GetAngle()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabeling::SetColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void ILabeling::SetFont(const VARIANT& newValue)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &newValue);
}

VARIANT ILabeling::GetFont()
{
    VARIANT result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

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

long ILabeling::GetId()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void ILabeling::SetText(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

void ILabeling::Delete()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ILabeling::GetPos(float* x1, float* y1)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1);
    return result;
}

BOOL ILabeling::SetPos(float x1, float y1)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimension properties

/////////////////////////////////////////////////////////////////////////////
// IDimension operations

void IDimension::SetArchitektengerecht(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IDimension::GetArchitektengerecht()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IDimension::SetDecimals(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IDimension::GetDecimals()
{
    short result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IDimension::SetDistance(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IDimension::GetDistance()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long IDimension::GetId()
{
    long result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IDimension::SetType(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IDimension::Delete()
{
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IDimension::GetPos(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IDimension::SetPos(float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGuide properties

/////////////////////////////////////////////////////////////////////////////
// IGuide operations

void IGuide::SetColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IGuide::SetDrawStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IGuide::GetDrawStyle()
{
    short result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IGuide::SetEndless(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IGuide::GetEndless()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

long IGuide::GetId()
{
    long result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IGuide::Delete()
{
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IGuide::GetPos(float* x1, float* y1, float* x2, float* y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}

BOOL IGuide::SetPos(float x1, float y1, float x2, float y2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x1, y1, x2, y2);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IProject properties

/////////////////////////////////////////////////////////////////////////////
// IProject operations

void IProject::SetBackColorDay(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IProject::GetBackColorDay()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IProject::SetBackColorNight(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IProject::GetBackColorNight()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IProject::SetOriginX(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetOriginX()
{
    float result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IProject::SetOriginY(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetOriginY()
{
    float result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IProject::SetOriginZ(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetOriginZ()
{
    float result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IProject::SetPaperHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetPaperHeight()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IProject::SetPaperSize(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IProject::GetPaperSize()
{
    short result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IProject::SetPaperSizeName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IProject::GetPaperSizeName()
{
    CString result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IProject::SetPaperSizePrinter(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IProject::GetPaperSizePrinter()
{
    short result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IProject::SetPaperWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetPaperWidth()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IProject::SetScale(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IProject::GetScale()
{
    short result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

CString IProject::GetShortName()
{
    CString result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IProject::SetUnit(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IProject::GetUnit()
{
    short result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IProject::SetWorldRotation(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IProject::GetWorldRotation()
{
    float result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICutCollection properties

/////////////////////////////////////////////////////////////////////////////
// ICutCollection operations

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

LPDISPATCH ICutCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IObjectConstructorCollection properties

/////////////////////////////////////////////////////////////////////////////
// IObjectConstructorCollection operations

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

LPDISPATCH IObjectConstructorCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IObjectConstructor properties

/////////////////////////////////////////////////////////////////////////////
// IObjectConstructor operations

long IObjectConstructor::GetDuration()
{
    long result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

CString IObjectConstructor::GetFileName()
{
    CString result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

long IObjectConstructor::GetId()
{
    long result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

CString IObjectConstructor::GetRelativeFileName()
{
    CString result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IObjectConstructor::AddPolygonWithHoles(BOOL SharpEdges, LPDISPATCH mat, LPCTSTR TextureName)
{
    static BYTE parms[] =
        VTS_BOOL VTS_DISPATCH VTS_BSTR;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         SharpEdges, mat, TextureName);
}

void IObjectConstructor::AddQuadriliteral(long SharpEdges, LPDISPATCH mat, LPCTSTR TextureName)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH VTS_BSTR;
    InvokeHelper(0x9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         SharpEdges, mat, TextureName);
}

void IObjectConstructor::AddTriangle(long SharpEdges, LPDISPATCH mat, LPCTSTR TextureName)
{
    static BYTE parms[] =
        VTS_I4 VTS_DISPATCH VTS_BSTR;
    InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         SharpEdges, mat, TextureName);
}

LPDISPATCH IObjectConstructor::Create(LPDISPATCH textureList, BOOL isRoomObject)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_BOOL;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        textureList, isRoomObject);
    return result;
}

BOOL IObjectConstructor::Finish(LPCTSTR Name, BOOL storeInProject, long Duration)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR VTS_BOOL VTS_I4;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Name, storeInProject, Duration);
    return result;
}

LPDISPATCH IObjectConstructor::GetTextureCollection()
{
    LPDISPATCH result;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void IObjectConstructor::SetHoleContur(short holeIndex, short numPoints, const VARIANT& Points)
{
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_VARIANT;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         holeIndex, numPoints, &Points);
}

void IObjectConstructor::SetContur(short numPoints, const VARIANT& Points)
{
    static BYTE parms[] =
        VTS_I2 VTS_VARIANT;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         numPoints, &Points);
}

void IObjectConstructor::SetHolePoint(short holeIndex, short pointIndex, float x, float y, float z, float u, float v)
{
    static BYTE parms[] =
        VTS_I2 VTS_I2 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         holeIndex, pointIndex, x, y, z, u, v);
}

void IObjectConstructor::SetPoint(short Index, float x, float y, float z, float u, float v)
{
    static BYTE parms[] =
        VTS_I2 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         Index, x, y, z, u, v);
}


/////////////////////////////////////////////////////////////////////////////
// IObject3DCollection properties

/////////////////////////////////////////////////////////////////////////////
// IObject3DCollection operations

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

LPDISPATCH IObject3DCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IObject3D properties

/////////////////////////////////////////////////////////////////////////////
// IObject3D operations

void IObject3D::SetDarfVerzerren(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetDarfVerzerren()
{
    BOOL result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetFlags(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IObject3D::GetFlags()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL IObject3D::GetGroup()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

long IObject3D::GetId()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IObject3D::SetKeineSchatten(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetKeineSchatten()
{
    BOOL result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLampenBeiNachtAn(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetLampenBeiNachtAn()
{
    BOOL result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLampenSindAn(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetLampenSindAn()
{
    BOOL result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLichtEinfluss(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IObject3D::GetLichtEinfluss()
{
    float result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLichtFarbe(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IObject3D::GetLichtFarbe()
{
    long result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLichtIntensitaet(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IObject3D::GetLichtIntensitaet()
{
    float result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLichtMachtSchatten(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetLichtMachtSchatten()
{
    BOOL result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetLokalAnTerrainAnpassen(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetLokalAnTerrainAnpassen()
{
    BOOL result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

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

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

BOOL IObject3D::GetRoomObject()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IObject3D::SetSollFallen(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IObject3D::GetSollFallen()
{
    BOOL result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

BOOL IObject3D::Delete(BOOL withSubObjects)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x17, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        withSubObjects);
    return result;
}

BOOL IObject3D::GetBoundingBox(float* minX, float* minY, float* minZ, float* maxX, float* maxY, float* maxZ)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x1a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        minX, minY, minZ, maxX, maxY, maxZ);
    return result;
}

BOOL IObject3D::GetModelToGroupTransformation(VARIANT* matrix)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        matrix);
    return result;
}

BOOL IObject3D::GetModelToWorldTransformation(VARIANT* matrix)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x19, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        matrix);
    return result;
}

LPDISPATCH IObject3D::GetTextureCollection()
{
    LPDISPATCH result;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

BOOL IObject3D::InsertIntoWorld(BOOL selected)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        selected);
    return result;
}

BOOL IObject3D::SetModelToWorldTransformation(const VARIANT& matrix)
{
    BOOL result;
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x15, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        &matrix);
    return result;
}

void IObject3D::SetOutline2D(LPDISPATCH obj2D, long cursor, LPCTSTR hint)
{
    static BYTE parms[] =
        VTS_DISPATCH VTS_I4 VTS_BSTR;
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         obj2D, cursor, hint);
}

BOOL IObject3D::WriteToFile(LPCTSTR FileName, float centerX, float centerY, float centerZ)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x18, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        FileName, centerX, centerY, centerZ);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITextureCollection properties

/////////////////////////////////////////////////////////////////////////////
// ITextureCollection operations

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

LPDISPATCH ITextureCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITextureName properties

/////////////////////////////////////////////////////////////////////////////
// ITextureName operations

void ITextureName::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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


/////////////////////////////////////////////////////////////////////////////
// IMaterial properties

/////////////////////////////////////////////////////////////////////////////
// IMaterial operations

void IMaterial::SetAmbientCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IMaterial::GetAmbientCoefficient()
{
    float result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetDiffuseCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IMaterial::GetDiffuseCoefficient()
{
    float result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetDiffuseColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IMaterial::GetDiffuseColor()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetFlags(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IMaterial::GetFlags()
{
    long result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetHighlightExponent(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IMaterial::GetHighlightExponent()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetSpecularCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IMaterial::GetSpecularCoefficient()
{
    float result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetSpecularColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IMaterial::GetSpecularColor()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetTransparency(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IMaterial::GetTransparency()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IMaterial::SetTransparent(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IMaterial::GetTransparent()
{
    BOOL result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

BOOL IMaterial::DragStart()
{
    BOOL result;
    InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IDimensionCollection properties

/////////////////////////////////////////////////////////////////////////////
// IDimensionCollection operations

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

LPDISPATCH IDimensionCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITerrain properties

/////////////////////////////////////////////////////////////////////////////
// ITerrain operations

void ITerrain::SetAmbientCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetAmbientCoefficient()
{
    float result;
    InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

float ITerrain::GetArea()
{
    float result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString ITerrain::GetAreaFormula()
{
    CString result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

LPDISPATCH ITerrain::GetBuildings()
{
    LPDISPATCH result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void ITerrain::SetDiffuseCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetDiffuseCoefficient()
{
    float result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetDiffuseColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ITerrain::GetDiffuseColor()
{
    long result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetFacetteLength(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetFacetteLength()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetFlags(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ITerrain::GetFlags()
{
    long result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void ITerrain::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetHeight()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetHighlightExponent(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetHighlightExponent()
{
    float result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

LPDISPATCH ITerrain::GetHistory()
{
    LPDISPATCH result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

long ITerrain::GetId()
{
    long result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

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

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

void ITerrain::SetRemark(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString ITerrain::GetRemark()
{
    CString result;
    InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void ITerrain::SetSpecularCoefficient(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetSpecularCoefficient()
{
    float result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetSpecularColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ITerrain::GetSpecularColor()
{
    long result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

LPDISPATCH ITerrain::GetTerrains()
{
    LPDISPATCH result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

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

void ITerrain::SetTransparency(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ITerrain::GetTransparency()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ITerrain::SetTransparent(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ITerrain::GetTransparent()
{
    BOOL result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ITerrain::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ITerrain::GetType()
{
    long result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

float ITerrain::GetUmfang()
{
    float result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString ITerrain::GetUmfangsFormel()
{
    CString result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void ITerrain::Delete()
{
    InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ITerrain::Edit()
{
    BOOL result;
    InvokeHelper(0x1e, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ITerrain::GetTransformation(float* x1, float* y1, float* z1, float* x2, float* y2, float* z2, float* X3, float* Y3, float* z3)
{
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x1, y1, z1, x2, y2, z2, X3, Y3, z3);
}

void ITerrain::SetTransformation(float x1, float y1, float z1, float x2, float y2, float z2, float X3, float Y3, float z3)
{
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4;
    InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x1, y1, z1, x2, y2, z2, X3, Y3, z3);
}


/////////////////////////////////////////////////////////////////////////////
// IHedge properties

/////////////////////////////////////////////////////////////////////////////
// IHedge operations

void IHedge::SetContinuous(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IHedge::GetContinuous()
{
    BOOL result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IHedge::SetDistance(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IHedge::GetDistance()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IHedge::SetFileName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IHedge::GetFileName()
{
    CString result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IHedge::SetScaleToFit(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IHedge::GetScaleToFit()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ITerrainCollection properties

/////////////////////////////////////////////////////////////////////////////
// ITerrainCollection operations

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

LPDISPATCH ITerrainCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IGuideCollection properties

/////////////////////////////////////////////////////////////////////////////
// IGuideCollection operations

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

LPDISPATCH IGuideCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILabelingCollection properties

/////////////////////////////////////////////////////////////////////////////
// ILabelingCollection operations

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

LPDISPATCH ILabelingCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IToolData properties

/////////////////////////////////////////////////////////////////////////////
// IToolData operations

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

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

void IToolData::Abort()
{
    InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IToolData::AddSnapPoint(float x, float y, float dirX, float dirY, float Distance, BOOL isOnVertex)
{
    static BYTE parms[] =
        VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_R4 VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         x, y, dirX, dirY, Distance, isOnVertex);
}

void IToolData::Continue()
{
    InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IToolData::Finish()
{
    InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IImage properties

/////////////////////////////////////////////////////////////////////////////
// IImage operations

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

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

void IImage::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IImage::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IImage::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IImage::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IImage::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IImage::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IImage::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void IImage::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IImage::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IImage::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IImage::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IImage::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long IImage::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void IImage::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IImage::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void IImage::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void IImage::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}

void IImage::SetAutoSize(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IImage::GetAutoSize()
{
    short result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IImage::SetBorderStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IImage::SetFileName(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IImage::GetFileName()
{
    CString result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IImage::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IImage::GetHeight()
{
    float result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IImage::SetLeft(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IImage::GetLeft()
{
    float result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IImage::SetPicture(const VARIANT& newValue)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &newValue);
}

void IImage::SetTop(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IImage::GetTop()
{
    float result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IImage::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IImage::GetWidth()
{
    float result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILabel properties

/////////////////////////////////////////////////////////////////////////////
// ILabel operations

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

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

void ILabel::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILabel::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILabel::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILabel::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void ILabel::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void ILabel::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ILabel::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void ILabel::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long ILabel::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void ILabel::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ILabel::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void ILabel::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void ILabel::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}

void ILabel::SetAlignment(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short ILabel::GetAlignment()
{
    short result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void ILabel::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabel::GetAngle()
{
    float result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabel::SetAutoSize(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetAutoSize()
{
    BOOL result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILabel::SetBackColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ILabel::GetBackColor()
{
    long result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ILabel::SetBackStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short ILabel::GetBackStyle()
{
    short result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void ILabel::SetBorderStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

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

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

void ILabel::SetFont(const VARIANT& newValue)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &newValue);
}

VARIANT ILabel::GetFont()
{
    VARIANT result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void ILabel::SetForeColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ILabel::GetForeColor()
{
    long result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void ILabel::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabel::GetHeight()
{
    float result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabel::SetLeft(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabel::GetLeft()
{
    float result;
    InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabel::SetTop(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabel::GetTop()
{
    float result;
    InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabel::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILabel::GetWidth()
{
    float result;
    InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILabel::SetWordWrap(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILabel::GetWordWrap()
{
    BOOL result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ILine properties

/////////////////////////////////////////////////////////////////////////////
// ILine operations

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

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

void ILine::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILine::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILine::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILine::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILine::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILine::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void ILine::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void ILine::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL ILine::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void ILine::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long ILine::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void ILine::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long ILine::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void ILine::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL ILine::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void ILine::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void ILine::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}

void ILine::SetBorderColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void ILine::SetBorderStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void ILine::SetBorderWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILine::GetBorderWidth()
{
    float result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILine::SetDrawMode(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short ILine::GetDrawMode()
{
    short result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void ILine::SetX1(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILine::GetX1()
{
    float result;
    InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILine::SetX2(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILine::GetX2()
{
    float result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILine::SetY1(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILine::GetY1()
{
    float result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void ILine::SetY2(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float ILine::GetY2()
{
    float result;
    InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IObjectTransformerCollection properties

/////////////////////////////////////////////////////////////////////////////
// IObjectTransformerCollection operations

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

BOOL IObjectTransformerCollection::Add(LPDISPATCH anObject, const VARIANT& aMatrix)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH VTS_VARIANT;
    InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        anObject, &aMatrix);
    return result;
}

BOOL IObjectTransformerCollection::AddTransformer(LPDISPATCH aTransformer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        aTransformer);
    return result;
}

LPDISPATCH IObjectTransformerCollection::Item(long Index)
{
    LPDISPATCH result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
        Index);
    return result;
}

BOOL IObjectTransformerCollection::Update(BOOL dropAfterMove)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        dropAfterMove);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IObjectTransformer properties

/////////////////////////////////////////////////////////////////////////////
// IObjectTransformer operations

void IObjectTransformer::SetMatrix(const VARIANT& newValue)
{
    static BYTE parms[] =
        VTS_VARIANT;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         &newValue);
}

VARIANT IObjectTransformer::GetMatrix()
{
    VARIANT result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void IObjectTransformer::SetObject3D(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

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


/////////////////////////////////////////////////////////////////////////////
// IShape properties

/////////////////////////////////////////////////////////////////////////////
// IShape operations

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

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

void IShape::SetDeletable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IShape::GetDeletable()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IShape::SetMoveable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IShape::GetMoveable()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IShape::SetSelectable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IShape::GetSelectable()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IShape::SetSelected(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

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

void IShape::SetSnapable(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IShape::GetSnapable()
{
    BOOL result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IShape::SetUserData(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IShape::GetUserData()
{
    long result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

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

void IShape::EnableUpdate(BOOL enabled)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         enabled);
}

long IShape::GetLayer()
{
    long result;
    InvokeHelper(0xd, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

void IShape::Refresh()
{
    InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IShape::SetLayer(long newLayer)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        newLayer);
    return result;
}

void IShape::SetMarks(short markerType, BOOL withLines)
{
    static BYTE parms[] =
        VTS_I2 VTS_BOOL;
    InvokeHelper(0x10, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         markerType, withLines);
}

void IShape::ZOrder(short pos)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         pos);
}

void IShape::SetAngle(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetAngle()
{
    float result;
    InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IShape::SetBackColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IShape::GetBackColor()
{
    long result;
    InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IShape::SetBackStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IShape::GetBackStyle()
{
    short result;
    InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IShape::SetBorderColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IShape::SetBorderStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IShape::SetBorderWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetBorderWidth()
{
    float result;
    InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IShape::SetDrawMode(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IShape::GetDrawMode()
{
    short result;
    InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IShape::SetFillColor(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

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

void IShape::SetFillStyle(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IShape::GetFillStyle()
{
    short result;
    InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IShape::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetHeight()
{
    float result;
    InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IShape::SetLeft(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetLeft()
{
    float result;
    InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IShape::SetShape(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

short IShape::GetShape()
{
    short result;
    InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void IShape::SetTop(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetTop()
{
    float result;
    InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

void IShape::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IShape::GetWidth()
{
    float result;
    InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IWindow properties

/////////////////////////////////////////////////////////////////////////////
// IWindow operations

float IWindow::GetArea()
{
    float result;
    InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IWindow::GetAreaFormula()
{
    CString result;
    InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IWindow::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IWindow::GetHeight()
{
    float result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long IWindow::GetId()
{
    long result;
    InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IWindow::SetLeftHung(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IWindow::GetLeftHung()
{
    BOOL result;
    InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IWindow::SetOpensInwards(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IWindow::GetOpensInwards()
{
    BOOL result;
    InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IWindow::SetParapetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IWindow::GetParapetHeight()
{
    float result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IWindow::GetRemark()
{
    CString result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

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

void IWindow::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IWindow::GetType()
{
    long result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

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

void IWindow::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IWindow::GetWidth()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

long IWindow::GetTextureCount()
{
    long result;
    InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IWindow::Delete()
{
    InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL IWindow::GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PDISPATCH VTS_PDISPATCH VTS_PR4 VTS_PR4;
    InvokeHelper(0x14, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        leftPolygon, rightPolygon, leftDepth, rightDepth);
    return result;
}

BOOL IWindow::GetPos(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IWindow::SetPos(float x, float y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_R4 VTS_R4;
    InvokeHelper(0x13, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IWindow::SetTexture(long Index, LPCTSTR TextureName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x16, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, TextureName);
    return result;
}

CString IWindow::GetTexture(long Index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x17, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// IRoofWindow properties

/////////////////////////////////////////////////////////////////////////////
// IRoofWindow operations

float IRoofWindow::GetArea()
{
    float result;
    InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

CString IRoofWindow::GetAreaFormula()
{
    CString result;
    InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoofWindow::SetHeight(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IRoofWindow::GetHeight()
{
    float result;
    InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

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

long IRoofWindow::GetId()
{
    long result;
    InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoofWindow::SetOpensInwards(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofWindow::GetOpensInwards()
{
    BOOL result;
    InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

CString IRoofWindow::GetRemark()
{
    CString result;
    InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IRoofWindow::SetRightHung(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IRoofWindow::GetRightHung()
{
    BOOL result;
    InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

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

void IRoofWindow::SetType(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IRoofWindow::GetType()
{
    long result;
    InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IRoofWindow::SetWidth(float newValue)
{
    static BYTE parms[] =
        VTS_R4;
    InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

float IRoofWindow::GetWidth()
{
    float result;
    InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
    return result;
}

long IRoofWindow::GetTextureCount()
{
    long result;
    InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

BOOL IRoofWindow::GetPos2D(float* x, float* y)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4;
    InvokeHelper(0xe, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y);
    return result;
}

BOOL IRoofWindow::GetPos3D(float* x, float* y, float* z)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PR4 VTS_PR4 VTS_PR4;
    InvokeHelper(0xf, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        x, y, z);
    return result;
}

BOOL IRoofWindow::SetTexture(long Index, LPCTSTR TextureName)
{
    BOOL result;
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x11, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        Index, TextureName);
    return result;
}

CString IRoofWindow::GetTexture(long Index)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x12, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        Index);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// ICutView properties

/////////////////////////////////////////////////////////////////////////////
// ICutView operations

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