The Houseplan Collection/HRCD2005.ISO/data1.cab/Zusatz/3DS/DATA2.Z/acconn.h

C/C++ Source or Header | 1999-04-28 | 100KB | 3,074 lines

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

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

// Attributes
public:

// Operations
public:
    void ProgramExit();
    void LoadDialog(long dialogID, long ArConDlgToken, LPDISPATCH dialogObject);
    void EndDialog(long dialogID, BOOL ok);
    void ExecuteMenuItem(long menuId);
    void GotOneClick(BOOL valid, float x, float y, long id);
    void ButtonChange(long btnId, long evnt, long selectedIndex, BOOL pressed, BOOL visible, BOOL enabled);
    void HowMove(long btnId, float x, float y, long viewHandle);
    void HowInput(long btnId, float x, float y, float dirX, float dirY, long state, LPDISPATCH CutView);
    void SaveDialogDefaults(long dlgId, long token);
    void DialogActivation(long dlgId, long ArConDlgToken, long subObjectCount, BOOL activated);
    void LoadComplete(BOOL successfull);
    void LoadBuilding(LPDISPATCH aBuilding, long SaveNo);
    void LoadStart();
    void SaveStart(LPCTSTR FileName, long NumBuildings, BOOL isAutoSave, long* numChunksToSave);
    void SaveBuilding(long BuildingNo, LPDISPATCH aBuilding);
    void HowSnap(long btnId, float x, float y, long viewHandle, float snapDistance);
    void HowStatusLineRedraw(long btnId, float x, float y, long viewHandle);
    void ProjectClosed();
    void Graphics2DDoubleClick(LPDISPATCH obj);
    void Graphics2DSelectionChanged(LPDISPATCH obj, float x, float y, BOOL selected, BOOL extended, BOOL hasAlreadyBeenSelected, float pixelScale, long snapRadius);
    void Graphics2DDeleted(LPDISPATCH obj, BOOL* allowDelete);
    void Graphics2DMove(LPDISPATCH obj, float x, float y, long viewHandle);
    void Graphics2DEndMoving(LPDISPATCH obj, BOOL aborted, BOOL extended, BOOL copied);
    void NewCurrentProject();
    void Graphics2DStartMoving(LPDISPATCH obj, float x, float y, float pixelFactor, BOOL extended, long markerIndex, BOOL* allowMove);
    void InputModeChanged(long newMode);
    void ProjectChange();
    void ChangeNotify(LPDISPATCH obj, long events);
    void Object3DDoubleClicked(LPDISPATCH obj3D, LPDISPATCH obj2D, BOOL* redrawObject, BOOL* redrawAll);
    void TextureDropped(LPDISPATCH obj2D, LPDISPATCH obj3D, long matIndex, LPDISPATCH objTexture, LPCTSTR droppedTextureName, float x, float y, float z, BOOL* redraw, BOOL* redrawWholeScene, BOOL* autoExchangeTexture);
    void Graphics2DStoryHeightsChanged(LPDISPATCH obj2D);
    void Graphics2DObjectTransform(LPDISPATCH obj2D, VARIANT* matrix);
    void RoofDoubleClicked(BOOL* showDialog);
    void UserPanelAdjustSize(long ButtonInfo, long* width, long* height, BOOL* ok);
    void UserPanelPosChanged(long ButtonInfo, long left, long top, long right, long bottom);
    void UserPanelRightClicked(long ButtonInfo);
    void ExternalViewsVisibilityChanged(long newVisibility);
};
/////////////////////////////////////////////////////////////////////////////
// IArCon wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAllFloorsVisible(BOOL bNewValue);
    BOOL GetAllFloorsVisible();
    CString GetArConDirectory();
    long GetArConWindowHandle();
    BOOL GetAutoLoaded();
    long GetAvailableChimneys();
    long GetAvailableDoors();
    long GetAvailableGauben();
    long GetAvailableStairCases();
    long GetAvailableWindows();
    long GetAvailableWalls();
    long GetAvailableRoofWindows();
    long GetAvailableSupports();
    LPDISPATCH GetBuildings();
    long GetConstructedWindows();
    long GetConstructedRoofWindows();
    LPDISPATCH GetCurrentBuilding();
    LPDISPATCH GetCurrentProject();
    void SetCurrentStory(LPDISPATCH newValue);
    LPDISPATCH GetCurrentStory();
    LPDISPATCH GetCuts();
    LPDISPATCH GetDesignObjectConstructors();
    LPDISPATCH GetDesignObjects();
    LPDISPATCH GetDimensions();
    LPDISPATCH GetGlobalTerrain();
    LPDISPATCH GetGraphics2D();
    LPDISPATCH GetGuides();
    long GetInternalMode();
    LPDISPATCH GetLabelings();
    void SetMode(long nNewValue);
    long GetMode();
    void SetMultiUserMode(long nNewValue);
    long GetMultiUserMode();
    BOOL GetRunning();
    LPDISPATCH GetRunningTool();
    long GetStartupMenuID();
    void SetState(long nNewValue);
    long GetState();
    LPDISPATCH GetTerrains();
    CString GetProgramName();
    long GetProgramVersion();
    long GetProgramTypeID();
    long GetProgramProperties();
    void AttachDialog(long ArConDlg, long hWnd, long icon, long helpContext, BOOL isActive, BOOL exclusive);
    BOOL CloseProject();
    LPDISPATCH CreateBuilding(short initialFloorType);
    long CreateMenuItem(long parentMenu, long beforeId, LPCTSTR Name, LPCTSTR description, long modes, long picture, long helpId);
    long CreateMenuSeparator(long menu, long before, long modes);
    void CreateProject(LPDISPATCH aProject);
    long DefButton(const VARIANT& pic, long Info, LPCTSTR str, long helpId);
    long DefButtonRes(long id, LPCTSTR moduleFileName, long Info, LPCTSTR str, long helpId);
    long DefHowButton(long MultiButtonVariantID, const VARIANT& pic, long Info, LPCTSTR str, long helpId);
    long DefHowButtonRes(long MultiButtonVariantID, long id, LPCTSTR moduleFileName, long Info, LPCTSTR str, long helpId);
    long DefMultiButton(long Info);
    long DefMultiButtonVariant(long MultiButtonID, const VARIANT& pic, LPCTSTR str, long helpId);
    long DefMultiButtonVariantRes(long MultiButtonID, long id, LPCTSTR moduleFileName, LPCTSTR str, long helpId);
    BOOL DeleteButton(long btnId);
    CString DoorName(long DoorTypeIndex);
    CString WallName(long WallType);
    BOOL DragEnd(long x, long y, BOOL canceld);
    void DragMove(long x, long y);
    void DragRButtonPressed(long x, long y, BOOL down);
    BOOL DragTextureStart(LPCTSTR FileName);
    BOOL EnableMenuItem(long id, BOOL doEnable);
    BOOL EndArCon();
    void EndMe();
    BOOL EndModalDialog();
    BOOL GetButtonState(long btnId, long* selected, BOOL* pressed, BOOL* visible, BOOL* enabled);
    LPDISPATCH GetDefaultCeiling();
    LPDISPATCH GetDefaultChimney(long Type);
    LPDISPATCH GetDefaultDimension();
    LPDISPATCH GetDefaultDoor(long Type);
    LPDISPATCH GetDefaultGuide();
    LPDISPATCH GetDefaultHedge(long Type);
    LPDISPATCH GetDefaultHole();
    LPDISPATCH GetDefaultLabeling();
    LPDISPATCH GetDefaultSupport(long Type);
    LPDISPATCH GetDefaultTerrain(long Type);
    LPDISPATCH GetDefaultUnterUeberzug(BOOL Ueberzug);
    LPDISPATCH GetDefaultWall(long Type);
    VARIANT GetDialogData(long token, long subObjectNo, long dataId);
    void GetOneClick(LPCTSTR message, const VARIANT& picture, long id);
    float GetTerrainHeight(float x, float y);
    LPDISPATCH GroupDesignObjects(LPCTSTR Name, long NumOfObjects, const VARIANT& ObjectArray);
    LPDISPATCH ImportFolie(long layer, BSTR* FileName, float* minX, float* minY, float* maxX, float* maxY);
    LPDISPATCH LoadObjectConstructor(LPCTSTR FileName, long Duration);
    BOOL LoadProject(LPCTSTR FileName);
    LPDISPATCH NewCeiling();
    LPDISPATCH NewCeilingOpening();
    LPDISPATCH NewChimney(long Type);
    LPDISPATCH NewDimension();
    LPDISPATCH NewDoor(long Type);
    LPDISPATCH NewGuide();
    LPDISPATCH NewHedge(long Type);
    LPDISPATCH newHole();
    LPDISPATCH NewHolePolygon(LPDISPATCH Points);
    LPDISPATCH NewImage(long layer);
    LPDISPATCH NewLabel(long layer);
    LPDISPATCH NewLabeling();
    LPDISPATCH NewLine(long layer);
    LPDISPATCH NewMaterial();
    LPDISPATCH NewObjectConstructor(float epsilon, float sharpAngle);
    LPDISPATCH NewObjectTransformerCollection();
    LPDISPATCH NewPoint2DCollection();
    LPDISPATCH NewPolygon2D(long layer);
    LPDISPATCH NewProject();
    LPDISPATCH NewRoof();
    LPDISPATCH NewShape(long layer);
    LPDISPATCH NewStairCase();
    LPDISPATCH NewSupport(long Type);
    LPDISPATCH NewTerrain(long Type);
    LPDISPATCH NewTexture();
    LPDISPATCH NewTextureCollection(long numElements);
    LPDISPATCH NewUnterUeberzug(BOOL Ueberzug);
    LPDISPATCH NewWall(long Type);
    LPDISPATCH NewWindow(long Type);
    BOOL PlaceTerrain(LPDISPATCH aTerrain, LPDISPATCH aPolygon);
    BOOL ReadChunk(long ChunkID, LPCTSTR FileName);
    void Redraw3DViews();
    BOOL RemoveAnyMenuItem(long id);
    BOOL RemoveMenuItem(long id);
    BOOL SaveProject(BOOL mayAskForName);
    BOOL SaveProjectAs(LPCTSTR FileName);
    BOOL SetButtonState(long btnId, long selectedIndex, BOOL pressed, BOOL visible, BOOL enabled);
    BOOL SetDialogData(long token, long subObjectNo, long dataId, const VARIANT& value);
    void SetInputMode(long newMode);
    void SetProgressbarSubTitle(LPCTSTR subTitle);
    void SetProgressbarValue(long percent);
    void SetStatusText(LPCTSTR msg);
    BOOL SetTerrainHeight(float x, float y, float height);
    BOOL ShowAll();
    BOOL StartMe(long hWnd, LPCTSTR helpFileName);
    BOOL StartModalDialog(long hWnd);
    void StartProgressbar(LPCTSTR title, long percent);
    void StopProgressbar();
    CString WindowName(long WindowTypeIndex);
    CString RoofWindowName(long WindowTypeIndex);
    BOOL WriteChunk(long ChunkID, LPCTSTR FileName);
    BOOL NotifyOnChange(LPDISPATCH anyObject, long events);
    CString GetStairCaseName(long typeIndex);
    CString GetRoofWindowName(long typeIndex);
    CString GetChimneyName(long typeIndex);
    CString GetSupportName(long typeIndex);
    CString GetWindowName(long typeIndex);
    CString GetDoorName(long typeIndex);
    LPDISPATCH NewRoofConstruction();
    void ShowWaitCursor(BOOL Hourglass);
    CString GetGaubenName(long typeIndex);
    void GetGaubenConstructionRange(long typeIndex, long* minConturPoints, long* maxConturPoints);
    BOOL CloseDialog(long ArConDlgToken, BOOL withOK);
    BOOL ShowMenu(long Mode, BOOL showIt);
    BOOL ShowPanel(long panel, BOOL showIt);
    BOOL ShowAllButtonsInPanel(long panel, BOOL visible);
    BOOL EnableAllButtonsInPanel(long panel, BOOL enabled);
    BOOL ShowButtonByID(long panel, long id, long SubID, BOOL visible);
    BOOL EnableButtonByID(long panel, long id, long SubID, BOOL enabled);
    BOOL StartMe2(long hWnd, LPCTSTR helpFileName, BOOL hidden, long ParentWindow);
    long CreateUserPanel(long position, long helpId, BOOL visible, BOOL enabled);
    BOOL DestroyUserPanel(long ButtonInfo);
    BOOL SetUserPanelState(long ButtonInfo, BOOL visible, BOOL enabled);
    LPDISPATCH NewVirtualWall();
    void UpdateWindowPos();
    LPDISPATCH NewRoofWindow(long Type);
    void SetParentWindow(long ParentWindow);
    BOOL LoadTextureDialog(long ParentWindow, LPCTSTR Caption, BSTR* FileName, BSTR* Directory);
    BOOL LoadObjectDialog(long ParentWindow, LPCTSTR Caption, BOOL Objects, BOOL groups, BSTR* FileName, BSTR* Directory);
    LPDISPATCH NewProjectPreview(LPCTSTR FileName);
    BOOL LoadProjectDialog(long ParentWindow, LPCTSTR Caption, BSTR* FileName, BSTR* Directory);
    LPDISPATCH NewPolygonWendelConstruction();
    long AvailablePfostenObjects();
    CString GetPfostenObject(long Index);
    CString GetPfostenBeschreibung(long Index);
    CString GetFileNameOfLoadingProject();
    BOOL GetOnlySomeBuildingsLoading();
    LPDISPATCH NewPrintSettings();
    LPDISPATCH NewSavePictureSettings();
    LPDISPATCH Views();
    LPDISPATCH ThePrintSettings();
    LPDISPATCH TheSavePictureSettings();
    LPDISPATCH TheZoomSettings();
    LPDISPATCH TheWalkSettings();
    LPDISPATCH ActiveView();
    long AvailableExternalViews();
    long ActiveExternalViews();
    void SetExternalViews(long newVal);
    long GetExternalViewDockMode(long viewFlag);
    BOOL SetExternalViewDockMode(long viewFlag, long DockMode, long screenLeft, long screenTop, long screenBottom, long screeRight);
    BOOL VRDeviceAvailable();
    BOOL SpaceMouseAvailable();
    long PredefinedViewing3DCount();
    BOOL GetPredefinedViewing3D(long Index, BSTR* description, float* VRPx, float* VRPy, float* VRPz, float* EyeX, float* EyeY, float* EyeZ, float* tanViewAngleHalf);
    long AddPredefinedViewing3D(LPCTSTR description, float VRPx, float VRPy, float VRPz, float EyeX, float EyeY, float EyeZ, float tanViewAngleHalf);
    BOOL DeletePredefinedViewing3D(long Index);
    BOOL RenamePredefinedViewing3D(long Index, LPCTSTR newDescription);
    BOOL ChangePredefinedViewing3D(long Index, float VRPx, float VRPy, float VRPz, float EyeX, float EyeY, float EyeZ, float tanViewAngleHalf);
};
/////////////////////////////////////////////////////////////////////////////
// IBuildingCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IBuilding wrapper class

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

// Attributes
public:

// Operations
public:
    float GetArea();
    LPDISPATCH GetHistory();
    long GetId();
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
    void SetRemark(LPCTSTR lpszNewValue);
    CString GetRemark();
    void SetRotation(float newValue);
    float GetRotation();
    LPDISPATCH GetStories();
    float GetVolume();
    LPDISPATCH CreateStory(BOOL aboveCurrent, short floorType);
    void Delete();
    BOOL 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 Move(float dx, float dy, BOOL canUndo);
    BOOL Rotate(float PivotX, float PivotY, float Angle, BOOL canUndo);
    BOOL Mirror(float x0, float y0, float dx, float dy, BOOL canUndo);
};
/////////////////////////////////////////////////////////////////////////////
// IIDHistory wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCurrentID();
    LPDISPATCH GetParentObject();
    long GetPreviousID();
    CString GetPreviousProjectName();
    BOOL GetRecentlyLoaded();
};
/////////////////////////////////////////////////////////////////////////////
// IStoryCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IStory wrapper class

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

// Attributes
public:

// Operations
public:
    void SetBaseHeight(float newValue);
    float GetBaseHeight();
    float GetBruttoGeschossflaeche();
    CString GetBruttoGeschossflaechenFormel();
    float GetBruttoRauminhalt();
    CString GetBruttoRauminhaltsFormel();
    LPDISPATCH GetBuilding();
    LPDISPATCH GetCeilingOpenings();
    LPDISPATCH GetCeilings();
    LPDISPATCH GetChimneys();
    LPDISPATCH GetConturs();
    void SetDistanceStoryBelow(float newValue);
    float GetDistanceStoryBelow();
    void SetFussboden(float newValue);
    float GetFussboden();
    LPDISPATCH GetGraphics2D();
    LPDISPATCH GetHistory();
    long GetId();
    void SetLichteHoehe(float newValue);
    float GetLichteHoehe();
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
    void SetPlasterName(LPCTSTR lpszNewValue);
    CString GetPlasterName();
    void SetPlasterThickness(float newValue);
    float GetPlasterThickness();
    void SetRemark(LPCTSTR lpszNewValue);
    CString GetRemark();
    void SetRohdecke(float newValue);
    float GetRohdecke();
    LPDISPATCH GetRoofs();
    LPDISPATCH GetRooms();
    LPDISPATCH GetStairs();
    LPDISPATCH GetSupports();
    LPDISPATCH GetUnterUeberzuege();
    void SetUnterbau(float newValue);
    float GetUnterbau();
    LPDISPATCH GetWalls();
    LPDISPATCH GetVirtualWalls();
    LPDISPATCH GetGauben();
    LPDISPATCH FindChimney(float x, float y);
    LPDISPATCH FindRoom(float x, float y);
    LPDISPATCH FindSupport(float x, float y);
    LPDISPATCH FindUnterUeberzug(float x, float y);
    LPDISPATCH FindWall(float x, float y);
    BOOL Label(LPDISPATCH aLabeling, float x, float y);
    BOOL PlaceCeiling(LPDISPATCH aCeiling, LPDISPATCH aPolygon);
    BOOL PlaceCeilingOpening(LPDISPATCH opening, LPDISPATCH aPolygon);
    BOOL PlaceChimney(LPDISPATCH aChimney, float x, float y);
    BOOL PlaceDimension(LPDISPATCH aDimension, float x1, float y1, float x2, float y2);
    BOOL PlaceGuide(LPDISPATCH aGuide, float x1, float y1, float x2, float y2);
    BOOL PlaceRoof(LPDISPATCH aRoof, LPDISPATCH aPolygon, BOOL withDialog);
    BOOL PlaceRoofAutomatic(LPDISPATCH aRoof, float x, float y, BOOL withDialog);
    BOOL PlaceStairCase(LPDISPATCH stair, BOOL withDialog);
    BOOL PlaceSupport(LPDISPATCH aSupport, float x, float y);
    BOOL PlaceUnterUeberzug(LPDISPATCH UnterUeberzug, float x1, float y1, float x2, float y2, float X3, float Y3, float x4, float y4);
    BOOL PlaceWall(LPDISPATCH aWall, float x1, float y1, float x2, float y2);
    BOOL PlaceVirtualWall(LPDISPATCH aWall, float x1, float y1, float x2, float y2);
    BOOL Delete();
};
/////////////////////////////////////////////////////////////////////////////
// ICeilingOpeningsCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ICeilingOpening wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetHistory();
    long GetId();
    void SetPolygon(LPDISPATCH newValue);
    LPDISPATCH GetPolygon();
    void Delete();
};
/////////////////////////////////////////////////////////////////////////////
// IPolygon2D wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
    void SetBackColor(long nNewValue);
    long GetBackColor();
    void SetBackStyle(short nNewValue);
    short GetBackStyle();
    void SetBorderColor(long nNewValue);
    long GetBorderColor();
    void SetBorderStyle(short nNewValue);
    short GetBorderStyle();
    void SetBorderWidth(float newValue);
    float GetBorderWidth();
    void SetClosed(BOOL bNewValue);
    BOOL GetClosed();
    void SetDrawMode(short nNewValue);
    short GetDrawMode();
    void SetFillColor(long nNewValue);
    long GetFillColor();
    void SetFillStyle(short nNewValue);
    short GetFillStyle();
    LPDISPATCH GetPoints();
    void SetPoints(long numPoints, const VARIANT& Points);
};
/////////////////////////////////////////////////////////////////////////////
// IGraphics2DObject wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
};
/////////////////////////////////////////////////////////////////////////////
// IPoint2DCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    void Add(LPDISPATCH aPoint);
    void AddPoint(float x, float y);
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IPoint2D wrapper class

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

// Attributes
public:

// Operations
public:
    void SetX(float newValue);
    float GetX();
    void SetY(float newValue);
    float GetY();
};
/////////////////////////////////////////////////////////////////////////////
// ICut wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetGraphics2D();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetStory();
    BOOL GetReferenceLine(float* x1, float* y1, float* x2, float* y2);
};
/////////////////////////////////////////////////////////////////////////////
// IGraphics2DCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    BOOL Add(LPDISPATCH gr2DObj);
    void EnableUpdate(BOOL enabled);
    LPDISPATCH Item(long Index);
    BOOL Remove(LPDISPATCH gr2DObj);
    void Sort(BOOL increasingZOrder);
    void RemoveAll();
};
/////////////////////////////////////////////////////////////////////////////
// ICeilingCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ICeiling wrapper class

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

// Attributes
public:

// Operations
public:
    void SetEdgeTexture(LPDISPATCH newValue);
    LPDISPATCH GetEdgeTexture();
    LPDISPATCH GetHistory();
    long GetId();
    void SetLowerSurfaceTexture(LPDISPATCH newValue);
    LPDISPATCH GetLowerSurfaceTexture();
    void SetPolygon(LPDISPATCH newValue);
    LPDISPATCH GetPolygon();
    void SetUpperSurfaceTexture(LPDISPATCH newValue);
    LPDISPATCH GetUpperSurfaceTexture();
    LPDISPATCH GetOpenings();
    LPDISPATCH GetStory();
    void Delete();
};
/////////////////////////////////////////////////////////////////////////////
// ITexture wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAngle(float newValue);
    float GetAngle();
    void SetColor(long nNewValue);
    long GetColor();
    void SetHeight(float newValue);
    float GetHeight();
    void SetMixColorAndTexture(BOOL bNewValue);
    BOOL GetMixColorAndTexture();
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
    void SetUseOriginalSize(BOOL bNewValue);
    BOOL GetUseOriginalSize();
    void SetUseTexture(BOOL bNewValue);
    BOOL GetUseTexture();
    void SetWidth(float newValue);
    float GetWidth();
    void SetXRaport(float newValue);
    float GetXRaport();
    void SetYRaport(float newValue);
    float GetYRaport();
};
/////////////////////////////////////////////////////////////////////////////
// IChimneyCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IChimney wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAngle(float newValue);
    float GetAngle();
    void SetHeight(float newValue);
    float GetHeight();
    LPDISPATCH GetHistory();
    long GetId();
    CString GetRemark();
    LPDISPATCH GetStory();
    LPDISPATCH GetTexture();
    void SetThickness(float newValue);
    float GetThickness();
    void SetToCeiling(BOOL bNewValue);
    BOOL GetToCeiling();
    void SetType(long nNewValue);
    long GetType();
    void SetWidth(float newValue);
    float GetWidth();
    void Delete();
    BOOL GetPos(float* x, float* y);
    BOOL SetPos(float x, float y);
};
/////////////////////////////////////////////////////////////////////////////
// IConturCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IContur wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL GetInner();
    LPDISPATCH GetRoom();
    LPDISPATCH GetWallSegments();
};
/////////////////////////////////////////////////////////////////////////////
// IRoom wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAngle(long nNewValue);
    long GetAngle();
    float GetBodenflaeche();
    CString GetBodenflaechenFormel();
    LPDISPATCH GetChimneys();
    LPDISPATCH GetConturs();
    float GetDeckenflaeche();
    CString GetDeckenflaechenFormel();
    void SetFlags(long nNewValue);
    long GetFlags();
    void SetFont(const VARIANT& newValue);
    VARIANT GetFont();
    LPDISPATCH GetHistory();
    long GetId();
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
    float GetNettoDeckenflaeche();
    CString GetNettoDeckenflaechenFormel();
    float GetNettoGrundflaeche();
    CString GetNettoGrundflaechenFormel();
    void SetNutzflaechenart(LPCTSTR lpszNewValue);
    CString GetNutzflaechenart();
    void SetOrdnungszahl(LPCTSTR lpszNewValue);
    CString GetOrdnungszahl();
    void SetPlasterName(LPCTSTR lpszNewValue);
    CString GetPlasterName();
    void SetPlasterThickness(float newValue);
    float GetPlasterThickness();
    void SetRemark(LPCTSTR lpszNewValue);
    CString GetRemark();
    LPDISPATCH GetStory();
    LPDISPATCH GetSupports();
    void SetUmschliessungsart(short nNewValue);
    short GetUmschliessungsart();
    float GetVolumen();
    CString GetVolumenFormel();
    LPDISPATCH GetFloorTexture();
    LPDISPATCH GetCeilingTexture();
    LPDISPATCH GetRoofAreas();
    BOOL AddHolePolygon(LPDISPATCH thePolygon, BOOL holeInCeiling);
    BOOL RemoveHolePolygon(LPDISPATCH thePolygon, BOOL holeInCeiling);
};
/////////////////////////////////////////////////////////////////////////////
// ISupportCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ISupport wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAngle(float newValue);
    float GetAngle();
    void SetHeight(float newValue);
    float GetHeight();
    LPDISPATCH GetHistory();
    long GetId();
    CString GetRemark();
    LPDISPATCH GetStory();
    LPDISPATCH GetTexture();
    void SetThickness(float newValue);
    float GetThickness();
    void SetToCeiling(BOOL bNewValue);
    BOOL GetToCeiling();
    void SetType(long nNewValue);
    long GetType();
    void SetWidth(float newValue);
    float GetWidth();
    void Delete();
    BOOL GetPos(float* x, float* y);
    BOOL SetPos(float x, float y);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofAreaCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofArea wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetTexture();
    BOOL GetVisible();
    void SetVisible(BOOL bNewValue);
    BOOL GetOutside();
    void SetOutside(BOOL bNewValue);
    LPDISPATCH GetRoof();
    LPDISPATCH GetRoom();
    LPDISPATCH GetHistory();
    long GetId();
    float GetArea();
    CString GetAreaFormula();
    LPDISPATCH GetWindows();
};
/////////////////////////////////////////////////////////////////////////////
// IRoof wrapper class

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

// Attributes
public:

// Operations
public:
    double GetDachSummeFirstlaenge();
    double GetDachSummeFlaeche();
    double GetDachSummeGratlaenge();
    double GetDachSummeKehlenlaenge();
    double GetDachSummeOrtganglaenge();
    double GetDachSummePultdachFirstlaenge();
    double GetDachSummeTrauflaenge();
    double GetFlaecheDerEindeckungUebermessen();
    double GetGaubenSummeFirstlaenge();
    double GetGaubenSummeFlaeche();
    double GetGaubenSummeGratlaenge();
    double GetGaubenSummeKehlenlaenge();
    double GetGaubenSummeOrtganglaenge();
    double GetGaubenSummePultdachFirstlaenge();
    double GetGaubenSummeTrauflaenge();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetPolygon();
    LPDISPATCH GetStory();
    double GetTotalSummeFirstlaenge();
    double GetTotalSummeFlaeche();
    double GetTotalSummeGratlaenge();
    double GetTotalSummeKehlenlaenge();
    double GetTotalSummeOrtganglaenge();
    double GetTotalSummePultdachFirstlaenge();
    double GetTotalSummeTrauflaenge();
    LPDISPATCH GetWindows();
    LPDISPATCH GetRoofAreas();
    LPDISPATCH GetGauben();
    LPDISPATCH GetConstruction();
    long GetTextureCount();
    void Delete();
    BOOL Edit();
    LPDISPATCH CreateGaube(long Type, LPDISPATCH Contur);
    LPDISPATCH GetWoodConstruction(BOOL collapse, float epsilon);
    BOOL SetTexture(long Index, LPCTSTR TextureName);
    CString GetTexture(long Index);
    BOOL PlaceWindow(LPDISPATCH aRoofWindow, float x, float y);
};
/////////////////////////////////////////////////////////////////////////////
// IWindowCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IGaubenCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IGaube wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetVertices();
    long GetType();
    LPDISPATCH GetStory();
    LPDISPATCH GetRoof();
    LPDISPATCH GetFrontWall();
    LPDISPATCH GetLeftWall();
    LPDISPATCH GetRightWall();
    LPDISPATCH GetHistory();
    long GetId();
    long GetTextureCount();
    BOOL SetTexture(long Index, LPCTSTR TextureName);
    CString GetTexture(long Index);
    double GetCursorAbstand();
    void SetCursorAbstand(double nVal, BOOL update);
    double GetSchnittNeigung();
    void SetSchnittNeigung(double nVal, BOOL update);
    double GetSchnittHoehe();
    void SetSchnittHoehe(double nVal, BOOL update);
    double GetSchnittTraufHoehe();
    void SetSchnittTraufHoehe(double nVal, BOOL update);
    double GetSchnittUeberstand();
    void SetSchnittUeberstand(double nVal, BOOL update);
    double GetWandDicke();
    void SetWandDicke(double nVal, BOOL update);
    double GetBreite();
    void SetBreite(double nVal, BOOL update);
    double GetBreiteOben();
    void SetBreiteOben(double nVal, BOOL update);
    double GetUeberstandLinks();
    void SetUeberstandLinks(double nVal, BOOL update);
    double GetUeberstandRechts();
    void SetUeberstandRechts(double nVal, BOOL update);
    double GetNeigungLinks();
    void SetNeigungLinks(double nVal, BOOL update);
    double GetNeigungRechts();
    void SetNeigungRechts(double nVal, BOOL update);
    double GetTraufHoehe();
    void SetTraufHoehe(double nVal, BOOL update);
    double GetStich();
    void SetStich(double nVal, BOOL update);
    double GetFluegelBreite();
    void SetFluegelBreite(double nVal, BOOL update);
    BOOL GetAufgesetzt();
    void SetAufgesetzt(BOOL nVal, BOOL update);
    BOOL GetAufgesetzteFluegel();
    void SetAufgesetzteFluegel(BOOL nVal, BOOL update);
    BOOL GetOeffnungBisDecke();
    void SetOeffnungBisDecke(BOOL nVal, BOOL update);
    BOOL GetDetailsUebernehmen();
    void SetDetailsUebernehmen(BOOL nVal, BOOL update);
    BOOL GetMitBlende();
    void SetMitBlende(BOOL nVal, BOOL update);
};
/////////////////////////////////////////////////////////////////////////////
// IWall wrapper class

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

// Attributes
public:

// Operations
public:
    float GetAverageArea();
    CString GetAverageAreaFormula();
    float GetAverageLength();
    LPDISPATCH GetDoors();
    LPDISPATCH GetHistory();
    LPDISPATCH GetHoles();
    long GetId();
    LPDISPATCH GetStory();
    LPDISPATCH GetTexture();
    void SetThickness(float newValue);
    float GetThickness();
    void SetType(long nNewValue);
    long GetType();
    LPDISPATCH GetWallSegments();
    LPDISPATCH GetWindows();
    LPDISPATCH GetVirtualWall();
    void Delete();
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2);
    BOOL SetPos(float x1, float y1, float x2, float y2);
    BOOL PlaceDoor(LPDISPATCH aDoor, float x, float y);
    BOOL PlaceHole(LPDISPATCH aHole, LPDISPATCH aPolygon, float x, float y);
    BOOL PlaceWindow(LPDISPATCH aWindow, float x, float y);
    BOOL PlaceWindow2(LPDISPATCH aWindow, float x, float y, BOOL MitGehrungLinks, BOOL MitGehrungRechts);
};
/////////////////////////////////////////////////////////////////////////////
// IDoorCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IDoor wrapper class

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

// Attributes
public:

// Operations
public:
    float GetArea();
    CString GetAreaFormula();
    void SetFrameTexture(LPDISPATCH newValue);
    LPDISPATCH GetFrameTexture();
    void SetHeight(float newValue);
    float GetHeight();
    LPDISPATCH GetHistory();
    void SetHungLeft(BOOL bNewValue);
    BOOL GetHungLeft();
    long GetId();
    LPDISPATCH GetLeftSegment();
    void SetLeftWingAngle(float newValue);
    float GetLeftWingAngle();
    void SetLeftWingTexture(LPDISPATCH newValue);
    LPDISPATCH GetLeftWingTexture();
    void SetLeftWingType(long nNewValue);
    long GetLeftWingType();
    void SetOpensInwards(BOOL bNewValue);
    BOOL GetOpensInwards();
    CString GetRemark();
    LPDISPATCH GetRightSegment();
    void SetRightWingAngle(float newValue);
    float GetRightWingAngle();
    void SetRightWingTexture(LPDISPATCH newValue);
    LPDISPATCH GetRightWingTexture();
    void SetRightWingType(long nNewValue);
    long GetRightWingType();
    void SetType(long nNewValue);
    long GetType();
    LPDISPATCH GetWall();
    void SetWidth(float newValue);
    float GetWidth();
    void Delete();
    BOOL GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth);
    BOOL GetPos(float* x, float* y);
    BOOL SetPos(float x, float y);
};
/////////////////////////////////////////////////////////////////////////////
// IWallSegment wrapper class

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

// Attributes
public:

// Operations
public:
    float GetArea();
    CString GetAreaFormula();
    LPDISPATCH GetContur();
    LPDISPATCH GetDoors();
    LPDISPATCH GetHistory();
    LPDISPATCH GetHoles();
    long GetId();
    LPDISPATCH GetLambdaHs();
    void SetMaterialFromBelow(BOOL bNewValue);
    BOOL GetMaterialFromBelow();
    LPDISPATCH GetRoom();
    LPDISPATCH GetTexture();
    long GetVisMode();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    LPDISPATCH GetWall();
    long GetWallSide();
    LPDISPATCH GetWindows();
    float GetZBottom();
    float GetZTop();
    BOOL AddHolePolygon(LPDISPATCH thePolygon);
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2);
    BOOL RemoveHolePolygon(LPDISPATCH thePolygon);
};
/////////////////////////////////////////////////////////////////////////////
// IHoleCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IHole wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetHistory();
    long GetId();
    void SetLeftAngle(float newValue);
    float GetLeftAngle();
    void SetLeftBase(float newValue);
    float GetLeftBase();
    void SetLeftHeight(float newValue);
    float GetLeftHeight();
    void SetLeftToTop(BOOL bNewValue);
    BOOL GetLeftToTop();
    void SetPolygon(LPDISPATCH newValue);
    LPDISPATCH GetPolygon();
    void SetRightAngle(float newValue);
    float GetRightAngle();
    void SetRightBase(float newValue);
    float GetRightBase();
    void SetRightHeight(float newValue);
    float GetRightHeight();
    void SetRightToTop(BOOL bNewValue);
    BOOL GetRightToTop();
    LPDISPATCH GetTexture();
    void SetWidth(float newValue);
    float GetWidth();
    void Delete();
    BOOL GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth);
    BOOL SetPos(float x, float y);
    BOOL GetPos(float* x, float* y);
    LPDISPATCH LeftSegment();
    LPDISPATCH RightSegment();
};
/////////////////////////////////////////////////////////////////////////////
// ILambdaHCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ILambdaH wrapper class

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

// Attributes
public:

// Operations
public:
    float GetHeight();
    float GetLambda();
};
/////////////////////////////////////////////////////////////////////////////
// IHolePolygon wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL AddHole(LPDISPATCH newHole);
    BOOL RemoveHole(LPDISPATCH removedHole);
};
/////////////////////////////////////////////////////////////////////////////
// IWallSegmentCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IVirtualWall wrapper class

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

// Attributes
public:

// Operations
public:
    void SetWithHoles(BOOL bNewValue);
    BOOL GetWithHoles();
    void SetThickness(float newValue);
    float GetThickness();
    void SetStyle(long nNewValue);
    long GetStyle();
    void SetColor(long nNewValue);
    long GetColor();
    LPDISPATCH GetStory();
    LPDISPATCH GetWall();
    long GetId();
    LPDISPATCH GetHistory();
    BOOL Delete();
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2);
    BOOL SetPos(float x1, float y1, float x2, float y2);
};
/////////////////////////////////////////////////////////////////////////////
// IWindow wrapper class

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

// Attributes
public:

// Operations
public:
    float GetArea();
    CString GetAreaFormula();
    void SetHeight(float newValue);
    float GetHeight();
    LPDISPATCH GetHistory();
    long GetId();
    void SetLeftHung(BOOL bNewValue);
    BOOL GetLeftHung();
    LPDISPATCH GetLeftSegment();
    void SetOpensInwards(BOOL bNewValue);
    BOOL GetOpensInwards();
    void SetParapetHeight(float newValue);
    float GetParapetHeight();
    CString GetRemark();
    LPDISPATCH GetRightSegment();
    void SetType(long nNewValue);
    long GetType();
    LPDISPATCH GetWall();
    void SetWidth(float newValue);
    float GetWidth();
    long GetTextureCount();
    void Delete();
    BOOL GetPolygons(LPDISPATCH* leftPolygon, LPDISPATCH* rightPolygon, float* leftDepth, float* rightDepth);
    BOOL GetPos(float* x, float* y);
    BOOL SetPos(float x, float y);
    BOOL SetTexture(long Index, LPCTSTR TextureName);
    CString GetTexture(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofConstruction wrapper class

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

// Attributes
public:

// Operations
public:
    double GetDickeEindeckung();
    void SetDickeEindeckung(double newValue);
    double GetDickeKonstruktion();
    void SetDickeKonstruktion(double newValue);
    double GetDachrinnenDurchmesser();
    void SetDachrinnenDurchmesser(double newValue);
    BOOL GetEindeckungTransparent();
    void SetEindeckungTransparent(BOOL bNewValue);
    BOOL GetDachHorizontalBegrenzen();
    void SetDachHorizontalBegrenzen(BOOL bNewValue);
    double GetSchnittHoehe();
    void SetSchnittHoehe(double newValue);
    BOOL GetMitDachrinne();
    void SetMitDachrinne(BOOL bNewValue);
    BOOL GetMitTraufDetails();
    void SetMitTraufDetails(BOOL bNewValue);
    long GetTraufDetailTyp();
    void SetTraufDetailTyp(long nNewValue);
    BOOL GetMitFirstSteinen();
    void SetMitFirstSteinen(BOOL bNewValue);
    BOOL GetPfettenKoepfeSichtbar();
    void SetPfettenKoepfeSichtbar(BOOL bNewValue);
    double GetSparrenKopfLaenge();
    void SetSparrenKopfLaenge(double newValue);
    double GetSparrenKopfTiefe();
    void SetSparrenKopfTiefe(double newValue);
    double GetGesimsHoeheStirn();
    void SetGesimsHoeheStirn(double newValue);
    double GetGesimsNeigungStirn();
    void SetGesimsNeigungStirn(double newValue);
    BOOL GetMitSparren();
    void SetMitSparren(BOOL bNewValue);
    BOOL GetMitKehlbalken();
    void SetMitKehlbalken(BOOL bNewValue);
    BOOL GetMitGratsparren();
    void SetMitGratsparren(BOOL bNewValue);
    BOOL GetMitFusspfetten();
    void SetMitFusspfetten(BOOL bNewValue);
    BOOL GetMitFirstpfetten();
    void SetMitFirstpfetten(BOOL bNewValue);
    double GetHoeheUKMittelpfetten();
    void SetHoeheUKMittelpfetten(double newValue);
    double GetHoeheUKKehlbalken();
    void SetHoeheUKKehlbalken(double newValue);
    double GetMaxSparrenAbstand();
    void SetMaxSparrenAbstand(double newValue);
    double GetAbstandOrtgangSparren();
    void SetAbstandOrtgangSparren(double newValue);
    double GetMaxUeberstandEindeckung();
    void SetMaxUeberstandEindeckung(double newValue);
    double GetSparrenBreite();
    void SetSparrenBreite(double newValue);
    double GetSparrenDicke();
    void SetSparrenDicke(double newValue);
    double GetKehlbalkenBreite();
    void SetKehlbalkenBreite(double newValue);
    double GetKehlbalkenDicke();
    void SetKehlbalkenDicke(double newValue);
    double GetGratsparrenBreite();
    void SetGratsparrenBreite(double newValue);
    double GetGratsparrenDicke();
    void SetGratsparrenDicke(double newValue);
    double GetFusspfettenBreite();
    void SetFusspfettenBreite(double newValue);
    double GetFusspfettenDicke();
    void SetFusspfettenDicke(double newValue);
    double GetMittelpfettenBreite();
    void SetMittelpfettenBreite(double newValue);
    double GetMittelpfettenDicke();
    void SetMittelpfettenDicke(double newValue);
    double GetFirstpfettenBreite();
    void SetFirstpfettenBreite(double newValue);
    double GetFirstpfettenDicke();
    void SetFirstpfettenDicke(double newValue);
    double GetKehlbohlenBreite();
    void SetKehlbohlenBreite(double newValue);
    double GetKehlbohlenDicke();
    void SetKehlbohlenDicke(double newValue);
    CString GetFehler();
    BOOL GetMitMittelpfetten();
    void SetMitMittelpfetten(BOOL bNewValue);
    LPDISPATCH CreateRoof(LPDISPATCH aStory);
    BOOL SetzeAnzahlKonturPunkte(long AnzahlSeiten);
    BOOL SetzeKonturPunkt(long seite, double x, double y);
    BOOL SetzeUeberstand(long seite, double ueberstand);
    BOOL SetzeAnzahlKnicke(long seite, long anzahlKnicke);
    BOOL SetzeKnickNeigung(long seite, long knick, double neigung);
    BOOL SetzeKnickHoehe(long seite, long knick, double hoehe);
    BOOL HoleAnzahlKonturPunkte(long* AnzahlSeiten);
    BOOL HoleKonturPunkt(long seite, double* x, double* y);
    BOOL HoleUeberstand(long seite, double* ueberstand);
    BOOL HoleAnzahlKnicke(long seite, long* anzahlKnicke);
    BOOL HoleKnickNeigung(long seite, long knick, double* neigung);
    BOOL HoleKnickHoehe(long seite, long knick, double* hoehe);
    long GetAnzahlFlaechen();
    long GetFlaechenTyp(long Index);
    double GetFlaechenNeigung(long Index);
    double GetFlaechenRichtung(long Index);
    long GetFlaechenVater(long Index);
    long GetAnzahlKanten(long Index);
    long GetDachkantenTyp(long Index, long kantenIndex);
    BOOL GetDachkanteAktiv(long Index, long kantenIndex);
    long GetDachkantenNachbarflaeche(long Index, long kantenIndex);
    BOOL GetDachkantenPunktAnfang(long Index, long kantenIndex, float* x, float* y, float* z);
    BOOL GetDachkantenPunktEnde(long Index, long kantenIndex, float* x, float* y, float* z);
    long GetPfettenKopfTyp();
    void SetPfettenKopfTyp(long nVal);
    BOOL BeginNewArea(long typeOfArea);
    BOOL AddPoint(double x, double y, double z);
    BOOL Analyze(BOOL autoClosure);
    BOOL NewRafter(long typeOfRafter, LPCTSTR Name, double width, double Thickness);
    BOOL RafterSetGeo(long flag, double x, double y, double z);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofWoodCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
    void Sort(long criteria);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofWood wrapper class

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

// Attributes
public:

// Operations
public:
    long GetType();
    long GetNumber();
    float GetWidth();
    float GetHeight();
    float GetLength();
};
/////////////////////////////////////////////////////////////////////////////
// IRoofWindow wrapper class

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

// Attributes
public:

// Operations
public:
    float GetArea();
    CString GetAreaFormula();
    void SetHeight(float newValue);
    float GetHeight();
    LPDISPATCH GetHistory();
    long GetId();
    void SetOpensInwards(BOOL bNewValue);
    BOOL GetOpensInwards();
    CString GetRemark();
    void SetRightHung(BOOL bNewValue);
    BOOL GetRightHung();
    LPDISPATCH GetRoof();
    void SetType(long nNewValue);
    long GetType();
    void SetWidth(float newValue);
    float GetWidth();
    long GetTextureCount();
    BOOL GetPos2D(float* x, float* y);
    BOOL GetPos3D(float* x, float* y, float* z);
    BOOL SetTexture(long Index, LPCTSTR TextureName);
    CString GetTexture(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IRoofCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IRoomCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IStairCaseCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IStairCase wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetStory();
    void SetType(long nNewValue);
    long GetType();
    void SetX1(float newValue);
    float GetX1();
    void SetX2(float newValue);
    float GetX2();
    void SetX3(float newValue);
    float GetX3();
    void SetY1(float newValue);
    float GetY1();
    void SetY2(float newValue);
    float GetY2();
    void SetY3(float newValue);
    float GetY3();
    float GetLaufLaenge();
    float GetLaufBreiteAussen();
    float GetLaufPlattenDicke();
    float GetHoehe();
    float GetAuftrittsBreite();
    float GetSteigung();
    float GetGelaenderLaengeLinks();
    float GetGelaenderLaengeRechts();
    float GetGelaenderHoeheLinks();
    float GetGelaenderHoeheRechts();
    long GetTextureCount();
    void Delete();
    BOOL Edit();
    BOOL SetTexture(long Index, LPCTSTR TextureName);
    CString GetTexture(long Index);
    LPDISPATCH GetPolygonWendelConstruction();
};
/////////////////////////////////////////////////////////////////////////////
// IPolygonWendelConstruction wrapper class

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

// Attributes
public:

// Operations
public:
    void SetBauart(long nNewValue);
    long GetBauart();
    void SetAchslage(long nNewValue);
    long GetAchslage();
    void SetLaufBreiteAussen(float newValue);
    float GetLaufBreiteAussen();
    void SetAnzahlSteigungen(long nNewValue);
    long GetAnzahlSteigungen();
    void SetNiveauAmAntritt(float newValue);
    float GetNiveauAmAntritt();
    void SetHoehe(float newValue);
    float GetHoehe();
    void SetWinkelAmAntritt(float newValue);
    float GetWinkelAmAntritt();
    void SetWinkelAmAustritt(float newValue);
    float GetWinkelAmAustritt();
    void SetMitSetzStufen(BOOL bNewValue);
    BOOL GetMitSetzStufen();
    void SetSchrittMassOptimieren(BOOL bNewValue);
    BOOL GetSchrittMassOptimieren();
    float GetLaufLaenge();
    float GetAuftrittsBreite();
    void SetMitGelaenderLinks(BOOL bNewValue);
    BOOL GetMitGelaenderLinks();
    void SetMitGelaenderRechts(BOOL bNewValue);
    BOOL GetMitGelaenderRechts();
    void SetGelaenderBauart(long nNewValue);
    long GetGelaenderBauart();
    void SetHandlaufQuerschnitt(long nNewValue);
    long GetHandlaufQuerschnitt();
    void SetHandlaufDurchmesser(float newValue);
    float GetHandlaufDurchmesser();
    void SetHandlaufBreite(float newValue);
    float GetHandlaufBreite();
    void SetHandlaufDicke(float newValue);
    float GetHandlaufDicke();
    void SetHandlaufHoehe(float newValue);
    float GetHandlaufHoehe();
    void SetHandlaufMitKnicken(BOOL bNewValue);
    BOOL GetHandlaufMitKnicken();
    void SetMaximaleAuslenkungLinks(float newValue);
    float GetMaximaleAuslenkungLinks();
    void SetMaximaleAuslenkungRechts(float newValue);
    float GetMaximaleAuslenkungRechts();
    void SetFusslaufBreite(float newValue);
    float GetFusslaufBreite();
    void SetFusslaufDicke(float newValue);
    float GetFusslaufDicke();
    void SetMittlererFusslaufAbstand(float newValue);
    float GetMittlererFusslaufAbstand();
    void SetStabQuerschnitt(long nNewValue);
    long GetStabQuerschnitt();
    void SetStabDurchmesser(float newValue);
    float GetStabDurchmesser();
    void SetStabBreite(float newValue);
    float GetStabBreite();
    void SetStabDicke(float newValue);
    float GetStabDicke();
    void SetStabMaximalerAbstand(float newValue);
    float GetStabMaximalerAbstand();
    void SetPfostenQuerschnitt(long nNewValue);
    long GetPfostenQuerschnitt();
    void SetPfostenDurchmesser(float newValue);
    float GetPfostenDurchmesser();
    void SetPfostenBreite(float newValue);
    float GetPfostenBreite();
    void SetPfostenDicke(float newValue);
    float GetPfostenDicke();
    void SetPfostenLaenge(float newValue);
    float GetPfostenLaenge();
    void SetPfostenObjektName(LPCTSTR lpszNewValue);
    CString GetPfostenObjektName();
    LPDISPATCH GetPolygon();
    void SetPolygon(LPDISPATCH nVal);
    LPDISPATCH CreateStairCase(long TreppenTyp);
};
/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzugCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IUnterUeberzug wrapper class

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

// Attributes
public:

// Operations
public:
    void SetDeckelTextur(LPDISPATCH newValue);
    LPDISPATCH GetDeckelTextur();
    void SetHeight(float newValue);
    float GetHeight();
    void SetLength(float newValue);
    float GetLength();
    void SetSchraffur(long nNewValue);
    long GetSchraffur();
    void SetSchraffurFarbe(long nNewValue);
    long GetSchraffurFarbe();
    void SetSeg1LinienFarbe(long nNewValue);
    long GetSeg1LinienFarbe();
    void SetSeg1LinienTyp(long nNewValue);
    long GetSeg1LinienTyp();
    void SetSeg1Textur(LPDISPATCH newValue);
    LPDISPATCH GetSeg1Textur();
    void SetSeg2LinienFarbe(long nNewValue);
    long GetSeg2LinienFarbe();
    void SetSeg2LinienTyp(long nNewValue);
    long GetSeg2LinienTyp();
    void SetSeg2Textur(LPDISPATCH newValue);
    LPDISPATCH GetSeg2Textur();
    void SetSeg3LinienFarbe(long nNewValue);
    long GetSeg3LinienFarbe();
    void SetSeg3LinienTyp(long nNewValue);
    long GetSeg3LinienTyp();
    void SetSeg3Textur(LPDISPATCH newValue);
    LPDISPATCH GetSeg3Textur();
    void SetSeg4LinienFarbe(long nNewValue);
    long GetSeg4LinienFarbe();
    void SetSeg4LinienTyp(long nNewValue);
    long GetSeg4LinienTyp();
    void SetSeg4Textur(LPDISPATCH newValue);
    LPDISPATCH GetSeg4Textur();
    LPDISPATCH GetStory();
    void SetThickness(float newValue);
    float GetThickness();
    void SetUeberzug(BOOL bNewValue);
    BOOL GetUeberzug();
    LPDISPATCH GetHistory();
    long GetId();
    BOOL Delete();
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2, float* X3, float* Y3, float* x4, float* y4);
    BOOL SetPos(float x1, float y1, float x2, float y2, float X3, float Y3, float x4, float y4);
};
/////////////////////////////////////////////////////////////////////////////
// IWallCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IVirtualWallCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ILabeling wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAngle(float newValue);
    float GetAngle();
    void SetColor(long nNewValue);
    long GetColor();
    void SetFont(const VARIANT& newValue);
    VARIANT GetFont();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetStory();
    void SetText(LPCTSTR lpszNewValue);
    CString GetText();
    void Delete();
    BOOL GetPos(float* x1, float* y1);
    BOOL SetPos(float x1, float y1);
};
/////////////////////////////////////////////////////////////////////////////
// IDimension wrapper class

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

// Attributes
public:

// Operations
public:
    void SetArchitektengerecht(BOOL bNewValue);
    BOOL GetArchitektengerecht();
    void SetDecimals(short nNewValue);
    short GetDecimals();
    void SetDistance(float newValue);
    float GetDistance();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetStory();
    void SetType(short nNewValue);
    short GetType();
    void Delete();
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2);
    BOOL SetPos(float x1, float y1, float x2, float y2);
};
/////////////////////////////////////////////////////////////////////////////
// IGuide wrapper class

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

// Attributes
public:

// Operations
public:
    void SetColor(long nNewValue);
    long GetColor();
    void SetDrawStyle(short nNewValue);
    short GetDrawStyle();
    void SetEndless(BOOL bNewValue);
    BOOL GetEndless();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetStory();
    void Delete();
    BOOL GetPos(float* x1, float* y1, float* x2, float* y2);
    BOOL SetPos(float x1, float y1, float x2, float y2);
};
/////////////////////////////////////////////////////////////////////////////
// IProject wrapper class

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

// Attributes
public:

// Operations
public:
    void SetBackColorDay(long nNewValue);
    long GetBackColorDay();
    void SetBackColorNight(long nNewValue);
    long GetBackColorNight();
    CString GetName();
    void SetOriginX(float newValue);
    float GetOriginX();
    void SetOriginY(float newValue);
    float GetOriginY();
    void SetOriginZ(float newValue);
    float GetOriginZ();
    void SetPaperHeight(float newValue);
    float GetPaperHeight();
    void SetPaperSize(short nNewValue);
    short GetPaperSize();
    void SetPaperSizeName(LPCTSTR lpszNewValue);
    CString GetPaperSizeName();
    void SetPaperSizePrinter(short nNewValue);
    short GetPaperSizePrinter();
    void SetPaperWidth(float newValue);
    float GetPaperWidth();
    void SetScale(short nNewValue);
    short GetScale();
    CString GetShortName();
    void SetUnit(short nNewValue);
    short GetUnit();
    void SetWorldRotation(float newValue);
    float GetWorldRotation();
};
/////////////////////////////////////////////////////////////////////////////
// ICutCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IObjectConstructorCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IObjectConstructor wrapper class

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

// Attributes
public:

// Operations
public:
    long GetDuration();
    CString GetFileName();
    LPDISPATCH GetHistory();
    long GetId();
    LPDISPATCH GetObjects();
    CString GetRelativeFileName();
    void AddPolygonWithHoles(BOOL SharpEdges, LPDISPATCH mat, LPCTSTR TextureName);
    void AddQuadriliteral(long SharpEdges, LPDISPATCH mat, LPCTSTR TextureName);
    void AddTriangle(long SharpEdges, LPDISPATCH mat, LPCTSTR TextureName);
    LPDISPATCH Create(LPDISPATCH textureList, BOOL isRoomObject);
    BOOL Finish(LPCTSTR Name, BOOL storeInProject, long Duration);
    LPDISPATCH GetTextureCollection();
    void SetHoleContur(short holeIndex, short numPoints, const VARIANT& Points);
    void SetContur(short numPoints, const VARIANT& Points);
    void SetHolePoint(short holeIndex, short pointIndex, float x, float y, float z, float u, float v);
    void SetPoint(short Index, float x, float y, float z, float u, float v);
    long GetTextureCount();
    CString GetTextureName(long Index);
    long Properties();
    CString GetURL(LPCTSTR language, long urlID);
};
/////////////////////////////////////////////////////////////////////////////
// IObject3DCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IObject3D wrapper class

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

// Attributes
public:

// Operations
public:
    void SetDarfVerzerren(BOOL bNewValue);
    BOOL GetDarfVerzerren();
    void SetFlags(long nNewValue);
    long GetFlags();
    BOOL GetGroup();
    LPDISPATCH GetHistory();
    long GetId();
    void SetKeineSchatten(BOOL bNewValue);
    BOOL GetKeineSchatten();
    void SetLampenBeiNachtAn(BOOL bNewValue);
    BOOL GetLampenBeiNachtAn();
    void SetLampenSindAn(BOOL bNewValue);
    BOOL GetLampenSindAn();
    void SetLichtEinfluss(float newValue);
    float GetLichtEinfluss();
    void SetLichtFarbe(long nNewValue);
    long GetLichtFarbe();
    void SetLichtIntensitaet(float newValue);
    float GetLichtIntensitaet();
    void SetLichtMachtSchatten(BOOL bNewValue);
    BOOL GetLichtMachtSchatten();
    void SetLokalAnTerrainAnpassen(BOOL bNewValue);
    BOOL GetLokalAnTerrainAnpassen();
    CString GetName();
    LPDISPATCH GetObjectConstructor();
    LPDISPATCH GetParentObject();
    BOOL GetRoomObject();
    void SetSollFallen(BOOL bNewValue);
    BOOL GetSollFallen();
    LPDISPATCH GetSubObjects();
    BOOL Delete(BOOL withSubObjects);
    BOOL GetBoundingBox(float* minX, float* minY, float* minZ, float* maxX, float* maxY, float* maxZ);
    BOOL GetModelToGroupTransformation(VARIANT* matrix);
    BOOL GetModelToWorldTransformation(VARIANT* matrix);
    LPDISPATCH GetTextureCollection();
    BOOL InsertIntoWorld(BOOL selected);
    BOOL SetModelToWorldTransformation(const VARIANT& matrix);
    void SetOutline2D(LPDISPATCH obj2D, long cursor, LPCTSTR hint);
    BOOL WriteToFile(LPCTSTR FileName, float centerX, float centerY, float centerZ);
    void GetExtend(BOOL scaled, float* dx, float* dy, float* dz);
    BOOL IsInternalObject();
};
/////////////////////////////////////////////////////////////////////////////
// ITextureCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ITextureName wrapper class

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

// Attributes
public:

// Operations
public:
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
};
/////////////////////////////////////////////////////////////////////////////
// IMaterial wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAmbientCoefficient(float newValue);
    float GetAmbientCoefficient();
    void SetDiffuseCoefficient(float newValue);
    float GetDiffuseCoefficient();
    void SetDiffuseColor(long nNewValue);
    long GetDiffuseColor();
    void SetFlags(long nNewValue);
    long GetFlags();
    void SetHighlightExponent(float newValue);
    float GetHighlightExponent();
    void SetSpecularCoefficient(float newValue);
    float GetSpecularCoefficient();
    void SetSpecularColor(long nNewValue);
    long GetSpecularColor();
    void SetTransparency(float newValue);
    float GetTransparency();
    void SetTransparent(BOOL bNewValue);
    BOOL GetTransparent();
    BOOL DragStart();
};
/////////////////////////////////////////////////////////////////////////////
// IDimensionCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ITerrain wrapper class

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

// Attributes
public:

// Operations
public:
    void SetAmbientCoefficient(float newValue);
    float GetAmbientCoefficient();
    float GetArea();
    CString GetAreaFormula();
    LPDISPATCH GetBuildings();
    void SetDiffuseCoefficient(float newValue);
    float GetDiffuseCoefficient();
    void SetDiffuseColor(long nNewValue);
    long GetDiffuseColor();
    void SetFacetteLength(float newValue);
    float GetFacetteLength();
    void SetFlags(long nNewValue);
    long GetFlags();
    LPDISPATCH GetHedge();
    void SetHeight(float newValue);
    float GetHeight();
    void SetHighlightExponent(float newValue);
    float GetHighlightExponent();
    LPDISPATCH GetHistory();
    long GetId();
    void SetName(LPCTSTR lpszNewValue);
    CString GetName();
    LPDISPATCH GetOwner();
    void SetRemark(LPCTSTR lpszNewValue);
    CString GetRemark();
    void SetSpecularCoefficient(float newValue);
    float GetSpecularCoefficient();
    void SetSpecularColor(long nNewValue);
    long GetSpecularColor();
    LPDISPATCH GetTerrains();
    LPDISPATCH GetTexture();
    void SetTransparency(float newValue);
    float GetTransparency();
    void SetTransparent(BOOL bNewValue);
    BOOL GetTransparent();
    void SetType(long nNewValue);
    long GetType();
    float GetUmfang();
    CString GetUmfangsFormel();
    void Delete();
    BOOL Edit();
    void GetTransformation(float* x1, float* y1, float* z1, float* x2, float* y2, float* z2, float* X3, float* Y3, float* z3);
    void SetTransformation(float x1, float y1, float z1, float x2, float y2, float z2, float X3, float Y3, float z3);
};
/////////////////////////////////////////////////////////////////////////////
// IHedge wrapper class

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

// Attributes
public:

// Operations
public:
    void SetContinuous(BOOL bNewValue);
    BOOL GetContinuous();
    void SetDistance(float newValue);
    float GetDistance();
    void SetFileName(LPCTSTR lpszNewValue);
    CString GetFileName();
    void SetScaleToFit(BOOL bNewValue);
    BOOL GetScaleToFit();
};
/////////////////////////////////////////////////////////////////////////////
// ITerrainCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IGuideCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// ILabelingCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IToolData wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetGraphics2D();
    LPDISPATCH GetPoints();
    void Abort();
    void AddSnapPoint(float x, float y, float dirX, float dirY, float Distance, BOOL isOnVertex);
    void Continue();
    void Finish();
};
/////////////////////////////////////////////////////////////////////////////
// IImage wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
    void SetAutoSize(short nNewValue);
    short GetAutoSize();
    void SetBorderStyle(short nNewValue);
    short GetBorderStyle();
    void SetFileName(LPCTSTR lpszNewValue);
    CString GetFileName();
    void SetHeight(float newValue);
    float GetHeight();
    void SetLeft(float newValue);
    float GetLeft();
    void SetPicture(const VARIANT& newValue);
    void SetTop(float newValue);
    float GetTop();
    void SetWidth(float newValue);
    float GetWidth();
};
/////////////////////////////////////////////////////////////////////////////
// ILabel wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
    void SetAlignment(short nNewValue);
    short GetAlignment();
    void SetAngle(float newValue);
    float GetAngle();
    void SetAutoSize(BOOL bNewValue);
    BOOL GetAutoSize();
    void SetBackColor(long nNewValue);
    long GetBackColor();
    void SetBackStyle(short nNewValue);
    short GetBackStyle();
    void SetBorderStyle(short nNewValue);
    short GetBorderStyle();
    void SetCaption(LPCTSTR lpszNewValue);
    CString GetCaption();
    void SetFont(const VARIANT& newValue);
    VARIANT GetFont();
    void SetForeColor(long nNewValue);
    long GetForeColor();
    void SetHeight(float newValue);
    float GetHeight();
    void SetLeft(float newValue);
    float GetLeft();
    void SetTop(float newValue);
    float GetTop();
    void SetWidth(float newValue);
    float GetWidth();
    void SetWordWrap(BOOL bNewValue);
    BOOL GetWordWrap();
};
/////////////////////////////////////////////////////////////////////////////
// ILine wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
    void SetBorderColor(long nNewValue);
    long GetBorderColor();
    void SetBorderStyle(short nNewValue);
    short GetBorderStyle();
    void SetBorderWidth(float newValue);
    float GetBorderWidth();
    void SetDrawMode(short nNewValue);
    short GetDrawMode();
    void SetX1(float newValue);
    float GetX1();
    void SetX2(float newValue);
    float GetX2();
    void SetY1(float newValue);
    float GetY1();
    void SetY2(float newValue);
    float GetY2();
};
/////////////////////////////////////////////////////////////////////////////
// IObjectTransformerCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    BOOL Add(LPDISPATCH anObject, const VARIANT& aMatrix);
    BOOL AddTransformer(LPDISPATCH aTransformer);
    LPDISPATCH Item(long Index);
    BOOL update(BOOL dropAfterMove);
};
/////////////////////////////////////////////////////////////////////////////
// IObjectTransformer wrapper class

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

// Attributes
public:

// Operations
public:
    void SetMatrix(const VARIANT& newValue);
    VARIANT GetMatrix();
    void SetObject3D(LPDISPATCH newValue);
    LPDISPATCH GetObject3D();
};
/////////////////////////////////////////////////////////////////////////////
// IShape wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCustomMarks();
    LPDISPATCH GetCut();
    void SetDeletable(BOOL bNewValue);
    BOOL GetDeletable();
    void SetMoveable(BOOL bNewValue);
    BOOL GetMoveable();
    void SetSelectable(BOOL bNewValue);
    BOOL GetSelectable();
    void SetSelected(BOOL bNewValue);
    BOOL GetSelected();
    void SetSnapable(BOOL bNewValue);
    BOOL GetSnapable();
    LPDISPATCH GetStory();
    void SetUserData(long nNewValue);
    long GetUserData();
    void SetVisible(BOOL bNewValue);
    BOOL GetVisible();
    void EnableUpdate(BOOL enabled);
    long GetLayer();
    void Refresh();
    BOOL SetLayer(long newLayer);
    void SetMarks(short markerType, BOOL withLines);
    void ZOrder(short pos);
    void SetAngle(float newValue);
    float GetAngle();
    void SetBackColor(long nNewValue);
    long GetBackColor();
    void SetBackStyle(short nNewValue);
    short GetBackStyle();
    void SetBorderColor(long nNewValue);
    long GetBorderColor();
    void SetBorderStyle(short nNewValue);
    short GetBorderStyle();
    void SetBorderWidth(float newValue);
    float GetBorderWidth();
    void SetDrawMode(short nNewValue);
    short GetDrawMode();
    void SetFillColor(long nNewValue);
    long GetFillColor();
    void SetFillStyle(short nNewValue);
    short GetFillStyle();
    void SetHeight(float newValue);
    float GetHeight();
    void SetLeft(float newValue);
    float GetLeft();
    void SetShape(short nNewValue);
    short GetShape();
    void SetTop(float newValue);
    float GetTop();
    void SetWidth(float newValue);
    float GetWidth();
};
/////////////////////////////////////////////////////////////////////////////
// IProjectPreview wrapper class

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

// Attributes
public:

// Operations
public:
    CString GetDescription();
    VARIANT GetConstructionPreview();
    VARIANT GetDesignPreview();
};
/////////////////////////////////////////////////////////////////////////////
// IPrintSettings wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL GetAlsGrundriss();
    void SetAlsGrundriss(BOOL bNewValue);
    BOOL GetScale();
    void SetScale(BOOL bNewValue);
    float GetPagesToScaleTo();
    void SetPagesToScaleTo(float newValue);
    BOOL GetBackgroundWhite();
    void SetBackgroundWhite(BOOL bNewValue);
    long GetResolution();
    void SetResolution(long nNewValue);
    long GetGreyColor();
    void SetGreyColor(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ISavePictureSettings wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL GetWmf();
    void SetWmf(BOOL bNewValue);
    long GetSize();
    void SetSize(long nNewValue);
    long GetWidth();
    void SetWidth(long nNewValue);
    long GetHeight();
    void SetHeight(long nNewValue);
    BOOL GetTrueColor();
    void SetTrueColor(BOOL bNewValue);
    long GetOversampling();
    void SetOversampling(long nNewValue);
    BOOL GetAntiAliasing();
    void SetAntiAliasing(BOOL bNewValue);
    BOOL GetRaytrace();
    void SetRaytrace(BOOL bNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// IViewCollection wrapper class

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

// Attributes
public:

// Operations
public:
    long GetCount();
    LPDISPATCH Item(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IView wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL GetActive();
    BOOL GetWalking();
    long GetLeft();
    long GetTop();
    long GetWidth();
    long GetHeight();
    long GetViewer();
    BOOL GetZooming();
    long GetTimeOfDay();
    void SetTimeOfDay(long nNewValue);
    LPDISPATCH GetCut();
    void SetCut(LPDISPATCH newValue);
    LPDISPATCH GetCurrentStory();
    void SetCurrentStory(LPDISPATCH newValue);
    CString GetCaption();
    void SetCaption(LPCTSTR lpszNewValue);
    BOOL Activate();
    BOOL Print(LPDISPATCH settings, BOOL showDialog, BOOL askMultiplePages);
    BOOL SavePicture(LPDISPATCH settings, LPCTSTR FileName);
    BOOL StartWalking(BOOL UseVRDevice);
    BOOL StopWalking();
    BOOL Elevator(BOOL up, BOOL animated);
    BOOL StartRotateBuilding(BOOL canUndo);
    BOOL StartMirrorBuilding(BOOL canUndo);
    BOOL StartZoom();
    BOOL StopZoom();
    BOOL Zoom(long x, long y, float factor);
    BOOL ShowAll();
    BOOL Home();
    BOOL Pan(long PanCode, BOOL fast);
    BOOL Rotate(long RotCode, BOOL MoveEye, BOOL fast);
    BOOL PlayWalkFile(LPCTSTR FileName, BOOL UseVRDevice);
    BOOL GetCutViewing2D(long CutViewMode, LPDISPATCH* pViewing);
    BOOL SetCutViewing2D(long CutViewMode, float VRPx, float VRPy, float VRPz, float VPDist, float WCWidth);
    LPDISPATCH GetViewing(long typeOfView);
    BOOL SetViewing2D(long whichViewing, float VRPx, float VRPy, float VRPz, float VPDist, float WCWidth);
    BOOL SetViewing3D(float VRPx, float VRPy, float VRPz, float EyeX, float EyeY, float EyeZ, float tanViewAngleHalf);
    void GetMode(long* ViewType, long* ViewSubType, long* ViewMode);
    void SetMode(long ViewType, long ViewSubType, long ViewMode);
    BOOL SetFloorVisibility(BOOL OnlyCurrent);
    BOOL SelectPredefinedViewing3D(long Index);
};
/////////////////////////////////////////////////////////////////////////////
// IViewing wrapper class

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

// Attributes
public:

// Operations
public:
    float GetEyeX();
    float GetEyeY();
    float GetEyeZ();
    float GetVRPx();
    float GetVRPy();
    float GetVRPz();
    float GetVUPx();
    float GetVUPy();
    float GetVUPz();
    VARIANT GetWc_dc();
    VARIANT GetDc_wc();
    VARIANT GetWc_npc();
    VARIANT GetWc_npcx();
    VARIANT GetNpc_dc();
    VARIANT GetNpc_wc();
    float GetVPDist();
    float GetFCDist();
    float GetBCDist();
    float GetWCxmin();
    float GetWCxmax();
    float GetWCymin();
    float GetWCymax();
    BOOL GetReverse();
    BOOL GetParallel();
};
/////////////////////////////////////////////////////////////////////////////
// IZoomSettings wrapper class

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

// Attributes
public:

// Operations
public:
    long GetMode();
    void SetMode(long nNewValue);
    float GetFactor();
    void SetFactor(float newValue);
};
/////////////////////////////////////////////////////////////////////////////
// IWalkSettings wrapper class

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

// Attributes
public:

// Operations
public:
    BOOL GetParallel();
    void SetParallel(BOOL bNewValue);
    long GetManipulator();
    void SetManipulator(long nNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ICutView wrapper class

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

// Attributes
public:

// Operations
public:
    LPDISPATCH GetCut();
    long Viewer();
};