home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Houseplan Collection
/
HRCD2005.ISO
/
data1.cab
/
Zusatz
/
3DS
/
DATA2.Z
/
arcon.h
< prev
next >
Wrap
C/C++ Source or Header
|
1998-06-10
|
81KB
|
2,580 lines
// Machine generated IDispatch wrapper class(es) created with ClassWizard
/////////////////////////////////////////////////////////////////////////////
// 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();
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, long hInst, 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, long hInst, 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, long hInst, 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 enable);
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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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();
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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();
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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();
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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);
};
/////////////////////////////////////////////////////////////////////////////
// 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();
};