acad.cpp

ARX/CAD二次开发 toolbar原码

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

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

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

LPDISPATCH IAcadBlock::AddLine(const VARIANT& StartPoint, const VARIANT& EndPoint)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x62d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&StartPoint, &EndPoint);
	return result;
}

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

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

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

LPDISPATCH IAcadBlock::AddMInsertBlock(const VARIANT& InsertionPoint, LPCTSTR Name, double Xscale, double Yscale, double Zscale, double Rotation, long NumRows, long NumColumns, long RowSpacing, long ColumnSpacing)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_BSTR VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x631, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&InsertionPoint, Name, Xscale, Yscale, Zscale, Rotation, NumRows, NumColumns, RowSpacing, ColumnSpacing);
	return result;
}

LPDISPATCH IAcadBlock::AddPolyfaceMesh(const VARIANT& VertexList, const VARIANT& FaceList)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x632, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&VertexList, &FaceList);
	return result;
}

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

LPDISPATCH IAcadBlock::AddDim3PointAngular(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(0x634, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&AngleVertex, &FirstEndPoint, &SecondEndPoint, &TextPoint);
	return result;
}

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

LPDISPATCH IAcadBlock::AttachExternalReference(LPCTSTR PathName, LPCTSTR Name, const VARIANT& InsertionPoint, double Xscale, double Yscale, double Zscale, double Rotation, BOOL bOverlay)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_VARIANT VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_BOOL;
	InvokeHelper(0x636, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		PathName, Name, &InsertionPoint, Xscale, Yscale, Zscale, Rotation, bOverlay);
	return result;
}

void IAcadBlock::Unload()
{
	InvokeHelper(0x637, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAcadBlock::Reload()
{
	InvokeHelper(0x638, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAcadBlock::Bind(BOOL bPrefixName)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x639, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 bPrefixName);
}

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


/////////////////////////////////////////////////////////////////////////////
// IAcadEntity properties

/////////////////////////////////////////////////////////////////////////////
// IAcadEntity operations

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

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

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

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

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

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

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

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

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

long IAcadEntity::GetColor()
{
	long result;
	InvokeHelper(0x500, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
	return result;
}

void IAcadEntity::SetColor(long nNewValue)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x500, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 nNewValue);
}

CString IAcadEntity::GetLayer()
{
	CString result;
	InvokeHelper(0x501, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IAcadEntity::SetLayer(LPCTSTR lpszNewValue)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x501, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 lpszNewValue);
}

CString IAcadEntity::GetLinetype()
{
	CString result;
	InvokeHelper(0x502, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
	return result;
}

void IAcadEntity::SetLinetype(LPCTSTR lpszNewValue)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x502, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 lpszNewValue);
}

double IAcadEntity::GetLinetypeScale()
{
	double result;
	InvokeHelper(0x503, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
	return result;
}

void IAcadEntity::SetLinetypeScale(double newValue)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x503, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 newValue);
}

BOOL IAcadEntity::GetVisible()
{
	BOOL result;
	InvokeHelper(0x504, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
	return result;
}

void IAcadEntity::SetVisible(BOOL bNewValue)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x504, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 bNewValue);
}

VARIANT IAcadEntity::ArrayPolar(long NumberOfObjects, double AngleToFill, const VARIANT& CenterPoint)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_R8 VTS_VARIANT;
	InvokeHelper(0x505, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		NumberOfObjects, AngleToFill, &CenterPoint);
	return result;
}

VARIANT IAcadEntity::ArrayRectangular(long NumberOfRows, long NumberOfColumns, long NumberOfLevels, double DistBetweenRows, double DistBetweenCols, double DistBetweenLevels)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
	InvokeHelper(0x506, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
		NumberOfRows, NumberOfColumns, NumberOfLevels, DistBetweenRows, DistBetweenCols, DistBetweenLevels);
	return result;
}

void IAcadEntity::Highlight(BOOL HighlightFlag)
{
	static BYTE parms[] =
		VTS_BOOL;
	InvokeHelper(0x507, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 HighlightFlag);
}

LPDISPATCH IAcadEntity::Copy()
{
	LPDISPATCH result;
	InvokeHelper(0x508, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return result;
}

void IAcadEntity::Move(const VARIANT& FromPoint, const VARIANT& ToPoint)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x509, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &FromPoint, &ToPoint);
}

void IAcadEntity::Rotate(const VARIANT& BasePoint, double RotationAngle)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_R8;
	InvokeHelper(0x50a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &BasePoint, RotationAngle);
}

void IAcadEntity::Rotate3D(const VARIANT& Point1, const VARIANT& Point2, double RotationAngle)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_R8;
	InvokeHelper(0x50b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &Point1, &Point2, RotationAngle);
}

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

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

void IAcadEntity::ScaleEntity(const VARIANT& BasePoint, double ScaleFactor)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_R8;
	InvokeHelper(0x50e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &BasePoint, ScaleFactor);
}

void IAcadEntity::TransformBy(const VARIANT& TransformationMatrix)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x50f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &TransformationMatrix);
}

void IAcadEntity::Update()
{
	InvokeHelper(0x510, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IAcadEntity::GetBoundingBox(VARIANT* MinPoint, VARIANT* MaxPoint)
{
	static BYTE parms[] =
		VTS_PVARIANT VTS_PVARIANT;
	InvokeHelper(0x511, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 MinPoint, MaxPoint);
}

VARIANT IAcadEntity::IntersectWith(LPDISPATCH IntersectObject, long option)
{
	VARIANT result;