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

C/C++ Source or Header | 1997-10-08 | 136KB | 4,095 lines

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

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetFullName();
    CString GetName();
    CString Get_Name();
    BOOL GetVisible();
    void SetVisible(BOOL);
    BOOL GetMinimized();
    void SetMinimized(BOOL);
    BOOL GetMaximized();
    void SetMaximized(BOOL);
    LPDISPATCH GetActiveDocument();
    LPDISPATCH GetDocuments();
    LPDISPATCH GetEvents();
    long GetWindowHandle();
    short GetVersionMajor();
    short GetVersionMinor();
    long GetSerialNumber();

// Operations
public:
    void Quit();
    LPDISPATCH NewVector(const VARIANT& x, const VARIANT& y, const VARIANT& z);
    LPDISPATCH NewMatrix();
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();

// Operations
public:
    BOOL AddToolsCommand(long addonid, long menuid, LPCTSTR menutext, LPCTSTR statusbar);
    BOOL AddToolsOption(long addonid, long menuid, long eventid, LPCTSTR buttontext);
    BOOL RemoveToolsOption(long addonid, long menuid, long eventid);
    BOOL AddKeyboardCommand(long addonid, long eventid, LPCTSTR keystrokes);
    BOOL RegisterControl(LPDISPATCH channel);
    BOOL UnregisterControl(long addonid);
};
/////////////////////////////////////////////////////////////////////////////
// IDocuments wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    LPDISPATCH Add(const VARIANT& Name);
    LPDISPATCH New(const VARIANT& Name);
    void Close();
    void CloseOut();
    void Save();
    void Print();
    void PrintAll();
};
/////////////////////////////////////////////////////////////////////////////
// IDocument wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetFullName();
    CString GetName();
    CString Get_Name();
    CString GetPath();
    BOOL GetSaved();
    LPDISPATCH GetEntitySnap();
    LPDISPATCH GetUnits();
    LPDISPATCH GetEntities();
    LPDISPATCH GetApplicationIDs();
    LPDISPATCH GetLayers();
    LPDISPATCH GetLinetypes();
    LPDISPATCH GetBlocks();
    LPDISPATCH GetDimStyles();
    LPDISPATCH GetTextStyles();
    LPDISPATCH GetUcses();
    LPDISPATCH GetNamedViews();
    LPDISPATCH GetViews();
    LPDISPATCH GetCommands();
    LPDISPATCH GetColors();
    LPDISPATCH GetSelection();
    CString GetStatusbar();
    void SetStatusbar(LPCTSTR);
    LPDISPATCH GetHeader();
    LPDISPATCH GetPickEvents();
    LPDISPATCH GetSelectionEvents();
    BOOL GetVisible();
    void SetVisible(BOOL);
    BOOL GetMinimized();
    void SetMinimized(BOOL);
    BOOL GetMaximized();
    void SetMaximized(BOOL);
    long GetWindowHandle();

// Operations
public:
    void Activate();
    void Print(const VARIANT& copies);
    void PrintOut(const VARIANT& copies);
    void PrintSetup();
    void PrintPreview();
    void PrintPreviewClose();
    void Save();
    void SaveAs(LPCTSTR filename);
    void Close(const VARIANT& savechanges, const VARIANT& filename);
    void CloseOut(const VARIANT& savechanges, const VARIANT& filename);
    void Redraw();
    void Regen();
    LPDISPATCH NewEntitySet();
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IVector wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    double GetX();
    void SetX(double);
    double GetY();
    void SetY(double);
    double GetZ();
    void SetZ(double);
    double GetLength();
    double GetLengthSquared();
    double GetAngle();

// Operations
public:
    void CopyFrom(LPDISPATCH vector);
    void AddIn(LPDISPATCH vector);
    void SubtractAway(LPDISPATCH vector);
    void MultiplyBy(LPDISPATCH vector);
    void DivideBy(LPDISPATCH vector);
    void ScaleBy(double factor);
    double Distance(LPDISPATCH vector);
    BOOL Normalize();
    double DotProduct(LPDISPATCH vector);
    LPDISPATCH CrossProduct(LPDISPATCH vector);
    void Set(double x, double y, const VARIANT& z);
    void Set2D(double x, double y);
    void Set3D(double x, double y, double z);
    void Detach();
    CString Dump();
    CString _Dump();
};
/////////////////////////////////////////////////////////////////////////////
// IVectors wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(long which);
    void SetItem(long which, LPDISPATCH newValue);
    LPDISPATCH Get_Item(long which);
    void Set_Item(long which, LPDISPATCH newValue);
    void Add(LPDISPATCH vector);
};
/////////////////////////////////////////////////////////////////////////////
// IMatrix wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();

// Operations
public:
    LPDISPATCH GetItem(long which);
    void SetItem(long which, LPDISPATCH newValue);
    LPDISPATCH Get_Item(long which);
    void Set_Item(long which, LPDISPATCH newValue);
    void Id();
    void CopyFrom(LPDISPATCH matrix);
    void ECStoWCS(LPDISPATCH normal);
    void WCStoECS(LPDISPATCH normal);
    void Translation(LPDISPATCH offset);
    void Rotation(double Angle, const VARIANT& basepoint, const VARIANT& normal);
    void Scaling(LPDISPATCH factors, const VARIANT& basepoint, const VARIANT& normal);
    void Mirror(LPDISPATCH one, LPDISPATCH two, const VARIANT& normal);
    void Transform(LPDISPATCH point);
};
/////////////////////////////////////////////////////////////////////////////
// IHeader wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    BOOL GetAttributeDialog();
    void SetAttributeDialog(BOOL);
    long GetAttributeMode();
    void SetAttributeMode(long);
    BOOL GetAttributeRequest();
    void SetAttributeRequest(BOOL);
    BOOL GetAxisMode();
    void SetAxisMode(BOOL);
    LPDISPATCH GetAxisUnit();
    void SetAxisUnit(LPDISPATCH);
    BOOL GetBlipMode();
    void SetBlipMode(BOOL);
    long GetCirclePrecision();
    void SetCirclePrecision(long);
    long GetCoordinateDisplay();
    void SetCoordinateDisplay(long);
    double GetCurrentElevation();
    void SetCurrentElevation(double);
    double GetCurrentThickness();
    void SetCurrentThickness(double);
    long GetDragMode();
    void SetDragMode(long);
    long GetDrawingCodePage();
    void SetDrawingCodePage(long);
    BOOL GetFastZoom();
    void SetFastZoom(BOOL);
    BOOL GetFillMode();
    void SetFillMode(BOOL);
    BOOL GetFlatLand();
    void SetFlatLand(BOOL);
    BOOL GetHandles();
    void SetHandles(BOOL);
    CString GetHandleSeed();
    void SetHandleSeed(LPCTSTR);
    LPDISPATCH GetLimitsMax();
    void SetLimitsMax(LPDISPATCH);
    LPDISPATCH GetLimitsMin();
    void SetLimitsMin(LPDISPATCH);
    BOOL GetLimitsCheck();
    void SetLimitsCheck(BOOL);
    long GetMaxActiveViewports();
    void SetMaxActiveViewports(long);
    CString GetMenuName();
    void SetMenuName(LPCTSTR);
    BOOL GetMirrorText();
    void SetMirrorText(BOOL);
    double GetPaperSpaceElevation();
    void SetPaperSpaceElevation(double);
    LPDISPATCH GetPaperSpaceLimitsMax();
    void SetPaperSpaceLimitsMax(LPDISPATCH);
    LPDISPATCH GetPaperSpaceLimitsMin();
    void SetPaperSpaceLimitsMin(LPDISPATCH);
    BOOL GetPaperSpaceLimitsCheck();
    void SetPaperSpaceLimitsCheck(BOOL);
    long GetPolylineLinetypePattern();
    void SetPolylineLinetypePattern(long);
    double GetPolylineWidth();
    void SetPolylineWidth(double);
    long GetQuickText();
    void SetQuickText(long);
    long GetRegenMode();
    void SetRegenMode(long);
    long GetShadeDiffuse();
    void SetShadeDiffuse(long);
    long GetShadeEdge();
    void SetShadeEdge(long);
    double GetSketchIncrement();
    void SetSketchIncrement(double);
    BOOL GetSketchPolyline();
    void SetSketchPolyline(BOOL);
    long GetSplineFrame();
    void SetSplineFrame(long);
    long GetSplineSegments();
    void SetSplineSegments(long);
    long GetSplineType();
    void SetSplineType(long);
    long GetSurfaceDensityM();
    void SetSurfaceDensityM(long);
    long GetSurfaceDensityN();
    void SetSurfaceDensityN(long);
    long GetSurfaceTabulations1();
    void SetSurfaceTabulations1(long);
    long GetSurfaceTabulations2();
    void SetSurfaceTabulations2(long);
    long GetSurfaceType();
    void SetSurfaceType(long);
    double GetTextSize();
    void SetTextSize(double);
    double GetTraceSize();
    void SetTraceSize(double);
    long GetTreeDepth();
    void SetTreeDepth(long);
    long GetUCSIcon();
    void SetUCSIcon(long);
    long GetUnitMode();
    void SetUnitMode(long);
    long GetUserInteger1();
    void SetUserInteger1(long);
    long GetUserInteger2();
    void SetUserInteger2(long);
    long GetUserInteger3();
    void SetUserInteger3(long);
    long GetUserInteger4();
    void SetUserInteger4(long);
    long GetUserInteger5();
    void SetUserInteger5(long);
    long GetUserReal1();
    void SetUserReal1(long);
    long GetUserReal2();
    void SetUserReal2(long);
    long GetUserReal3();
    void SetUserReal3(long);
    long GetUserReal4();
    void SetUserReal4(long);
    long GetUserReal5();
    void SetUserReal5(long);
    BOOL GetUserTimer();
    void SetUserTimer(BOOL);
    BOOL GetWorldView();
    void SetWorldView(BOOL);
    double GetFilletRadius();
    void SetFilletRadius(double);
    double GetChamferDistanceA();
    void SetChamferDistanceA(double);
    double GetChamferDistanceB();
    void SetChamferDistanceB(double);
    short GetPointDisplayMode();
    void SetPointDisplayMode(short);
    double GetPointDisplaySize();
    void SetPointDisplaySize(double);
    BOOL GetLengthSnap();
    void SetLengthSnap(BOOL);
    double GetLengthSnapValue();
    void SetLengthSnapValue(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IEntitySnap wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    BOOL GetSnap();
    void SetSnap(BOOL);
    BOOL Get_Snap();
    void Set_Snap(BOOL);
    BOOL GetSnapToSelection();
    void SetSnapToSelection(BOOL);
    BOOL GetEndpoint();
    void SetEndpoint(BOOL);
    BOOL GetMidpoint();
    void SetMidpoint(BOOL);
    BOOL GetCenter();
    void SetCenter(BOOL);
    BOOL GetNearest();
    void SetNearest(BOOL);
    BOOL GetPointSnap();
    void SetPointSnap(BOOL);
    BOOL GetQuadrant();
    void SetQuadrant(BOOL);
    BOOL GetInsertion();
    void SetInsertion(BOOL);
    BOOL GetPerpendicular();
    void SetPerpendicular(BOOL);
    BOOL GetTangent();
    void SetTangent(BOOL);
    BOOL GetIntersection();
    void SetIntersection(BOOL);

// Operations
public:
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IUnits wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    short GetLinear();
    void SetLinear(short);
    short GetLinearDigits();
    void SetLinearDigits(short);
    short GetAngular();
    void SetAngular(short);
    short GetAngularDigits();
    void SetAngularDigits(short);
    double GetAngleBase();
    void SetAngleBase(double);
    BOOL GetClockwise();
    void SetClockwise(BOOL);
    short GetScaleMethod();
    double GetScaling();
    void SetScaling(double);
    short GetMetricUnits();
    void SetMetricUnits(short);
    short GetDisplayUnits();
    void SetDisplayUnits(short);

// Operations
public:
    CString PointToString(LPDISPATCH point);
    CString CoordinateToString(double value);
    CString AngleToString(double Angle);
    LPDISPATCH StringToPoint(LPCTSTR string);
    double StringToCoordinate(LPCTSTR string);
    double StringToAngle(LPCTSTR string);
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// ICommands wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    CString GetItem(long index);
    CString Get_Item(long index);
    BOOL Undo(const VARIANT& howmany);
    BOOL Redo(const VARIANT& howmany);
    BOOL Restart();
    BOOL Do(LPCTSTR command);
    void Group(LPCTSTR description);
    void EndGroup();
    void KillUndoRedo();
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IPickEvents wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString GetStatusbar();
    void SetStatusbar(LPCTSTR);
    BOOL GetNotifyDone();
    void SetNotifyDone(BOOL);
    BOOL GetNotifyProperties();
    void SetNotifyProperties(BOOL);
    BOOL GetNotifyUndo();
    void SetNotifyUndo(BOOL);
    long GetHelpToken();
    void SetHelpToken(long);
    LPDISPATCH GetBasepoint();
    void SetBasepoint(LPDISPATCH);

// Operations
public:
    BOOL RequestPick(long addonid, const VARIANT& userinfo);
    void SetCursorTips(LPCTSTR tip1, const VARIANT& tip2, const VARIANT& tip3, const VARIANT& tip4);
    void SetCursorTipInfo(short tipinfo, LPDISPATCH basepoint);
    BOOL RequestDraw(long addonid, const VARIANT& userinfo);
    BOOL TriggerPick(LPDISPATCH point);
    BOOL TriggerPopup(short event);
    BOOL TriggerLength(double Length);
    BOOL TriggerAngle(double Angle);
    BOOL TriggerOffset(LPDISPATCH offset);
    BOOL TriggerScale(LPDISPATCH scale);
    BOOL TriggerHeight(double height);
    BOOL TriggerWidth(double width);
    BOOL TriggerRadius(double radius);
    BOOL TriggerDiameter(double diameter);
};
/////////////////////////////////////////////////////////////////////////////
// ISelectionEvents wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString GetStatusbar();
    void SetStatusbar(LPCTSTR);

// Operations
public:
    BOOL RequestSelect(long addonid, const VARIANT& userinfo);
    BOOL RequestSingleSelect(long addonid, const VARIANT& userinfo);
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationIDs wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    LPDISPATCH Add(LPCTSTR Name);
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationID wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ILayers wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
};
/////////////////////////////////////////////////////////////////////////////
// ILayer wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    BOOL GetOn();
    void SetOn(BOOL);
    BOOL GetFrozen();
    void SetFrozen(BOOL);
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);

// Operations
public:
    BOOL GetFrozenInView(LPDISPATCH view);
    void SetFrozenInView(LPDISPATCH view, BOOL bNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// ILinetypes wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);
    double GetScaling();
    void SetScaling(double);
    BOOL GetPaperSpaceScaling();
    void SetPaperSpaceScaling(BOOL);
    LPDISPATCH GetSameAsLayer();
    LPDISPATCH GetSameAsBlock();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
};
/////////////////////////////////////////////////////////////////////////////
// ILinetype wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    CString GetDescription();
    void SetDescription(LPCTSTR);
    short GetCount();

// Operations
public:
    double GetItem(short index);
    void SetItem(short index, double newValue);
};
/////////////////////////////////////////////////////////////////////////////
// IBlocks wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetInsertBase();
    void SetInsertBase(LPDISPATCH);
    LPDISPATCH GetPaperSpaceInsertBase();
    void SetPaperSpaceInsertBase(LPDISPATCH);
    BOOL GetXrefVisibility();
    void SetXrefVisibility(BOOL);

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name, LPDISPATCH basepoint, const VARIANT& how);
    LPDISPATCH Load(LPCTSTR filename, const VARIANT& asxref, const VARIANT& blockname);
};
/////////////////////////////////////////////////////////////////////////////
// IBlock wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    LPDISPATCH GetExtentsMin();
    LPDISPATCH GetExtentsMax();
    BOOL GetIsXref();
    BOOL GetIsAnonymous();
    BOOL GetHasAttributes();
    LPDISPATCH GetInserts();

// Operations
public:
    void SaveAs(LPCTSTR filename);
    void CopyToClipboard();
    void XrefReload();
    void XrefDetach();
    void XrefBind();
};
/////////////////////////////////////////////////////////////////////////////
// IDimStyles wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);
    LPDISPATCH GetUnnamed();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
};
/////////////////////////////////////////////////////////////////////////////
// IDimStyle wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    double GetExtensionAboveLine();
    void SetExtensionAboveLine(double);
    double GetOffsetFromFeature();
    void SetOffsetFromFeature(double);
    BOOL GetExtension1Visibility();
    void SetExtension1Visibility(BOOL);
    BOOL GetExtension2Visibility();
    void SetExtension2Visibility(BOOL);
    double GetCenterMarkSize();
    void SetCenterMarkSize(double);
    LPDISPATCH GetExtensionColor();
    void SetExtensionColor(LPDISPATCH);
    BOOL GetCreateCenterLines();
    void SetCreateCenterLines(BOOL);
    BOOL GetForceInteriorLines();
    void SetForceInteriorLines(BOOL);
    BOOL GetBoxAroundText();
    void SetBoxAroundText(BOOL);
    double GetScaling();
    void SetScaling(double);
    double GetBaselineIncrement();
    void SetBaselineIncrement(double);
    double GetTextGap();
    void SetTextGap(double);
    LPDISPATCH GetDimensionLineColor();
    void SetDimensionLineColor(LPDISPATCH);
    double GetTickExtension();
    void SetTickExtension(double);
    double GetTickSize();
    void SetTickSize(double);
    double GetArrowSize();
    void SetArrowSize(double);
    BOOL GetSeparateArrowHeads();
    void SetSeparateArrowHeads(BOOL);
    long GetArrowsType();
    long GetArrow1Type();
    long GetArrow2Type();
    LPDISPATCH GetArrowsBlock();
    void SetArrowsBlock(LPDISPATCH);
    LPDISPATCH GetArrow1Block();
    void SetArrow1Block(LPDISPATCH);
    LPDISPATCH GetArrow2Block();
    void SetArrow2Block(LPDISPATCH);
    double GetTextHeight();
    void SetTextHeight(double);
    double GetTextHeightValue();
    void SetTextHeightValue(double);
    double GetVerticalPosition();
    void SetVerticalPosition(double);
    short GetAlignment();
    void SetAlignment(short);
    short GetVertical();
    void SetVertical(short);
    short GetHorizontal();
    void SetHorizontal(short);
    LPDISPATCH GetTextColor();
    void SetTextColor(LPDISPATCH);
    double GetToleranceHeightScaling();
    void SetToleranceHeightScaling(double);
    double GetRoundOff();
    void SetRoundOff(double);
    CString GetPreText();
    void SetPreText(LPCTSTR);
    CString GetPostText();
    void SetPostText(LPCTSTR);
    double GetLengthScaling();
    void SetLengthScaling(double);
    short GetTolerance();
    void SetTolerance(short);
    double GetUpper();
    void SetUpper(double);
    double GetLower();
    void SetLower(double);
    BOOL GetAlternateUnits();
    void SetAlternateUnits(BOOL);
    short GetAlternatePrecision();
    void SetAlternatePrecision(short);
    CString GetAlternatePostText();
    void SetAlternatePostText(LPCTSTR);
    double GetAlternateScaling();
    void SetAlternateScaling(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ITextStyles wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
};
/////////////////////////////////////////////////////////////////////////////
// ITextStyle wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    double GetHeight();
    void SetHeight(double);
    double GetLastHeight();
    void SetLastHeight(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    double GetXScaling();
    void SetXScaling(double);
    BOOL GetUpsideDown();
    void SetUpsideDown(BOOL);
    BOOL GetBackwards();
    void SetBackwards(BOOL);
    CString GetFont();
    void SetFont(LPCTSTR);
    CString GetBigFont();
    void SetBigFont(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IUcses wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);
    LPDISPATCH GetPaperSpace();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
    void Remove(LPDISPATCH entry);
};
/////////////////////////////////////////////////////////////////////////////
// IUcs wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    LPDISPATCH GetOrigin();
    void SetOrigin(LPDISPATCH);
    LPDISPATCH GetXAxis();
    void SetXAxis(LPDISPATCH);
    LPDISPATCH GetYAxis();
    void SetYAxis(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// INamedViews wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    BOOL GetHasItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
    void Update();
    void UpdateNow();
    LPDISPATCH Add(LPCTSTR Name);
    void Remove(LPDISPATCH entry);
};
/////////////////////////////////////////////////////////////////////////////
// INamedView wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    void SetName(LPCTSTR);
    CString Get_Name();
    void Set_Name(LPCTSTR);
    LPDISPATCH GetCenter();
    void SetCenter(LPDISPATCH);
    LPDISPATCH GetDirection();
    void SetDirection(LPDISPATCH);
    LPDISPATCH GetTarget();
    void SetTarget(LPDISPATCH);
    double GetHeight();
    void SetHeight(double);
    double GetWidth();
    void SetWidth(double);
    double GetTwist();
    void SetTwist(double);
    double GetLensLength();
    void SetLensLength(double);
    double GetFrontClip();
    void SetFrontClip(double);
    double GetBackClip();
    void SetBackClip(double);
    BOOL GetUseFrontClip();
    void SetUseFrontClip(BOOL);
    BOOL GetUseBackClip();
    void SetUseBackClip(BOOL);
    BOOL GetInPaperSpace();
    void SetInPaperSpace(BOOL);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IColors wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    LPDISPATCH GetActive();
    void SetActive(LPDISPATCH);
    LPDISPATCH GetSameAsLayer();
    LPDISPATCH GetSameAsBlock();

// Operations
public:
    LPDISPATCH GetItem(const VARIANT& which);
    LPDISPATCH Get_Item(const VARIANT& which);
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IColor wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    CString GetName();
    CString Get_Name();
    short GetNumber();
    short GetRed();
    short GetGreen();
    short GetBlue();

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IViews wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();
    BOOL GetHasPaperSpace();
    BOOL GetInPaperSpace();
    void SetInPaperSpace(BOOL);
    BOOL GetInPaperPorts();
    void SetInPaperPorts(BOOL);
    LPDISPATCH GetActiveView();
    void SetActiveView(LPDISPATCH);
    LPDISPATCH GetPaperSpace();
    LPDISPATCH GetExtentsMax();
    LPDISPATCH GetExtentsMin();
    LPDISPATCH GetPaperSpaceExtentsMax();
    LPDISPATCH GetPaperSpaceExtentsMin();

// Operations
public:
    LPDISPATCH GetItem(long index);
    LPDISPATCH Get_Item(long index);
    LPDISPATCH Add(LPDISPATCH corner1, LPDISPATCH corner2);
    void Remove(LPDISPATCH entry);
    void Redraw();
    void Regen();
};
/////////////////////////////////////////////////////////////////////////////
// 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:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetCenter();
    void SetCenter(LPDISPATCH);
    LPDISPATCH GetDirection();
    void SetDirection(LPDISPATCH);
    LPDISPATCH GetTarget();
    void SetTarget(LPDISPATCH);
    double GetHeight();
    void SetHeight(double);
    double GetWidth();
    void SetWidth(double);
    double GetTwist();
    void SetTwist(double);
    double GetLensLength();
    void SetLensLength(double);
    double GetFrontClip();
    void SetFrontClip(double);
    double GetBackClip();
    void SetBackClip(double);
    BOOL GetUseFrontClip();
    void SetUseFrontClip(BOOL);
    BOOL GetUseBackClip();
    void SetUseBackClip(BOOL);
    LPDISPATCH GetUpperRight();
    LPDISPATCH GetLowerLeft();
    LPDISPATCH GetGridSnap();
    LPDISPATCH GetAngleSnap();
    LPDISPATCH GetEntity();
    double GetPaperspaceScale();
    void SetPaperspaceScale(double);

// Operations
public:
    LPDISPATCH TranslatePoint(LPDISPATCH point);
    void Redraw();
    void Regen();
    void Extents();
    void View(LPDISPATCH namedview);
    void ViewPoint(LPDISPATCH vpoint);
    void ZoomWindow(LPDISPATCH corner1, LPDISPATCH corner2);
    void PanWindow(LPDISPATCH point1, LPDISPATCH point2);
    void ZoomFactor(double factor);
    void PreTranslate(LPDISPATCH offset);
    void PostTranslate(LPDISPATCH offset);
    void PreScale(LPDISPATCH scale);
    void PostScale(LPDISPATCH scale);
    void PreRotate(double xangle, double yangle, double zangle);
    void PostRotate(double xangle, double yangle, double zangle);
    void CenterPreRotate(double xangle, double yangle, double zangle);
    void CenterPostRotate(double xangle, double yangle, double zangle);
    void Update();
    void UpdateNow();
    void Plan();
    void LastView();
};
/////////////////////////////////////////////////////////////////////////////
// IGridSnap wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    BOOL GetSnap();
    void SetSnap(BOOL);
    BOOL Get_Snap();
    void Set_Snap(BOOL);
    BOOL GetDisplay();
    void SetDisplay(BOOL);
    BOOL GetIsometric();
    void SetIsometric(BOOL);
    LPDISPATCH GetSnapSpacing();
    void SetSnapSpacing(LPDISPATCH);
    LPDISPATCH GetDisplaySpacing();
    void SetDisplaySpacing(LPDISPATCH);
    LPDISPATCH GetOrigin();
    void SetOrigin(LPDISPATCH);
    double GetIsometricSpacing();
    void SetIsometricSpacing(double);

// Operations
public:
    void Update();
    void UpdateNow();
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IAngleSnap wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    BOOL GetSnap();
    void SetSnap(BOOL);
    BOOL Get_Snap();
    void Set_Snap(BOOL);
    BOOL GetOrtho();
    void SetOrtho(BOOL);
    double GetAngle();
    void SetAngle(double);
    double GetBaseAngle();
    void SetBaseAngle(double);

// Operations
public:
    void Dialog();
};
/////////////////////////////////////////////////////////////////////////////
// IEntities wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    BOOL GetHasItems();
    long GetCount();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH GetItem(const VARIANT& which);
    LPDISPATCH GetLast();
    LPDISPATCH GetFirst();
    LPDISPATCH GetNext();
    LPDISPATCH Get_Item(const VARIANT& which);
    LPDISPATCH AddLine();
    LPDISPATCH AddCircle();
    LPDISPATCH AddArc();
    LPDISPATCH AddFace();
    LPDISPATCH AddText();
    LPDISPATCH AddPoint();
    LPDISPATCH AddShape();
    LPDISPATCH AddTrace();
    LPDISPATCH AddSolid();
    LPDISPATCH AddPolyline(short vertices);
    LPDISPATCH Add3DPolyline(short vertices);
    LPDISPATCH AddPolymesh(short rows, short columns);
    LPDISPATCH AddPolyface(short vertices, short faces);
    LPDISPATCH AddAttdef();
    LPDISPATCH AddDimension();
    LPDISPATCH AddInsert(LPCTSTR blockname);
    void DrawLines();
    void DrawLine();
    void DrawDoubleLines();
    void Draw2DPolyline();
    void Draw3DPolyline();
    void DrawCircle();
    void Draw2PointCircle();
    void Draw3PointCircle();
    void Draw3PointArcs();
    void Draw3PointArc();
    void DrawCenterStartEndArc();
    void DrawStartCenterEndArc();
    void DrawStartEndCenterArc();
    void DrawStartDirectionEndArc();
    void DrawFace();
    void DrawPoint();
    void DrawSolid();
    void DrawTrace();
    void DrawText();
    void DrawAttdef();
    void DrawInsert(const VARIANT& which);
    void Draw2DSpline();
    void Draw3DSpline();
    void Draw2DQuadraticSpline();
    void Draw3DQuadraticSpline();
    void Draw2DCubicSpline();
    void Draw3DCubicSpline();
    void Draw2PointRectangle();
    void Draw3PointRectangle();
    void DrawCenterVertexPolygon();
    void DrawCenterMidpointPolygon();
    void DrawEdgePolygon();
    void DrawDonut();
    void DrawHorizontalDim(const VARIANT& what);
    void DrawVerticalDim(const VARIANT& what);
    void DrawAlignedDim(const VARIANT& what);
    void DrawRotatedDim(const VARIANT& what);
    void DrawAngularDim(const VARIANT& what);
    void Draw4PointAngularDim(const VARIANT& what);
    void DrawRadiusDim(const VARIANT& what);
    void DrawDiameterDim(const VARIANT& what);
    void DrawOrdinateXDim(const VARIANT& what);
    void DrawOrdinateYDim(const VARIANT& what);
    void DrawBaselineDim(const VARIANT& what);
    void DrawContinuousDim(const VARIANT& what);
    void DrawLeader();
    void DrawViewport();
};
/////////////////////////////////////////////////////////////////////////////
// ISelection wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    BOOL GetHasItems();
    long GetCount();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH GetItem(const VARIANT& which);
    LPDISPATCH GetLast();
    LPDISPATCH GetFirst();
    LPDISPATCH GetNext();
    LPDISPATCH Get_Item(const VARIANT& which);
    void Add(LPDISPATCH Entity);
    void Remove(LPDISPATCH Entity);
    void RemoveAll();
    void AddAll();
    void AddPrevious();
    void CrossingWindow(LPDISPATCH corner1, LPDISPATCH corner2);
    void ContainingWindow(LPDISPATCH corner1, LPDISPATCH corner2);
    void PickSingle(LPDISPATCH point);
    void CopyToClipboard(const VARIANT& basepoint);
    void CutToClipboard(const VARIANT& basepoint);
    void WindowToClipboard();
    void TextToClipboard();
};
/////////////////////////////////////////////////////////////////////////////
// IEntitySet wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    BOOL GetHasItems();
    long GetCount();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH GetItem(const VARIANT& which);
    LPDISPATCH GetLast();
    LPDISPATCH GetFirst();
    LPDISPATCH GetNext();
    LPDISPATCH Get_Item(const VARIANT& which);
    void Add(LPDISPATCH Entity);
    void Remove(LPDISPATCH Entity);
    void RemoveAll();
    void AddAll();
};
/////////////////////////////////////////////////////////////////////////////
// IXData wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    short GetGroup();
    short GetType();
    short GetIndex();
    void SetIndex(short);
    CString GetString();
    void SetString(LPCTSTR);
    short GetControl();
    void SetControl(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    CString GetHandle();
    void SetHandle(LPCTSTR);
    LPDISPATCH GetVector();
    void SetVector(LPDISPATCH);
    double GetDouble();
    void SetDouble(double);
    short GetShort();
    void SetShort(short);
    long GetLong();
    void SetLong(long);

// Operations
public:
    BOOL Next();
    BOOL Add(short Group, const VARIANT& data);
    BOOL Remove();
    BOOL FindApplicationID(LPCTSTR appname);
    BOOL AddApplicationID(LPCTSTR appname);
};
/////////////////////////////////////////////////////////////////////////////
// IEntity wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// 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:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere1();
    void SetWhere1(LPDISPATCH);
    LPDISPATCH GetWhere2();
    void SetWhere2(LPDISPATCH);
    double GetLength();
    LPDISPATCH GetStartPoint();
    void SetStartPoint(LPDISPATCH);
    LPDISPATCH GetEndpoint();
    void SetEndpoint(LPDISPATCH);
    double GetAngle();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    short Fillet(LPDISPATCH Entity, LPDISPATCH pick1, LPDISPATCH pick2);
    short Chamfer(LPDISPATCH Entity, LPDISPATCH pick1, LPDISPATCH pick2);
};
/////////////////////////////////////////////////////////////////////////////
// IPoint wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    double GetRotation();
    void SetRotation(double);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// ICircle wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    double GetRadius();
    void SetRadius(double);
    double GetCircumference();
    double GetArea();
    LPDISPATCH GetCenter();
    void SetCenter(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// 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:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    CString GetShapeName();
    void SetShapeName(LPCTSTR);
    short GetShapeNumber();
    void SetShapeNumber(short);
    double GetRotation();
    void SetRotation(double);
    double GetSize();
    void SetSize(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    double GetXScaling();
    void SetXScaling(double);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// IArc wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    double GetRadius();
    void SetRadius(double);
    double GetStartAngle();
    void SetStartAngle(double);
    double GetEndAngle();
    void SetEndAngle(double);
    double GetLength();
    double GetChordedArea();
    double GetPieArea();
    LPDISPATCH GetWhere1();
    LPDISPATCH GetWhere2();
    LPDISPATCH GetStartPoint();
    LPDISPATCH GetEndpoint();
    LPDISPATCH GetCenter();
    void SetCenter(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// ISolid wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetCircumference();
    double GetArea();
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    LPDISPATCH GetWhere(short which);
    void SetWhere(short which, LPDISPATCH newValue);
};
/////////////////////////////////////////////////////////////////////////////
// ITrace wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetCircumference();
    double GetArea();
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    LPDISPATCH GetWhere(short which);
    void SetWhere(short which, LPDISPATCH newValue);
};
/////////////////////////////////////////////////////////////////////////////
// IFace wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetCircumference();
    double GetArea();
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    LPDISPATCH GetWhere(short which);
    void SetWhere(short which, LPDISPATCH newValue);
    BOOL GetVisible(short which);
    void SetVisible(short which, BOOL bNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// IInsert wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetBlock();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    LPDISPATCH GetScaling();
    void SetScaling(LPDISPATCH);
    double GetRotation();
    void SetRotation(double);
    short GetColumns();
    void SetColumns(short);
    short GetRows();
    void SetRows(short);
    double GetColumnSpacing();
    void SetColumnSpacing(double);
    double GetRowSpacing();
    void SetRowSpacing(double);
    LPDISPATCH GetAttributes();
    BOOL GetHasAttributes();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IText wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    LPDISPATCH GetAlignPoint();
    void SetAlignPoint(LPDISPATCH);
    BOOL GetBackwards();
    void SetBackwards(BOOL);
    double GetHeight();
    void SetHeight(double);
    short GetHorizontal();
    void SetHorizontal(short);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    double GetRotation();
    void SetRotation(double);
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    LPDISPATCH GetWhereJustified();
    void SetWhereJustified(LPDISPATCH);
    CString GetText();
    void SetText(LPCTSTR);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    BOOL GetUpsideDown();
    void SetUpsideDown(BOOL);
    short GetVertical();
    void SetVertical(short);
    double GetXScaling();
    void SetXScaling(double);
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// IAttdef wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    LPDISPATCH GetAlignPoint();
    void SetAlignPoint(LPDISPATCH);
    BOOL GetBackwards();
    void SetBackwards(BOOL);
    double GetHeight();
    void SetHeight(double);
    short GetHorizontal();
    void SetHorizontal(short);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    double GetRotation();
    void SetRotation(double);
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    LPDISPATCH GetWhereJustified();
    void SetWhereJustified(LPDISPATCH);
    CString GetText();
    void SetText(LPCTSTR);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    BOOL GetUpsideDown();
    void SetUpsideDown(BOOL);
    short GetVertical();
    void SetVertical(short);
    double GetXScaling();
    void SetXScaling(double);
    CString Get_Name();
    BOOL GetVisible();
    void SetVisible(BOOL);
    BOOL GetConstant();
    void SetConstant(BOOL);
    BOOL GetVerify();
    void SetVerify(BOOL);
    BOOL GetPreset();
    void SetPreset(BOOL);
    CString GetTag();
    void SetTag(LPCTSTR);
    CString GetPrompt();
    void SetPrompt(LPCTSTR);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// IAttributes wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(long index);
    LPDISPATCH Get_Item(long index);
};
/////////////////////////////////////////////////////////////////////////////
// IAttribute wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    LPDISPATCH GetAlignPoint();
    void SetAlignPoint(LPDISPATCH);
    BOOL GetBackwards();
    void SetBackwards(BOOL);
    double GetHeight();
    void SetHeight(double);
    short GetHorizontal();
    void SetHorizontal(short);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    double GetRotation();
    void SetRotation(double);
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    LPDISPATCH GetWhereJustified();
    void SetWhereJustified(LPDISPATCH);
    CString GetText();
    void SetText(LPCTSTR);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    BOOL GetUpsideDown();
    void SetUpsideDown(BOOL);
    short GetVertical();
    void SetVertical(short);
    double GetXScaling();
    void SetXScaling(double);
    CString Get_Name();
    BOOL GetVisible();
    BOOL GetConstant();
    BOOL GetVerify();
    BOOL GetPreset();
    CString GetTag();
    void SetTag(LPCTSTR);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// I2DPolyline wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetVertices();
    BOOL GetClosed();
    void SetClosed(BOOL);
    short GetCurve();
    void SetCurve(short);
    double GetEndWidth();
    void SetEndWidth(double);
    double GetStartWidth();
    void SetStartWidth(double);
    double GetLength();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
    short Fillet();
    short Chamfer();
};
/////////////////////////////////////////////////////////////////////////////
// I3DPolyline wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetVertices();
    BOOL GetClosed();
    void SetClosed(BOOL);
    short GetCurve();
    void SetCurve(short);
    double GetLength();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IPolymesh wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetVertices();
    BOOL GetColumnClosed();
    void SetColumnClosed(BOOL);
    BOOL GetRowClosed();
    void SetRowClosed(BOOL);
    short GetColumnSize();
    short GetRowSize();
    short GetColumnCurve();
    short GetRowCurve();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IPolyface wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetVertices();
    LPDISPATCH GetFaceVertices();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// I2DVertices wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(long index);
    LPDISPATCH Get_Item(long index);
};
/////////////////////////////////////////////////////////////////////////////
// IVertices wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(long index);
    LPDISPATCH Get_Item(long index);
};
/////////////////////////////////////////////////////////////////////////////
// IFaceVertices wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    long GetCount();

// Operations
public:
    LPDISPATCH GetItem(long index);
    LPDISPATCH Get_Item(long index);
};
/////////////////////////////////////////////////////////////////////////////
// I2DVertex wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    double GetEndWidth();
    void SetEndWidth(double);
    double GetStartWidth();
    void SetStartWidth(double);
    double GetBulge();
    void SetBulge(double);
    double GetTangent();
    void SetTangent(double);
    BOOL GetControlPoint();
    BOOL GetCurveFit();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// IVertex wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};
/////////////////////////////////////////////////////////////////////////////
// IFaceVertex wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    short GetCorner(short which);
    void SetCorner(short which, short nNewValue);
    BOOL GetVisible(short which);
    void SetVisible(short which, BOOL bNewValue);
    void SetCorners(short val1, short val2, short val3, short val4);
    void SetVisibility(BOOL flag1, BOOL flag2, BOOL flag3, BOOL flag4);
};
/////////////////////////////////////////////////////////////////////////////
// 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:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetAngle();
    void SetAngle(double);
    LPDISPATCH GetDxf10();
    void SetDxf10(LPDISPATCH);
    LPDISPATCH GetDxf11();
    void SetDxf11(LPDISPATCH);
    LPDISPATCH GetDxf12();
    void SetDxf12(LPDISPATCH);
    LPDISPATCH GetDxf13();
    void SetDxf13(LPDISPATCH);
    LPDISPATCH GetDxf14();
    void SetDxf14(LPDISPATCH);
    LPDISPATCH GetDxf15();
    void SetDxf15(LPDISPATCH);
    LPDISPATCH GetDxf16();
    void SetDxf16(LPDISPATCH);
    double GetHorizontalAngle();
    void SetHorizontalAngle(double);
    double GetLeaderLength();
    void SetLeaderLength(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    CString GetString();
    void SetString(LPCTSTR);
    double GetTextAngle();
    void SetTextAngle(double);
    BOOL GetTextHomePosition();
    void SetTextHomePosition(BOOL);
    CString Get_Name();

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IDimHorizontal wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetAngle();
    void SetAngle(double);
    LPDISPATCH GetDxf10();
    void SetDxf10(LPDISPATCH);
    LPDISPATCH GetDxf11();
    void SetDxf11(LPDISPATCH);
    LPDISPATCH GetDxf12();
    void SetDxf12(LPDISPATCH);
    LPDISPATCH GetDxf13();
    void SetDxf13(LPDISPATCH);
    LPDISPATCH GetDxf14();
    void SetDxf14(LPDISPATCH);
    LPDISPATCH GetDxf15();
    void SetDxf15(LPDISPATCH);
    LPDISPATCH GetDxf16();
    void SetDxf16(LPDISPATCH);
    double GetHorizontalAngle();
    void SetHorizontalAngle(double);
    double GetLeaderLength();
    void SetLeaderLength(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    CString GetString();
    void SetString(LPCTSTR);
    double GetTextAngle();
    void SetTextAngle(double);
    BOOL GetTextHomePosition();
    void SetTextHomePosition(BOOL);
    CString Get_Name();
    LPDISPATCH GetTextPosition();
    void SetTextPosition(LPDISPATCH);
    LPDISPATCH GetTranslationVector();
    void SetTranslationVector(LPDISPATCH);
    LPDISPATCH GetDimensionLine();
    void SetDimensionLine(LPDISPATCH);
    LPDISPATCH GetFirstExtension();
    void SetFirstExtension(LPDISPATCH);
    LPDISPATCH GetSecondExtension();
    void SetSecondExtension(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IDimVertical wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetAngle();
    void SetAngle(double);
    LPDISPATCH GetDxf10();
    void SetDxf10(LPDISPATCH);
    LPDISPATCH GetDxf11();
    void SetDxf11(LPDISPATCH);
    LPDISPATCH GetDxf12();
    void SetDxf12(LPDISPATCH);
    LPDISPATCH GetDxf13();
    void SetDxf13(LPDISPATCH);
    LPDISPATCH GetDxf14();
    void SetDxf14(LPDISPATCH);
    LPDISPATCH GetDxf15();
    void SetDxf15(LPDISPATCH);
    LPDISPATCH GetDxf16();
    void SetDxf16(LPDISPATCH);
    double GetHorizontalAngle();
    void SetHorizontalAngle(double);
    double GetLeaderLength();
    void SetLeaderLength(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    CString GetString();
    void SetString(LPCTSTR);
    double GetTextAngle();
    void SetTextAngle(double);
    BOOL GetTextHomePosition();
    void SetTextHomePosition(BOOL);
    CString Get_Name();
    LPDISPATCH GetTextPosition();
    void SetTextPosition(LPDISPATCH);
    LPDISPATCH GetTranslationVector();
    void SetTranslationVector(LPDISPATCH);
    LPDISPATCH GetDimensionLine();
    void SetDimensionLine(LPDISPATCH);
    LPDISPATCH GetFirstExtension();
    void SetFirstExtension(LPDISPATCH);
    LPDISPATCH GetSecondExtension();
    void SetSecondExtension(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IDimAligned wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetAngle();
    void SetAngle(double);
    LPDISPATCH GetDxf10();
    void SetDxf10(LPDISPATCH);
    LPDISPATCH GetDxf11();
    void SetDxf11(LPDISPATCH);
    LPDISPATCH GetDxf12();
    void SetDxf12(LPDISPATCH);
    LPDISPATCH GetDxf13();
    void SetDxf13(LPDISPATCH);
    LPDISPATCH GetDxf14();
    void SetDxf14(LPDISPATCH);
    LPDISPATCH GetDxf15();
    void SetDxf15(LPDISPATCH);
    LPDISPATCH GetDxf16();
    void SetDxf16(LPDISPATCH);
    double GetHorizontalAngle();
    void SetHorizontalAngle(double);
    double GetLeaderLength();
    void SetLeaderLength(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    CString GetString();
    void SetString(LPCTSTR);
    double GetTextAngle();
    void SetTextAngle(double);
    BOOL GetTextHomePosition();
    void SetTextHomePosition(BOOL);
    CString Get_Name();
    LPDISPATCH GetTextPosition();
    void SetTextPosition(LPDISPATCH);
    LPDISPATCH GetTranslationVector();
    void SetTranslationVector(LPDISPATCH);
    LPDISPATCH GetDimensionLine();
    void SetDimensionLine(LPDISPATCH);
    LPDISPATCH GetFirstExtension();
    void SetFirstExtension(LPDISPATCH);
    LPDISPATCH GetSecondExtension();
    void SetSecondExtension(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IDimRotated wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    double GetAngle();
    void SetAngle(double);
    LPDISPATCH GetDxf10();
    void SetDxf10(LPDISPATCH);
    LPDISPATCH GetDxf11();
    void SetDxf11(LPDISPATCH);
    LPDISPATCH GetDxf12();
    void SetDxf12(LPDISPATCH);
    LPDISPATCH GetDxf13();
    void SetDxf13(LPDISPATCH);
    LPDISPATCH GetDxf14();
    void SetDxf14(LPDISPATCH);
    LPDISPATCH GetDxf15();
    void SetDxf15(LPDISPATCH);
    LPDISPATCH GetDxf16();
    void SetDxf16(LPDISPATCH);
    double GetHorizontalAngle();
    void SetHorizontalAngle(double);
    double GetLeaderLength();
    void SetLeaderLength(double);
    double GetObliqueAngle();
    void SetObliqueAngle(double);
    LPDISPATCH GetStyle();
    void SetStyle(LPDISPATCH);
    CString GetString();
    void SetString(LPCTSTR);
    double GetTextAngle();
    void SetTextAngle(double);
    BOOL GetTextHomePosition();
    void SetTextHomePosition(BOOL);
    CString Get_Name();
    LPDISPATCH GetTextPosition();
    void SetTextPosition(LPDISPATCH);
    LPDISPATCH GetTranslationVector();
    void SetTranslationVector(LPDISPATCH);
    LPDISPATCH GetDimensionLine();
    void SetDimensionLine(LPDISPATCH);
    LPDISPATCH GetFirstExtension();
    void SetFirstExtension(LPDISPATCH);
    LPDISPATCH GetSecondExtension();
    void SetSecondExtension(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
    BOOL Explode();
};
/////////////////////////////////////////////////////////////////////////////
// IViewport wrapper class

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

// Attributes
public:
    LPDISPATCH GetApplication();
    LPDISPATCH GetParent();
    LPDISPATCH GetColor();
    void SetColor(LPDISPATCH);
    short GetColorNumber();
    void SetColorNumber(short);
    LPDISPATCH GetLayer();
    void SetLayer(LPDISPATCH);
    LPDISPATCH GetLinetype();
    void SetLinetype(LPDISPATCH);
    double GetThickness();
    void SetThickness(double);
    BOOL GetPaperSpace();
    void SetPaperSpace(BOOL);
    LPDISPATCH GetNormal();
    void SetNormal(LPDISPATCH);
    CString GetName();
    short GetType();
    CString GetHandle();
    BOOL GetHasXData();
    LPDISPATCH GetXData();
    BOOL GetAutoDraw();
    void SetAutoDraw(BOOL);
    CString Get_Name();
    LPDISPATCH GetWhere();
    void SetWhere(LPDISPATCH);
    double GetWidth();
    void SetWidth(double);
    double GetHeight();
    void SetHeight(double);
    short GetStatus();
    void SetStatus(short);
    LPDISPATCH GetCenter();
    void SetCenter(LPDISPATCH);

// Operations
public:
    void Redraw();
    void Regen();
    void Erase();
    void Delete();
    void Move(LPDISPATCH offset);
    LPDISPATCH Copy(LPDISPATCH offset);
    void scale(LPDISPATCH basepoint, LPDISPATCH scale);
    void ScaleIt(LPDISPATCH basepoint, LPDISPATCH scale);
    void Rotate(LPDISPATCH basepoint, double Angle);
    void Mirror(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    LPDISPATCH MirrorCopy(LPDISPATCH point1, LPDISPATCH point2, const VARIANT& MirrorText);
    void Dialog();
    LPDISPATCH Offset(LPDISPATCH vec, const VARIANT& Distance);
    LPDISPATCH Array(short numrows, short numcols, double rowspacing, double colspacing, double Rotation);
    LPDISPATCH Array3D(short numrows, short numcols, short numlevels, double rowspacing, double colspacing, double levelspacing, double Rotation);
    LPDISPATCH PolarArray(short numitems, double fillangle, double angletween, LPDISPATCH Center, const VARIANT& refpoint);
    void DisplayGrips();
    void EraseGrips();
    LPDISPATCH Snap2Endpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Midpoint(LPDISPATCH closeto);
    LPDISPATCH Snap2Center(LPDISPATCH closeto);
    LPDISPATCH Snap2Nearest(LPDISPATCH closeto);
    LPDISPATCH Snap2Point(LPDISPATCH closeto);
    LPDISPATCH Snap2Quadrant(LPDISPATCH closeto);
    LPDISPATCH Snap2Insertion(LPDISPATCH closeto);
    LPDISPATCH Snap2Perpendicular(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Snap2Tangent(LPDISPATCH closeto, LPDISPATCH prevpoint);
    LPDISPATCH Intersection(LPDISPATCH Entity, const VARIANT& infinite1, const VARIANT& infinite2);
    BOOL ExtendToSet(LPDISPATCH point);
    BOOL TrimToSet(LPDISPATCH point);
    BOOL Break(LPDISPATCH point1, LPDISPATCH point2);
    void Update();
    void UpdateNow();
};