acad.cpp

ARX/CAD二次开发 toolbar原码

		VTS_BOOL;
	InvokeHelper(0x639, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 bPrefixName);
}

void IAcadModelSpace::Detach()
{
	InvokeHelper(0x63a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// IAcadBlock properties

/////////////////////////////////////////////////////////////////////////////
// IAcadBlock operations

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

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

void IAcadBlock::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 IAcadBlock::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 IAcadBlock::Delete()
{
	InvokeHelper(0x404, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

LPDISPATCH IAcadBlock::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 IAcadBlock::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 IAcadBlock::Add3DPoly(const VARIANT& PointsArray)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x606, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&PointsArray);
	return result;
}

LPDISPATCH IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::AddPoint(const VARIANT& Point)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point);
	return result;
}

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

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

LPDISPATCH IAcadBlock::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 IAcadBlock::AddRegion(const VARIANT& ObjectList)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x61e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		&ObjectList);
	return result;
}

LPDISPATCH IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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 IAcadBlock::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;
}