asdkmyclass.cpp

AutoCAD环境中,自定义实体的很好的例子,有助于ARX开发人员快速掌握自定义实体的技术

// AsdkMyClass.cpp: implementation of the AsdkMyClass class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"
#include "AsdkMyClass.h"
#include "geassign.h"
#include <math.h>
#include "commands.h"

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

#define PI 3.1415926

ACRX_DXF_DEFINE_MEMBERS(AsdkMyClass, AcDbEntity,
						AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
						0, ASDKMYCLASS, SAMP2);
///////////////////////////////////////////////////////////////////
AsdkMyClass::AsdkMyClass(AcGePoint3d basePt, int floorNum,
						 double baseLen, double QCJWid, 
						 double HCJWid, double Hei):m_BasePt(basePt),
m_FloorNum(floorNum), m_baseLen(baseLen), m_LeftCJLen(HCJWid), 
m_RightCJLen(QCJWid), m_BaseHeight(Hei)
{

	ExtendedBaseIni();
	
}
						 
// 计算点坐标的函数
void AsdkMyClass::ExtendedBaseIni()
{
	double transLen;
	
	m_PtArr1[0] = m_BasePt;
	m_PtArr1[1] = Pt2Pt(m_BasePt, PI/2, m_BaseHeight);
	m_PtArr1[2] = Pt2Pt(m_PtArr1[1], 0, m_baseLen);
	m_PtArr1[3] = Pt2Pt(m_BasePt, 0, m_baseLen);
	if (m_FloorNum >= 2)
	{
		transLen = m_baseLen - m_LeftCJLen - m_RightCJLen;
		m_PtArr2[0] = Pt2Pt(m_PtArr1[1], 0, m_LeftCJLen);
		m_PtArr2[1] = Pt2Pt(m_PtArr2[0], PI/2, m_BaseHeight);
		m_PtArr2[2] = Pt2Pt(m_PtArr2[1], 0, transLen);
		m_PtArr2[3] = Pt2Pt(m_PtArr2[0], 0, transLen);
		if (m_FloorNum >=3)
		{
			transLen = transLen - m_LeftCJLen - m_RightCJLen;
			m_PtArr3[0] = Pt2Pt(m_PtArr2[1], 0, m_LeftCJLen);
			m_PtArr3[1] = Pt2Pt(m_PtArr3[0], PI/2, m_BaseHeight);
			m_PtArr3[2] = Pt2Pt(m_PtArr3[1], 0, transLen);
			m_PtArr3[3] = Pt2Pt(m_PtArr3[0], 0, transLen);
			if (m_FloorNum == 4)
			{
				transLen = transLen - m_LeftCJLen - m_RightCJLen;
				m_PtArr4[0] = Pt2Pt(m_PtArr3[1], 0, m_LeftCJLen);
				m_PtArr4[1] = Pt2Pt(m_PtArr4[0], PI/2, m_BaseHeight);
				m_PtArr4[2] = Pt2Pt(m_PtArr4[1], 0, transLen);
				m_PtArr4[3] = Pt2Pt(m_PtArr4[0], 0, transLen);
			}
		}
	}
}

// 读入数据
Acad::ErrorStatus
AsdkMyClass::dwgInFields(AcDbDwgFiler *pFiler)
{

	assertWriteEnabled();
	Acad::ErrorStatus es;
	
    if ((es = AcDbEntity::dwgInFields(pFiler)) != Acad::eOk) 
    {
        return es;
    }

	if (pFiler->filerType() == AcDb::kWblockCloneFiler)
	{
		AcDbHardPointerId id;
		pFiler->readItem(&id);
	}

	pFiler->readItem(&m_BasePt);
	pFiler->readItem(&m_FloorNum);


	for (int i=0; i<4; i++) {
		pFiler->readItem(&m_PtArr1[i]);
	}
	if (m_FloorNum >= 2)
	{
		for (int i=0; i<4; i++) {
			pFiler->readItem(&m_PtArr2[i]);
		}
		if (m_FloorNum >=3)
		{
			for (int i=0; i<4; i++) {
				pFiler->readItem(&m_PtArr3[i]);
			}
			if (m_FloorNum == 4)
			{
				for (int i=0; i<4; i++) {
					pFiler->readItem(&m_PtArr4[i]);
				}
			}
		}
	}


	return pFiler->filerStatus();
}

//  写出数据到DWG文件中
Acad::ErrorStatus
AsdkMyClass::dwgOutFields(AcDbDwgFiler *pFiler) const
{

	assertReadEnabled();
	Acad::ErrorStatus es;
	if ((es=AcDbEntity::dwgOutFields(pFiler))!=Acad::eOk)
	{
		return es;
	}

	if (pFiler->filerType() == AcDb::kWblockCloneFiler)
	{
		pFiler->writeHardPointerId((AcDbHardPointerId)ownerId());
	}
	
	pFiler->writeItem(m_BasePt);
	pFiler->writeItem(m_FloorNum);
	
	for (int i=0; i<4; i++) {
		pFiler->writeItem(m_PtArr1[i]);
	}
	if (m_FloorNum >= 2)
	{
		for (int i=0; i<4; i++) {
			pFiler->writeItem(m_PtArr2[i]);
		}
		if (m_FloorNum >=3)
		{
			for (int i=0; i<4; i++) {
				pFiler->writeItem(m_PtArr3[i]);
			}
			if (m_FloorNum == 4)
			{
				for (int i=0; i<4; i++) {
					pFiler->writeItem(m_PtArr4[i]);
				}
			}
		}
	}

	return pFiler->filerStatus();
}

// 读入数据
Acad::ErrorStatus
AsdkMyClass::dxfInFields(AcDbDxfFiler *pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;
	if ((es = AcDbObject::dxfInFields(pFiler)) != Acad::eOk)
	{
		return es;
	}
	if (! pFiler->atSubclassData("AsdkMyClass"))
	{
		return Acad::eBadDxfSequence;
	}
	return pFiler->filerStatus();
}

// 写出数据到DXF文件中
Acad::ErrorStatus
AsdkMyClass::dxfOutFields(AcDbDxfFiler *pFiler) const
{
	assertReadEnabled();
	AcDbObject::dxfOutFields(pFiler);
	pFiler->writeItem(AcDb::kDxfSubclass, "AsdkMyClass");
	return pFiler->filerStatus();
}

// 对于要在viewportDraw()中实现绘制功能的自定义实体来说，这个函数必须返回false
Adesk::Boolean
AsdkMyClass::worldDraw(AcGiWorldDraw *mode)
{

	return Adesk::kFalse;	
}

// 在这个函数中实现自定义实体的绘制
void 
AsdkMyClass::viewportDraw(AcGiViewportDraw *mode)
{
	
	mode->geometry().polygon(4, m_PtArr1);
	if (m_FloorNum >= 2)
	{
		mode->geometry().polyline(4, m_PtArr2);
		if (m_FloorNum >=3)
		{
			mode->geometry().polyline(4, m_PtArr3);
			if (m_FloorNum == 4)
			{
				mode->geometry().polyline(4, m_PtArr4);
			}
		}
	}
	
	
}

// 
Acad::ErrorStatus 
AsdkMyClass::getGeomExtents(AcDbExtents & extents)
{
	return Acad::eOk;
}

// 几个转换函数，实现几何转换功能
Acad::ErrorStatus 
AsdkMyClass::transformBy(const AcGeMatrix3d & xform)
{
	assertWriteEnabled();
	m_BasePt.transformBy(xform);
	ExtendedBaseIni();
	return Acad::eOk;
}

// 这个函数实现几何转换后新产生一个实体，我没有实现它
Acad::ErrorStatus 
AsdkMyClass::getTransformedCopy(const AcGeMatrix3d &xform,
							    AcDbEntity *&pEnt)
{
	assertReadEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	return es;
}

// 得到假点
Acad::ErrorStatus 
AsdkMyClass::getGripPoints(AcGePoint3dArray & gripPoints,
						   AcDbIntArray     & osnapModes, 
						   AcDbIntArray     & geomIds) const
{
	assertReadEnabled();
	gripPoints.setLogicalLength(0);

	for (int i=0; i<4; i++) {
		gripPoints.append(m_PtArr1[i]);
	}
	if (m_FloorNum >= 2)
	{
		for (int i=1; i<3; i++) {
			gripPoints.append(m_PtArr2[i]);
		}
		if (m_FloorNum >=3)
		{
			for (int i=1; i<3; i++) {
				gripPoints.append(m_PtArr3[i]);
			}
			if (m_FloorNum == 4)
			{
				for (int i=1; i<3; i++) {
					gripPoints.append(m_PtArr4[i]);
				}
			}
		}
	}

	return Acad::eOk;
	
}

// 移动假点时调用这个函数
Acad::ErrorStatus 
AsdkMyClass::moveGripPointsAt(const AcDbIntArray &indices, 
							  const AcGeVector3d &offset)
{
	assertWriteEnabled();
	AcGeVector3d vY(0, 1, 0);
	if (indices.length() == 0 || offset.isZeroLength())
		return Acad::eOk;
	
	int j = indices[0];
	switch(j) {
	case 0:
	case 3:
		return transformBy(AcGeMatrix3d::translation(offset));
		break;
	case 1:
	case 2:{
		vY.y = offset.y;
		m_PtArr1[1] += vY;
		m_PtArr1[2] += vY;
		if (m_FloorNum >=2) {
			m_PtArr2[0] += vY;
			m_PtArr2[1] += 2*vY;
			m_PtArr2[2] += 2*vY;
			m_PtArr2[3] += vY;
			if (m_FloorNum >=3) {
				m_PtArr3[0] += 2*vY;
				m_PtArr3[1] += 3*vY;
				m_PtArr3[2] += 3*vY;
				m_PtArr3[3] += 2*vY;
				if (m_FloorNum == 4) {
					m_PtArr4[0] += 3*vY;
					m_PtArr4[1] += 4*vY;
					m_PtArr4[2] += 4*vY;
					m_PtArr4[3] += 3*vY;
				}
			}
		}
		return Acad::eOk;
		}
		break;
	default:
		break;
	}
	
	return Acad::eOk;	
}

// 得到捕捉点
Acad::ErrorStatus 
AsdkMyClass::getOsnapPoints(AcDb::OsnapMode osnapMode,
							int gsSelectionMark,
							const AcGePoint3d &pickPoint,
							const AcGePoint3d &lastPoint,
							const AcGeMatrix3d &viewXform,
							AcGePoint3dArray &snapPoints,
							AcDbIntArray &geomIds) const 
{
	assertReadEnabled();
	Acad::ErrorStatus es = Acad::eOk;

	switch(osnapMode) {
	case AcDb::kOsModeEnd:{
		snapPoints.append(m_PtArr1[0]);
		snapPoints.append(m_PtArr1[3]);
		switch (m_FloorNum) {
		case 2:
			snapPoints.append(m_PtArr2[1]);
			snapPoints.append(m_PtArr2[2]);
			break;
		case 3:
			snapPoints.append(m_PtArr3[1]);
			snapPoints.append(m_PtArr3[2]);
			break;
		case 4:
			snapPoints.append(m_PtArr4[1]);
			snapPoints.append(m_PtArr4[2]);
			break;
		default:
			snapPoints.append(m_PtArr1[1]);
			snapPoints.append(m_PtArr1[2]);
			break;
		}
	}
		break;
	default:
		return es;
		break;
	}
	return es;
	
}

AcGePoint3d 
AsdkMyClass::Pt2Pt(const AcGePoint3d& BasePt, double angle, double lenth)
{
	AcGePoint3d ResultPt;
	double x = lenth * cos(angle);
	ResultPt.x = BasePt.x + lenth * cos(angle);
	ResultPt.y = BasePt.y + lenth * sin(angle);
	ResultPt.z = BasePt.z;
	return ResultPt;
}

double 
AsdkMyClass::GetBaseHeight()
{
	assertReadEnabled();
	return m_BaseHeight;
}

void   
AsdkMyClass::SetBaseHeight(double h)
{
	assertWriteEnabled();
	m_BaseHeight = h;
}

double 
AsdkMyClass::getBaseLenth()
{
	assertReadEnabled();
	return m_baseLen;
}

void   
AsdkMyClass::SetBaseLenth(double l)
{
	assertWriteEnabled();
	m_baseLen = l;
}

double 
AsdkMyClass::GetLeftCJLenth()
{
	assertReadEnabled();
	return m_LeftCJLen;
}

void   
AsdkMyClass::SetLeftCJLenth(double ll)
{
	assertWriteEnabled();
	m_LeftCJLen = ll;
}

double 
AsdkMyClass::GetRightCJLenth()
{
	assertReadEnabled();
	return m_RightCJLen;
}

void   
AsdkMyClass::SetRightCJLenth(double rl)
{
	assertWriteEnabled();
	m_RightCJLen = rl;
}

int    
AsdkMyClass::GetFloorNum()
{
	assertReadEnabled();
	return m_FloorNum;
}

void   
AsdkMyClass::SetFloorNum(int n)
{
	assertWriteEnabled();
	m_FloorNum = n;
}

AcGePoint3d 
AsdkMyClass::GetBasePoint()
{
	assertReadEnabled();
	return m_BasePt;
}

void		
AsdkMyClass::SetBasePoint(const AcGePoint3d& bp)
{
	assertWriteEnabled();
	m_BasePt = bp;
}

AcGePoint3d 
AsdkMyClass::GetLeftTopPoint()
{
	switch(m_FloorNum) {
	case 1:
		return m_PtArr1[1];
		break;
	case 2:
		return m_PtArr2[1];
		break;
	case 3:
		return m_PtArr3[1];
		break;
	case 4:
		return m_PtArr4[1];
		break;
	default:
		return m_PtArr2[1];
		break;
	}
}

AcGePoint3d 
AsdkMyClass::GetRightTopPoint()
{
	switch(m_FloorNum) {
	case 1:
		return m_PtArr1[2];
		break;
	case 2:
		return m_PtArr2[2];
		break;
	case 3:
		return m_PtArr3[2];
		break;
	case 4:
		return m_PtArr4[2];
		break;
	default:
		return m_PtArr2[2];
		break;
	}
}

AcGePoint3d 
AsdkMyClass::GetRightBasePoint()
{
	return m_PtArr1[3];
}