acad.cpp

ARX/CAD二次开发

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

#include "stdafx.h"
#include "acad.h"

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



/////////////////////////////////////////////////////////////////////////////
// IAcadModelSpace properties

/////////////////////////////////////////////////////////////////////////////
// IAcadModelSpace operations

CString IAcadModelSpace::GetHandle()
{
	CString result;
	InvokeHelper(0x400, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

CString IAcadModelSpace::GetObjectName()
{
	CString result;
	InvokeHelper(0x401, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IAcadModelSpace::GetXData(LPCTSTR AppName, VARIANT* XDataType, VARIANT* XDataValue)
{
	static BYTE parms[] =
		VTS_BSTR VTS_PVARIANT VTS_PVARIANT;
	InvokeHelper(0x402, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 AppName, XDataType, XDataValue);
}

void IAcadModelSpace::SetXData(const VARIANT& XDataType, const VARIANT& XDataValue)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x403, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &XDataType, &XDataValue);
}

void IAcadModelSpace::Delete()
{
	InvokeHelper(0x404, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IAcadModelSpace::GetObjectID()
{
	long result;
	InvokeHelper(0x405, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IAcadModelSpace::GetApplication()
{
	LPDISPATCH result;
	InvokeHelper(0x406, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

BOOL IAcadModelSpace::GetHasExtensionDictionary()
{
	BOOL result;
	InvokeHelper(0x408, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

LPDISPATCH IAcadModelSpace::GetExtensionDictionary()
{
	LPDISPATCH result;
	InvokeHelper(0x409, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

long IAcadModelSpace::GetOwnerID()
{
	long result;
	InvokeHelper(0x40a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

LPDISPATCH IAcadModelSpace::GetDocument()
{
	LPDISPATCH result;
	InvokeHelper(0x40b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

LPDISPATCH IAcadModelSpace::Item(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x0, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return result;
}

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

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

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

VARIANT IAcadModelSpace::GetOrigin()
{
	VARIANT result;
	InvokeHelper(0x602, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
	return result;
}

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

LPDISPATCH IAcadModelSpace::AddCustomObject(LPCTSTR ClassName)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x603, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		ClassName);
	return result;
}

LPDISPATCH IAcadModelSpace::Add3DFace(const VARIANT& Point1, const VARIANT& Point2, const VARIANT& point3, const VARIANT& Point4)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x604, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point1, &Point2, &point3, &Point4);
	return result;
}

LPDISPATCH IAcadModelSpace::Add3DMesh(long M, long N, const VARIANT& PointsMatrix)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_VARIANT;
	InvokeHelper(0x605, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		M, N, &PointsMatrix);
	return result;
}

LPDISPATCH IAcadModelSpace::Add3DPoly(const VARIANT& PointsArray)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x606, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&PointsArray);
	return result;
}

LPDISPATCH IAcadModelSpace::AddArc(const VARIANT& Center, double Radius, double StartAngle, double EndAngle)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x607, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, Radius, StartAngle, EndAngle);
	return result;
}

LPDISPATCH IAcadModelSpace::AddAttribute(double Height, long Mode, LPCTSTR Prompt, const VARIANT& InsertionPoint, LPCTSTR Tag, LPCTSTR Value)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_R8 VTS_I4 VTS_BSTR VTS_VARIANT VTS_BSTR VTS_BSTR;
	InvokeHelper(0x608, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Height, Mode, Prompt, &InsertionPoint, Tag, Value);
	return result;
}

LPDISPATCH IAcadModelSpace::AddBox(const VARIANT& Origin, double Length, double Width, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x609, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Origin, Length, Width, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddCircle(const VARIANT& Center, double Radius)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8;
	InvokeHelper(0x60a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, Radius);
	return result;
}

LPDISPATCH IAcadModelSpace::AddCone(const VARIANT& Center, double BaseRadius, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8;
	InvokeHelper(0x60b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, BaseRadius, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddCylinder(const VARIANT& Center, double Radius, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8;
	InvokeHelper(0x60c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, Radius, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimAligned(const VARIANT& ExtLine1Point, const VARIANT& ExtLine2Point, const VARIANT& TextPosition)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x60d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&ExtLine1Point, &ExtLine2Point, &TextPosition);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimAngular(const VARIANT& AngleVertex, const VARIANT& FirstEndPoint, const VARIANT& SecondEndPoint, const VARIANT& TextPoint)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x60e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&AngleVertex, &FirstEndPoint, &SecondEndPoint, &TextPoint);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimDiametric(const VARIANT& ChordPoint, const VARIANT& FarChordPoint, double LeaderLength)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x60f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&ChordPoint, &FarChordPoint, LeaderLength);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimRotated(const VARIANT& ExtLine1Point, const VARIANT& ExtLine2Point, const VARIANT& DimLineLocation, double RotationAngle)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x610, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&ExtLine1Point, &ExtLine2Point, &DimLineLocation, RotationAngle);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimOrdinate(const VARIANT& DefinitionPoint, const VARIANT& LeaderEndPoint, long UseXAxis)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_I4;
	InvokeHelper(0x611, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&DefinitionPoint, &LeaderEndPoint, UseXAxis);
	return result;
}

LPDISPATCH IAcadModelSpace::AddDimRadial(const VARIANT& Center, const VARIANT& ChordPoint, double LeaderLength)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x612, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, &ChordPoint, LeaderLength);
	return result;
}

LPDISPATCH IAcadModelSpace::AddEllipse(const VARIANT& Center, const VARIANT& MajorAxis, double RadiusRatio)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x613, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, &MajorAxis, RadiusRatio);
	return result;
}

LPDISPATCH IAcadModelSpace::AddEllipticalCone(const VARIANT& Center, double MajorRadius, double MinorRadius, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x614, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, MajorRadius, MinorRadius, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddEllipticalCylinder(const VARIANT& Center, double MajorRadius, double MinorRadius, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x615, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, MajorRadius, MinorRadius, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddExtrudedSolid(LPDISPATCH Profile, double Height, double TaperAngle)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_R8 VTS_R8;
	InvokeHelper(0x616, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Profile, Height, TaperAngle);
	return result;
}

LPDISPATCH IAcadModelSpace::AddExtrudedSolidAlongPath(LPDISPATCH Profile, LPDISPATCH Path)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x617, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Profile, Path);
	return result;
}

LPDISPATCH IAcadModelSpace::AddLeader(const VARIANT& PointsArray, LPDISPATCH Annotation, long Type)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_DISPATCH VTS_I4;
	InvokeHelper(0x618, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&PointsArray, Annotation, Type);
	return result;
}

LPDISPATCH IAcadModelSpace::AddMText(const VARIANT& InsertionPoint, double Width, LPCTSTR Text)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_BSTR;
	InvokeHelper(0x619, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&InsertionPoint, Width, Text);
	return result;
}

LPDISPATCH IAcadModelSpace::AddPoint(const VARIANT& Point)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point);
	return result;
}

LPDISPATCH IAcadModelSpace::AddLightWeightPolyline(const VARIANT& VerticesList)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&VerticesList);
	return result;
}

LPDISPATCH IAcadModelSpace::AddPolyline(const VARIANT& VerticesList)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&VerticesList);
	return result;
}

LPDISPATCH IAcadModelSpace::AddRay(const VARIANT& Point1, const VARIANT& Point2)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x61d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point1, &Point2);
	return result;
}

VARIANT IAcadModelSpace::AddRegion(const VARIANT& ObjectList)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ObjectList);
	return result;
}

LPDISPATCH IAcadModelSpace::AddRevolvedSolid(LPDISPATCH Profile, const VARIANT& AxisPoint, const VARIANT& AxisDir, double Angle)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x61f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Profile, &AxisPoint, &AxisDir, Angle);
	return result;
}

LPDISPATCH IAcadModelSpace::AddShape(LPCTSTR Name, const VARIANT& InsertionPoint, double ScaleFactor, double RotationAngle)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT VTS_R8 VTS_R8;
	InvokeHelper(0x620, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, &InsertionPoint, ScaleFactor, RotationAngle);
	return result;
}

LPDISPATCH IAcadModelSpace::AddSolid(const VARIANT& Point1, const VARIANT& Point2, const VARIANT& point3, const VARIANT& Point4)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x621, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point1, &Point2, &point3, &Point4);
	return result;
}

LPDISPATCH IAcadModelSpace::AddSphere(const VARIANT& Center, double Radius)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8;
	InvokeHelper(0x622, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, Radius);
	return result;
}

LPDISPATCH IAcadModelSpace::AddSpline(const VARIANT& PointsArray, const VARIANT& StartTangent, const VARIANT& EndTangent)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x623, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&PointsArray, &StartTangent, &EndTangent);
	return result;
}

LPDISPATCH IAcadModelSpace::AddText(LPCTSTR TextString, const VARIANT& InsertionPoint, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT VTS_R8;
	InvokeHelper(0x624, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		TextString, &InsertionPoint, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddTolerance(LPCTSTR Text, const VARIANT& InsertionPoint, const VARIANT& Direction)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x625, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Text, &InsertionPoint, &Direction);
	return result;
}

LPDISPATCH IAcadModelSpace::AddTorus(const VARIANT& Center, double TorusRadius, double TubeRadius)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8;
	InvokeHelper(0x626, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, TorusRadius, TubeRadius);
	return result;
}

LPDISPATCH IAcadModelSpace::AddTrace(const VARIANT& PointsArray)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x627, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&PointsArray);
	return result;
}

LPDISPATCH IAcadModelSpace::AddWedge(const VARIANT& Center, double Length, double Width, double Height)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x628, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Center, Length, Width, Height);
	return result;
}

LPDISPATCH IAcadModelSpace::AddXline(const VARIANT& Point1, const VARIANT& Point2)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x629, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point1, &Point2);
	return result;
}

LPDISPATCH IAcadModelSpace::InsertBlock(const VARIANT& InsertionPoint, LPCTSTR Name, double Xscale, double Yscale, double Zscale, double Rotation)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_BSTR VTS_R8 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x62a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&InsertionPoint, Name, Xscale, Yscale, Zscale, Rotation);
	return result;
}

LPDISPATCH IAcadModelSpace::AddHatch(long PatternType, LPCTSTR PatternName, BOOL Associativity)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_BOOL;
	InvokeHelper(0x62b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		PatternType, PatternName, Associativity);
	return result;