ObjectARX自定义实体

已于 2022-06-24 09:05:42 修改
阅读量6.8k 收藏 55
点赞数 17
分类专栏： ObjectARX 文章标签： ObjectARX
于 2019-04-10 13:49:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/phd17621680432/article/details/89181257
版权

说明： 此次绘制的CAD自定义实体是一个矩形，具有拉伸功能。因为初次接触自定义实体，在一次次制作的过程中遇到了很多困难，幸好有老大和同事的帮助，当然还有广大网友们的文章协助，才完成了这个自定义实体的绘制。我不敢说到目前还会有什么问题，但希望能帮助到别人。

一、需要重载的函数
    //绘制夹点
    virtual Acad::ErrorStatus getGripPoints(AcDbGripDataPtrArray& grips, const double curViewUnitSize, const int gripSize, const AcGeVector3d& curViewDir, const int bitflags) const;
	//移动夹点
	virtual Acad::ErrorStatus moveGripPointsAt(const AcDbVoidPtrArray& gripAppData,const AcGeVector3d& offset,const int bitflags);
	//加载数据
	virtual Acad::ErrorStatus dwgInFields(AcDbDwgFiler* pFiler);
	//保存数据
	virtual Acad::ErrorStatus dwgOutFields(AcDbDwgFiler* pFiler) const;
	//矩阵转换
	virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
	//分解（炸开）
	virtual Acad::ErrorStatus explode(ZcDbVoidPtrArray& entitySet) const;
	//夹点状态
	virtual void gripStatus(const AcDb::GripStat status);
	//实体绘制
	virtual Adesk::Boolean worldDraw(AcGiWorldDraw* pWd);
	//捕捉点
	virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode osnapMode, Adesk::GsMarker gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint,
		const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray & geomIds) const;
	//外包矩形
	virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
	//删除
	virtual	Acad::ErrorStatus erase(Adesk::Boolean erasing = true);
二、成员变量

因为这个自定义实体是矩形，所以是由四个直线组成，且由三个夹点。

	AcDbLine m_lineHori1;
	AcDbLine m_lineHori2;
	AcDbLine m_lineVert1;
	AcDbLine m_lineVert2;

	AcGePoint3d m_ptBase;		
	AcGePoint3d m_ptRight;	
	AcGePoint3d m_ptTop;

所以在写重载函数时，每个直线实体都要写一下。例如在worldDraw函数：

Adesk::Boolean CDiBanCsm::worldDraw(AcGiWorldDraw* pWd)
{
	assertReadEnabled();
	m_lineHori1.worldDraw(pWd);
	m_lineHori2.worldDraw(pWd);
	m_lineVert1.worldDraw(pWd);
	m_lineVert2.worldDraw(pWd);
	return Adesk::kTrue;
}

因为有夹点这个成员变量，所以，在dwgInFields函数、dwgOutFields函数、transformBy函数中也要将夹点添加进去：

Acad::ErrorStatus CDiBanCsm::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	AcDbEntity::dwgInFields(pFiler);

	m_lineHori1.dwgInFields(pFiler);
	m_lineHori2.dwgInFields(pFiler);
	m_lineVert1.dwgInFields(pFiler);
	m_lineVert2.dwgInFields(pFiler);
	
	pFiler->readPoint3d(&m_ptBase);
	pFiler->readPoint3d(&m_ptRight);
	pFiler->readPoint3d(&m_ptTop);

	return pFiler->filerStatus();
}
三、夹点绘制

绘制夹点比较麻烦，如果你不是要绘制夹点的形状，可以重载

Acad::ErrorStatus getGripPoints(
    AcGePoint3dArray& gripPoints, 
    AcDbIntArray & osnapModes, 
    AcDbIntArray & geomIds
) const;

只需要在gripPoints参数中添加夹点坐标就可以，夹点为默认夹点。
这里，我们需要改变夹点的形状，所以这里我们需要绘制夹点。夹点用AcDbGripData类绘制，它是new出来的，所以我们需要将它delete。
我们需要重载gripStatus函数，在AcDb::kGripsDone状态下，将new的AcDbGripData指针delte。
我们要声明一个全局的map变量来存放AcDbGripData指针：

//键：自定义实体指针		值：AcDbGripData指针数组
static std::map<const AcDbEntity*, AcDbGripDataPtrArray> s_mapGripPtr;

直接上代码了：

Acad::ErrorStatus CDiBanCsm::getGripPoints(AcDbGripDataPtrArray& grips, const double curViewUnitSize, 
	const int gripSize, const AcGeVector3d& curViewDir, const int bitflags) const
{
	assertReadEnabled();
	std::vector<CString>::const_iterator appIter = GetGripName();//这里appIter是一个字符串容器，存放的是夹点名称
	AcDbGripDataPtrArray tempGripArr;

	//BasePt
	AcDbGripData* pGripBase = new AcDbGripData();
	pGripBase->setAppData((void*)&(*appIter));//将夹点名称设置到数据中
	pGripBase->setGripPoint(m_ptBase);//设置夹点坐标
	grips.append(pGripBase);
	tempGripArr.append(pGripBase);
	appIter++;

	//RightPt
	AcDbGripData* pGripRight = new AcDbGripData();
	pGripRight->setAppData((void*)&(*appIter));
	pGripRight->setGripPoint(m_ptRight);
	pGripRight->setWorldDraw(DrawStretchGrip);
	grips.append(pGripRight);
	tempGripArr.append(pGripRight);
	appIter++;

	//TopPt
	AcDbGripData* pGripTop = new AcDbGripData();
	pGripTop->setAppData((void*)&(*appIter));
	pGripTop->setGripPoint(m_ptTop);
	pGripTop->setWorldDraw(DrawStretchGrip);
	grips.append(pGripTop);
	tempGripArr.append(pGripTop);
	appIter++;

	auto a = this;
	CCustomBase::s_mapGripPtr[this] = tempGripArr;//将new出来的AcDbGripData指针添加到s_mapGripPtr变量中
	return Acad::eOk;
}

bool CDiBanCsm::DrawStretchGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize)
{
	dGripSize *= CCustomBase::s_gripSize / 2;//夹点的大小 CCustomBase::s_gripSize == 2.8
	AcGePoint3d	pt = pThis->gripPoint();
	CString* pStr = (CString*)(pThis->appData());
	AcGeVector3d vec = AcGeVector3d::kXAxis;
	AcDbObjectPointer<CDiBanCsm> m_pDiBan(entId, AcDb::kForRead);
	if (m_pDiBan.openStatus() != Acad::eOk)
		return false;

	if (*pStr == _T("RightPt"))
		vec = m_pDiBan->GetHoriDirection().normal();//得到实体的水平向量，这个接口自己写，通过直线的两点坐标
	else if (*pStr == _T("TopPt"))
		vec = m_pDiBan->GetVertDirection().normal();//得到实体的垂直向量

	auto vecUp = AcGeVector3d::kZAxis.crossProduct(vec).normal();
	AcGePoint3d pts[3];
	pts[0] = pt + vec * dGripSize;
	pts[1] = pt - vec * dGripSize / 2 + vecUp * dGripSize * .7;
	pts[2] = pt - vec * dGripSize / 2 - vecUp * dGripSize * .7;

	pWd->subEntityTraits().setFillType(kAcGiFillAlways);
	pWd->geometry().polygon(3, pts);

	return true;
}

在重载的gripStatus函数中delete夹点指针

void CDiBanCsm::gripStatus(const AcDb::GripStat status)
{
	AcDbEntity::gripStatus(status);

	switch (status)
	{
	case AcDb::kGripsDone:
		CCustomBase::DeleteGrip(this);
		break;
	case AcDb::kGripsToBeDeleted:
		
		break;
	case AcDb::kDimDataToBeDeleted:

		break;
	}
}

bool CCustomBase::DeleteGrip(const AcDbEntity* pEnt)
{
	std::map<const AcDbEntity*, AcDbGripDataPtrArray>::iterator iter;
	for (iter = s_mapGripPtr.begin(); iter != s_mapGripPtr.end(); iter++)
	{
		if (pEnt == iter->first)
		{
			AcDbGripDataPtrArray tempGripArr = iter->second;
			for (int i = 0; i < tempGripArr.length(); ++i)
			{
				DEL(tempGripArr[i]);//这里delete 指针
				tempGripArr[i] = NULL;
			}
		}
	}
	int n = CCustomBase::s_mapGripPtr.erase(pEnt);//如果删除了会返回1，否则返回0  
	return n;
}

移动夹点就比较简单了，重写moveGripPointsAt函数就可以了

Acad::ErrorStatus CDiBanCsm::moveGripPointsAt(const AcDbVoidPtrArray& gripAppData,const AcGeVector3d& offset,
const int bitflags)
{
	assertWriteEnabled();
	CString* pStrTemp = NULL;
	for (int i = 0; i < gripAppData.length(); i++)
	{
		pStrTemp = static_cast<CString*>(gripAppData[i]);
		if (*pStrTemp == _T("BasePt"))//通过点的名称，判断移动的是哪个夹点
		{
			//这里我是通过偏移向量，来移动直线的两点位置
			SetLinePoint(m_lineHori1, 3, offset);
			SetLinePoint(m_lineHori2, 3, offset);
			SetLinePoint(m_lineVert1, 3, offset);
			SetLinePoint(m_lineVert2, 3, offset);
			m_ptBase = GetBaseGripPt();//重新定义夹点的位置
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
		else if (*pStrTemp == _T("RightPt"))
		{
			AcGePoint3d ptStart = m_lineHori2.startPoint();
			AcGePoint3d ptEnd = m_lineHori2.endPoint();
			AcGeVector3d vctHori = ptEnd - ptStart;
			AcGeVector3d vctOffset = GetProjectVector(m_ptBase, offset, vctHori);
			SetLinePoint(m_lineHori1,2,vctOffset);
			SetLinePoint(m_lineHori2, 2, vctOffset);
			SetLinePoint(m_lineVert2, 3, vctOffset);
			m_ptBase = GetBaseGripPt();
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
		else if (*pStrTemp == _T("TopPt"))
		{
			AcGePoint3d ptStart = m_lineVert1.startPoint();
			AcGePoint3d ptEnd = m_lineVert1.endPoint();
			AcGeVector3d vctHori = ptEnd - ptStart;
			AcGeVector3d vctOffset = GetProjectVector(m_ptBase, offset, vctHori);
			SetLinePoint(m_lineVert1, 2, vctOffset);
			SetLinePoint(m_lineVert2, 2, vctOffset);
			SetLinePoint(m_lineHori1, 3, vctOffset);
			m_ptBase = GetBaseGripPt();
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
	}
	return Acad::eOk;
}

AcGeVector3d CCustomBase::GetProjectVector(const AcGePoint3d& ptBase, const AcGeVector3d& vctOffset, const AcGeVector3d& vctDirection)
{//得到某一向量在指定向量上的投影向量
	AcGePoint3d ptOffset = ptBase + vctOffset;
	AcGeLine3d geLine(ptBase, vctDirection);
	AcGePoint3d ptTarget = geLine.closestPointTo(ptOffset);
	return ptTarget - ptBase;
}
四、实体分解

需要重写explode函数，这里有两个知识要说，一个是如果自定义实体可以分解，需要添加克隆的直线指针

Acad::ErrorStatus CDiBanCsm::explode(ZcDbVoidPtrArray& entitySet) const
{
	assertReadEnabled();
 	entitySet.append(m_lineHori1.clone());
 	entitySet.append(m_lineHori2.clone());
 	entitySet.append(m_lineVert1.clone());
 	entitySet.append(m_lineVert2.clone());
	return Acad::eOk;
}

如果你想让自定义实体不能分解，返回值返回：Acad::eCannotExplodeEntity即可。

五、总结

其实原本的代码比这个多很多，这里我只是截取了重要部分展示。这是目前绘制的自定义实体，某些地方还需要改进。

六、源码展示

这篇文章本来是已经删掉的，因为我觉得自己写的这个自定义实体比较垃圾，但是删掉后发现别人还是能看，也能收到评论，就感觉许多人都有这个自定义实体这个需求的，今天准备把源码贴出来。在这里我要简单说明一下，这篇文章是当初学习ObjectArx自定义实体时写的，例子也是当时写的。主要功能实现是做了一个矩形自定义实体，这个实体选中后会显示三个夹点，实体位置夹点、向上拉伸夹点、向右拉伸夹点，且具有移动和拉伸功能。当时测试过，应该是没什么问题的，如果有问题的话也不要@我了。总共2个类，4个文件。

CCustomBase.h

#pragma once

/*
//自定义实体初始化
CDiBanCsm::rxInit();
acrxBuildClassHierarchy();
//自定义实体删除
deleteAcRxClass(CDiBanCsm::desc());
*/

//自定义实体基类
class CCustomBase :public AcDbEntity
{
public:
	CCustomBase();
	~CCustomBase();

	virtual Adesk::Boolean worldDraw(AcGiWorldDraw* pWd);
	virtual Acad::ErrorStatus dwgInFields(AcDbDwgFiler* pFiler);
	virtual Acad::ErrorStatus dwgOutFields(AcDbDwgFiler* pFiler) const;
	virtual Acad::ErrorStatus dxfInFields(AcDbDxfFiler* pFiler);
	virtual Acad::ErrorStatus dxfOutFields(AcDbDxfFiler* pFiler) const;
	virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode osnapMode, Adesk::GsMarker gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint,
		const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray & geomIds) const;
	virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
	virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
	virtual Acad::ErrorStatus getTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const;
	virtual	Acad::ErrorStatus erase(Adesk::Boolean erasing = true);

protected:
#pragma region 辅助函数
	std::vector<CString>::const_iterator GetGripName() const;//记录夹点的名称

	//************************************
	// Summary: 	得到X轴或Y轴偏移点后的点坐标
	// Parameters: 	
	//    ptBase		- 	输入要偏移的点坐标
	//    dX		- 	输入X轴偏移距离
	//    dY		- 	输入Y轴偏移距离
	// Returns:   	
	//************************************
	AcGePoint3d GetOffsetPt(const AcGePoint3d& ptBase, double dX, double dY);

	//************************************
	// Summary: 	得到某一向量在指定向量上的投影向量
	// Parameters: 	
	//    ptBase		- 	输入两个向量的交点
	//    vctOffset		- 	输入某一向量
	//    vctDirection		- 	输入指定向量
	// Returns:   	
	//************************************
	AcGeVector3d GetProjectVector(const AcGePoint3d& ptBase, const AcGeVector3d& vctOffset, const AcGeVector3d& vctDirection);
	
	//************************************
	// Summary: 	通过偏移向量移动直线的点坐标
	// Parameters: 	
	//    pLine		- 	输入直线指针
	//    nType		- 	输入类型（1：移动起点，2：移动终点，3：都移动）
	//    vctOffset		- 	输入偏移向量
	// Returns:   	
	//************************************
	void SetLinePoint(AcDbLine& line, int nType, const AcGeVector3d& vctOffset);//设置直线偏移点
	
#pragma endregion 辅助函数

#pragma region 夹点
public:
	static double s_gripSize;	//夹点的大小
	static std::map<const AcDbEntity*, AcDbGripDataPtrArray> s_mapGripPtr;

	//delete夹点
	static bool DeleteGrip(const AcDbEntity* pEnt);
#pragma endregion 夹点

protected:
	AcArray<AcDbEntity*> m_arrEntPtr;
	std::vector<CString> m_vecGripName;
};

CCustomBase.cpp

#include "StdAfx.h"
#include "CCustomBase.h"
#include <strsafe.h>

double CCustomBase::s_gripSize = 2.8;
std::map<const AcDbEntity*, AcDbGripDataPtrArray> CCustomBase::s_mapGripPtr;

CCustomBase::CCustomBase()
{
}


CCustomBase::~CCustomBase()
{
}

Adesk::Boolean CCustomBase::worldDraw(AcGiWorldDraw* pWd)
{
	assertReadEnabled();
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->worldDraw(pWd);
	}
	return Adesk::kTrue;
}

Acad::ErrorStatus CCustomBase::dwgInFields(AcDbDwgFiler* pFiler)
{
	//读取数据
	assertWriteEnabled();
	AcDbEntity::dwgInFields(pFiler);
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->dwgInFields(pFiler);
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus CCustomBase::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	//存入数据
	assertReadEnabled();
	AcDbEntity::dwgOutFields(pFiler);
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->dwgOutFields(pFiler);
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus CCustomBase::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CCustomBase::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CCustomBase::getOsnapPoints(AcDb::OsnapMode osnapMode, Adesk::GsMarker gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray & geomIds) const
{
	assertReadEnabled();
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
	}
	return Acad::eOk;
}

Acad::ErrorStatus CCustomBase::getGeomExtents(AcDbExtents& extents) const
{
	assertReadEnabled();
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		AcDbExtents ext;
		m_arrEntPtr[i]->getGeomExtents(ext);
		extents.addExt(ext);
	}
	return Acad::eOk;
}

Acad::ErrorStatus CCustomBase::transformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->transformBy(xform);
	}
	return AcDbEntity::transformBy(xform);
}

Acad::ErrorStatus CCustomBase::getTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const
{
	assertReadEnabled();
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->getTransformedCopy(xform, ent);
	}
	return AcDbEntity::getTransformedCopy(xform, ent);
}

Acad::ErrorStatus CCustomBase::erase(Adesk::Boolean erasing /*= true*/)
{
	assertWriteEnabled();
	for (int i = 0; i < m_arrEntPtr.length(); ++i)
	{
		m_arrEntPtr[i]->erase(erasing);
	}
	return Acad::eOk;
}

std::vector<CString>::const_iterator CCustomBase::GetGripName() const
{
	return m_vecGripName.begin();
}

AcGePoint3d CCustomBase::GetOffsetPt(const AcGePoint3d& ptBase, double dX, double dY)
{
	AcGePoint3d ptTemp = ptBase;
	ptTemp.x += dX;
	ptTemp.y += dY;
	return ptTemp;
}

AcGeVector3d CCustomBase::GetProjectVector(const AcGePoint3d& ptBase, const AcGeVector3d& vctOffset, const AcGeVector3d& vctDirection)
{
	AcGePoint3d ptOffset = ptBase + vctOffset;
	AcGeLine3d geLine(ptBase, vctDirection);
	AcGePoint3d ptTarget = geLine.closestPointTo(ptOffset);
	return ptTarget - ptBase;
}

void CCustomBase::SetLinePoint(AcDbLine& line, int nType, const AcGeVector3d& vctOffset)
{
	AcGePoint3d ptStart = line.startPoint();
	AcGePoint3d ptEnd = line.endPoint();
	switch (nType)
	{
	case 1://移动起点
		ptStart += vctOffset;
		line.setStartPoint(ptStart);
		break;
	case 2://移动终点
		ptEnd += vctOffset;
		line.setEndPoint(ptEnd);
		break;
	case 3://移动起点和终点
		ptStart += vctOffset;
		line.setStartPoint(ptStart);
		ptEnd += vctOffset;
		line.setEndPoint(ptEnd);
		break;
	default:
		break;
	}
}

bool CCustomBase::DeleteGrip(const AcDbEntity* pEnt)
{
	std::map<const AcDbEntity*, AcDbGripDataPtrArray>::iterator iter;
	for (iter = s_mapGripPtr.begin(); iter != s_mapGripPtr.end(); iter++)
	{
		if (pEnt == iter->first)
		{
			AcDbGripDataPtrArray tempGripArr = iter->second;
			for (int i = 0; i < tempGripArr.length(); ++i)
			{
				AcDbGripData* pGrip = tempGripArr[i];
				DEL(tempGripArr[i]);
				tempGripArr[i] = NULL;
			}
		}
	}
	int n = CCustomBase::s_mapGripPtr.erase(pEnt);//如果删除了会返回1，否则返回0  
	return n;
}

CDiBanCsm.h

#pragma once
#include "CCustomBase.h"

//底板
class CDiBanCsm :public CCustomBase
{
public:
	ACRX_DECLARE_MEMBERS(CDiBanCsm);

	CDiBanCsm();
	CDiBanCsm(const AcGePoint3d& ptBase,double dLength,double dWidth);
	CDiBanCsm(const CDiBanCsm& obj);//拷贝构造函数
	~CDiBanCsm();

#pragma region 重载函数
	virtual Acad::ErrorStatus getGripPoints(AcDbGripDataPtrArray& grips, const double curViewUnitSize, const int gripSize, const AcGeVector3d& curViewDir, const int bitflags) const;
	virtual Acad::ErrorStatus moveGripPointsAt(const AcDbVoidPtrArray& gripAppData,const AcGeVector3d& offset,const int bitflags);
	virtual Acad::ErrorStatus dwgInFields(AcDbDwgFiler* pFiler);//加载
	virtual Acad::ErrorStatus dwgOutFields(AcDbDwgFiler* pFiler) const;//保存
	virtual Acad::ErrorStatus transformBy(const AcGeMatrix3d& xform);
	virtual Acad::ErrorStatus explode(ZcDbVoidPtrArray& entitySet) const;
	virtual void gripStatus(const AcDb::GripStat status);

	virtual Adesk::Boolean worldDraw(AcGiWorldDraw* pWd);//绘制
	virtual Acad::ErrorStatus dxfInFields(AcDbDxfFiler* pFiler);
	virtual Acad::ErrorStatus dxfOutFields(AcDbDxfFiler* pFiler) const;
	virtual Acad::ErrorStatus getOsnapPoints(AcDb::OsnapMode osnapMode, Adesk::GsMarker gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint,
		const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray & geomIds) const;
	virtual Acad::ErrorStatus getGeomExtents(AcDbExtents& extents) const;
	virtual Acad::ErrorStatus getTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const;
	virtual	Acad::ErrorStatus erase(Adesk::Boolean erasing = true);
	
#pragma endregion 重载函数

#pragma region 接口
	bool SetPosition(const AcGePoint3d& pt);//设置基点位置
	bool SetRotation(double dAngle);//设置旋转角度
	AcGeVector3d GetHoriDirection() const;//得到水平向量
	AcGeVector3d GetVertDirection() const;//得到垂直向量
#pragma endregion 接口

#pragma region 辅助函数
protected:
	//得到夹点坐标
	AcGePoint3d GetBaseGripPt() const;
	AcGePoint3d GetRightGripPt() const;
	AcGePoint3d GetTopGripPt() const;
#pragma endregion 辅助函数

#pragma region 夹点
public:
	//拉伸夹点
	static bool DrawStretchGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize);
	//转换夹点
	static bool DrawSwitchGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize);
	//枚举夹点
	static bool DrawEnumGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize);
#pragma endregion 夹点

protected:
	AcDbLine m_lineHori1;
	AcDbLine m_lineHori2;
	AcDbLine m_lineVert1;
	AcDbLine m_lineVert2;

	AcGePoint3d m_ptBase;	
	AcGePoint3d m_ptRight;	
	AcGePoint3d m_ptTop;
	double m_dLength;
	double m_dWidth;

};

CDiBanCsm.cpp

#include "StdAfx.h"
#include "CDiBanCsm.h"


ACRX_DXF_DEFINE_MEMBERS(CDiBanCsm, AcDbEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
	AcDbProxyEntity::kNoOperation, CDiBanCsm, ZwCad);


CDiBanCsm::CDiBanCsm()
{
	m_arrEntPtr.append(&m_lineHori1);
	m_arrEntPtr.append(&m_lineHori2);
	m_arrEntPtr.append(&m_lineVert1);
	m_arrEntPtr.append(&m_lineVert2);

	m_vecGripName.clear();
	m_vecGripName.push_back(_T("BasePt"));
	m_vecGripName.push_back(_T("RightPt"));
	m_vecGripName.push_back(_T("TopPt"));
}


CDiBanCsm::CDiBanCsm(const AcGePoint3d& ptBase, double dLength, double dWidth)
	:m_ptBase(ptBase),m_dLength(dLength),m_dWidth(dWidth)
{
	//实体初始化
	m_ptRight = GetOffsetPt(m_ptBase, m_dLength, m_dWidth / 2);
	m_ptTop = GetOffsetPt(m_ptBase, m_dLength / 2, m_dWidth);

	m_lineHori1.setStartPoint(GetOffsetPt(m_ptBase,0, m_dWidth));
	m_lineHori1.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, m_dWidth));

	m_lineHori2.setStartPoint(m_ptBase);
	m_lineHori2.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, 0));

	m_lineVert1.setStartPoint(m_ptBase);
	m_lineVert1.setEndPoint(GetOffsetPt(m_ptBase, 0, m_dWidth));

	m_lineVert2.setStartPoint(GetOffsetPt(m_ptBase, m_dLength, 0));
	m_lineVert2.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, m_dWidth));
	//添加实体指针，用于调用基类
	m_arrEntPtr.append(&m_lineHori1);
	m_arrEntPtr.append(&m_lineHori2);
	m_arrEntPtr.append(&m_lineVert1);
	m_arrEntPtr.append(&m_lineVert2);
	
	//添加夹点类型
	m_vecGripName.clear();
	m_vecGripName.push_back(_T("BasePt"));
	m_vecGripName.push_back(_T("RightPt"));
	m_vecGripName.push_back(_T("TopPt"));
}

CDiBanCsm::CDiBanCsm(const CDiBanCsm& obj)
{
	m_lineHori1.setStartPoint(obj.m_lineHori1.startPoint());
	m_lineHori1.setEndPoint(obj.m_lineHori1.endPoint());

	m_lineHori2.setStartPoint(obj.m_lineHori2.startPoint());
	m_lineHori2.setEndPoint(obj.m_lineHori2.endPoint());

	m_lineVert1.setStartPoint(obj.m_lineVert1.startPoint());
	m_lineVert1.setEndPoint(obj.m_lineVert1.endPoint());

	m_lineVert2.setStartPoint(obj.m_lineVert2.startPoint());
	m_lineVert2.setEndPoint(obj.m_lineVert2.endPoint());

	m_ptBase = obj.m_ptBase;
	m_ptRight = obj.m_ptRight;
	m_ptTop = obj.m_ptTop;
	m_dLength = obj.m_dLength;
	m_dWidth = obj.m_dWidth;

	//添加实体指针，用于调用基类
	m_arrEntPtr.append(&m_lineHori1);
	m_arrEntPtr.append(&m_lineHori2);
	m_arrEntPtr.append(&m_lineVert1);
	m_arrEntPtr.append(&m_lineVert2);
	//添加夹点类型
	m_vecGripName.clear();
	m_vecGripName.push_back(_T("BasePt"));
	m_vecGripName.push_back(_T("RightPt"));
	m_vecGripName.push_back(_T("TopPt"));
}

CDiBanCsm::~CDiBanCsm()
{
}

Adesk::Boolean CDiBanCsm::worldDraw(AcGiWorldDraw* pWd)
{
	assertReadEnabled();
	return CCustomBase::worldDraw(pWd);
}

Acad::ErrorStatus CDiBanCsm::dwgInFields(AcDbDwgFiler* pFiler)
{//读取数据
	assertWriteEnabled();
	CCustomBase::dwgInFields(pFiler);
	pFiler->readPoint3d(&m_ptBase);
	pFiler->readPoint3d(&m_ptRight);
	pFiler->readPoint3d(&m_ptTop);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CDiBanCsm::dwgOutFields(AcDbDwgFiler* pFiler) const
{//存入数据
	assertReadEnabled();
	CCustomBase::dwgOutFields(pFiler);
	pFiler->writePoint3d(m_ptBase);
	pFiler->writePoint3d(m_ptRight);
	pFiler->writePoint3d(m_ptTop);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CDiBanCsm::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CDiBanCsm::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CDiBanCsm::getGripPoints(AcDbGripDataPtrArray& grips, const double curViewUnitSize, 
	const int gripSize, const AcGeVector3d& curViewDir, const int bitflags) const
{
	assertReadEnabled();
	std::vector<CString>::const_iterator appIter = GetGripName();
	AcDbGripDataPtrArray tempGripArr;

	//BasePt
	AcDbGripData* pGripBase = new AcDbGripData();
	pGripBase->setAppData((void*)&(*appIter));
	pGripBase->setGripPoint(m_ptBase);
	grips.append(pGripBase);
	tempGripArr.append(pGripBase);
	appIter++;

	//RightPt
	AcDbGripData* pGripRight = new AcDbGripData();
	pGripRight->setAppData((void*)&(*appIter));
	pGripRight->setGripPoint(m_ptRight);
	pGripRight->setWorldDraw(DrawStretchGrip);
	grips.append(pGripRight);
	tempGripArr.append(pGripRight);
	appIter++;

	//TopPt
	AcDbGripData* pGripTop = new AcDbGripData();
	pGripTop->setAppData((void*)&(*appIter));
	pGripTop->setGripPoint(m_ptTop);
	pGripTop->setWorldDraw(DrawStretchGrip);
	grips.append(pGripTop);
	tempGripArr.append(pGripTop);
	appIter++;

	auto a = this;
	CCustomBase::s_mapGripPtr[this] = tempGripArr;
	return Acad::eOk;
}

Acad::ErrorStatus CDiBanCsm::moveGripPointsAt(const AcDbVoidPtrArray& gripAppData,const AcGeVector3d& offset,
const int bitflags)
{
	assertWriteEnabled();
	CString* pStrTemp = NULL;
	for (int i = 0; i < gripAppData.length(); i++)
	{
		pStrTemp = static_cast<CString*>(gripAppData[i]);
		if (*pStrTemp == _T("BasePt"))
		{
			SetLinePoint(m_lineHori1, 3, offset);
			SetLinePoint(m_lineHori2, 3, offset);
			SetLinePoint(m_lineVert1, 3, offset);
			SetLinePoint(m_lineVert2, 3, offset);
			m_ptBase = GetBaseGripPt();
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
		else if (*pStrTemp == _T("RightPt"))
		{
			AcGePoint3d ptStart = m_lineHori2.startPoint();
			AcGePoint3d ptEnd = m_lineHori2.endPoint();
			AcGeVector3d vctHori = ptEnd - ptStart;
			AcGeVector3d vctOffset = GetProjectVector(m_ptBase, offset, vctHori);
			SetLinePoint(m_lineHori1,2,vctOffset);
			SetLinePoint(m_lineHori2, 2, vctOffset);
			SetLinePoint(m_lineVert2, 3, vctOffset);
			m_ptBase = GetBaseGripPt();
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
		else if (*pStrTemp == _T("TopPt"))
		{
			AcGePoint3d ptStart = m_lineVert1.startPoint();
			AcGePoint3d ptEnd = m_lineVert1.endPoint();
			AcGeVector3d vctHori = ptEnd - ptStart;
			AcGeVector3d vctOffset = GetProjectVector(m_ptBase, offset, vctHori);
			SetLinePoint(m_lineVert1, 2, vctOffset);
			SetLinePoint(m_lineVert2, 2, vctOffset);
			SetLinePoint(m_lineHori1, 3, vctOffset);
			m_ptBase = GetBaseGripPt();
			m_ptRight = GetRightGripPt();
			m_ptTop = GetTopGripPt();
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus CDiBanCsm::getOsnapPoints(AcDb::OsnapMode osnapMode, Adesk::GsMarker gsSelectionMark, 
	const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform,
	AcGePoint3dArray& snapPoints, AcDbIntArray & geomIds) const
{
	assertReadEnabled();
	return CCustomBase::getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform,
		snapPoints, geomIds);
}

Acad::ErrorStatus CDiBanCsm::getGeomExtents(AcDbExtents& extents) const
{
	assertReadEnabled();
	return CCustomBase::getGeomExtents(extents);
}

Acad::ErrorStatus CDiBanCsm::transformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	m_ptBase.transformBy(xform);
	m_ptRight.transformBy(xform);
	m_ptTop.transformBy(xform);

	return CCustomBase::transformBy(xform);
}

Acad::ErrorStatus CDiBanCsm::getTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const
{
	assertReadEnabled();
	return CCustomBase::getTransformedCopy(xform, ent);
}

Acad::ErrorStatus CDiBanCsm::explode(ZcDbVoidPtrArray& entitySet) const
{
	assertReadEnabled();
// 	entitySet.append(m_lineHori1.clone());
// 	entitySet.append(m_lineHori2.clone());
// 	entitySet.append(m_lineVert1.clone());
// 	entitySet.append(m_lineVert2.clone());
	return Acad::eCannotExplodeEntity;
}

Acad::ErrorStatus CDiBanCsm::erase(Adesk::Boolean erasing /*= true*/)
{
	assertWriteEnabled();
	return CCustomBase::erase(erasing);
}

bool CDiBanCsm::SetPosition(const AcGePoint3d& pt)
{
	assertWriteEnabled();
	AcGeVector3d offset = pt - m_ptBase;
	SetLinePoint(m_lineHori1, 3, offset);
	SetLinePoint(m_lineHori2, 3, offset);
	SetLinePoint(m_lineVert1, 3, offset);
	SetLinePoint(m_lineVert2, 3, offset);
	m_ptBase = GetBaseGripPt();
	m_ptRight = GetRightGripPt();
	m_ptTop = GetTopGripPt();
	return true;
}

bool CDiBanCsm::SetRotation(double dAngle)
{
	assertWriteEnabled();
	m_lineHori1.setStartPoint(GetOffsetPt(m_ptBase, 0, m_dWidth).rotateBy(dAngle,AcGeVector3d::kZAxis,m_ptBase));
	m_lineHori1.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, m_dWidth).rotateBy(dAngle, AcGeVector3d::kZAxis, m_ptBase));
	m_lineHori2.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, 0).rotateBy(dAngle, AcGeVector3d::kZAxis, m_ptBase));
	m_lineVert1.setEndPoint(GetOffsetPt(m_ptBase, 0, m_dWidth).rotateBy(dAngle, AcGeVector3d::kZAxis, m_ptBase));
	m_lineVert2.setStartPoint(GetOffsetPt(m_ptBase, m_dLength, 0).rotateBy(dAngle, AcGeVector3d::kZAxis, m_ptBase));
	m_lineVert2.setEndPoint(GetOffsetPt(m_ptBase, m_dLength, m_dWidth).rotateBy(dAngle, AcGeVector3d::kZAxis, m_ptBase));
	m_ptBase = GetBaseGripPt();
	m_ptRight = GetRightGripPt();
	m_ptTop = GetTopGripPt();
	return true;
}

AcGeVector3d CDiBanCsm::GetHoriDirection() const
{
	AcGePoint3d ptStart = m_lineHori2.startPoint();
	AcGePoint3d ptEnd = m_lineHori2.endPoint();
	return ptEnd - ptStart;
}

AcGeVector3d CDiBanCsm::GetVertDirection() const
{
	AcGePoint3d ptStart = m_lineVert1.startPoint();
	AcGePoint3d ptEnd = m_lineVert1.endPoint();
	return ptEnd - ptStart;
}

void CDiBanCsm::gripStatus(const AcDb::GripStat status)
{
	AcDbEntity::gripStatus(status);

	switch (status)
	{
	case AcDb::kGripsDone:
		CCustomBase::DeleteGrip(this);
		break;
	case AcDb::kGripsToBeDeleted:
		
		break;
	case AcDb::kDimDataToBeDeleted:

		break;
	}
}

AcGePoint3d CDiBanCsm::GetBaseGripPt() const
{
	return m_lineHori2.startPoint();
}

AcGePoint3d CDiBanCsm::GetRightGripPt() const
{
	AcGePoint3d ptStart = m_lineVert2.startPoint();
	AcGePoint3d ptEnd = m_lineVert2.endPoint();
	return AcGePoint3d((ptStart.x + ptEnd.x)/2,(ptStart.y + ptEnd.y)/2,(ptStart.z + ptEnd.z)/2);
}

AcGePoint3d CDiBanCsm::GetTopGripPt() const
{
	AcGePoint3d ptStart = m_lineHori1.startPoint();
	AcGePoint3d ptEnd = m_lineHori1.endPoint();
	return AcGePoint3d((ptStart.x + ptEnd.x) / 2, (ptStart.y + ptEnd.y) / 2, (ptStart.z + ptEnd.z) / 2);
}

bool CDiBanCsm::DrawStretchGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize)
{
	dGripSize *= CCustomBase::s_gripSize / 2;
	AcGePoint3d	pt = pThis->gripPoint();
	CString* pStr = (CString*)(pThis->appData());
	AcGeVector3d vec = AcGeVector3d::kXAxis;
	AcDbObjectPointer<CDiBanCsm> m_pDiBan(entId, AcDb::kForRead);
	if (m_pDiBan.openStatus() != Acad::eOk)
		return false;

	if (*pStr == _T("RightPt"))
		vec = m_pDiBan->GetHoriDirection().normal();
	else if (*pStr == _T("TopPt"))
		vec = m_pDiBan->GetVertDirection().normal();

	auto vecUp = AcGeVector3d::kZAxis.crossProduct(vec).normal();
	AcGePoint3d pts[3];
	pts[0] = pt + vec * dGripSize;
	pts[1] = pt - vec * dGripSize / 2 + vecUp * dGripSize * .7;
	pts[2] = pt - vec * dGripSize / 2 - vecUp * dGripSize * .7;

	pWd->subEntityTraits().setFillType(kAcGiFillAlways);
	pWd->geometry().polygon(3, pts);

	return true;
}

bool CDiBanCsm::DrawSwitchGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize)
{
	dGripSize *= CCustomBase::s_gripSize / 2;
	AcGePoint3d	pt = pThis->gripPoint();
	AcGeVector3d vec = AcGeVector3d::kXAxis;

	auto vecUp = AcGeVector3d::kZAxis.crossProduct(vec).normal();
	AcGePoint3d ptsRec[4];
	ptsRec[0] = pt + vecUp * dGripSize;
	ptsRec[1] = pt + vecUp * dGripSize - vec * dGripSize;
	ptsRec[2] = pt - vecUp * dGripSize - vec * dGripSize;
	ptsRec[3] = pt - vecUp * dGripSize;

	AcGePoint3d ptsArr[3];
	ptsArr[0] = pt + vec * dGripSize * 2.4;
	ptsArr[1] = pt + vec * dGripSize + vecUp * dGripSize;
	ptsArr[2] = pt + vec * dGripSize - vecUp * dGripSize;

	pWd->subEntityTraits().setFillType(kAcGiFillAlways);

	pWd->geometry().polygon(4, ptsRec);
	pWd->geometry().polygon(3, ptsArr);
	return true;
}

bool CDiBanCsm::DrawEnumGrip(AcDbGripData *pThis, AcGiWorldDraw *pWd, const AcDbObjectId& entId, AcDbGripOperations::DrawType type, AcGePoint3d *cursor, double dGripSize)
{
	dGripSize *= CCustomBase::s_gripSize / 2;
	AcGePoint3d	pt = pThis->gripPoint();

	// 中心圆
	pWd->subEntityTraits().setFillType(kAcGiFillAlways);
	pWd->geometry().circle(pt, dGripSize, AcGeVector3d::kZAxis);

	return true;
}
A彡安静氵
关注
专栏目录
ObjectARX_for_AutoCAD_2023_Win_64bit
05-13
ObjectARX是AutoDesk公司针对AutoCAD平台上的二次开发而推出的一个开发软件包，它提供了以C++为基础的面向对象的开发环境及应用程序接口，能真正快速的访问AutoCAD图形数据库。 与以往的 AutoCAD 二次开发工具 AutoLISP 和ADS不同，ObjectARX应用程序是一个DLL（动态链接库），共享AutoCAD的地址空间，对AutoCAD进行直接函数调用。所以，使用ARX编程的函数的执行速度得以大大提高。ARX 类库采用了标准的C++类库的封装形式，这也大大提高了程序员编程的可靠度和效率。
＜七＞ objectARX开发：创建自定义实体
欧特GO
08-27 1588
objectARX开发：创建自定义实体，实现实体夹点效果
ObjectARX 介绍
最新发布
qq_32813921的博客
08-06 794
ObjectARX 是一个面向对象的 C++ 应用程序设计接口，为开发者提供了一个强大的环境，用于自定义和扩展 AutoCAD
ObjectARX简单自定义实体的实现
_Santiago的博客
12-05 7693
本文以VS2017+ObjectARX2019+cad2020进行演示说明，介绍了ObjectARX中自定义实体的实现方法。
ObjectArx自定义实体
panzhijiepanzhiyang的专栏
01-15 4192
1.arx文档中规定的必须重写的几个函数 //AcDbObject: virtual Acad::ErrorStatus dwgInFields(AcDbDwgFiler* filer); virtual Acad::ErrorStatus dwgOutFields(AcDbDwgFiler* filer) const; virtual Acad::ErrorSta
ObjectArx创建自定义实体
u012158162的专栏
03-28 6873
ObjectArx创建自定义实体 一。目的 在ObjectArx中已经有了许多实体，如AcDbLine,AcDbCircle,AcDbArc等，但在用户使用Cad时，会有一些对他们来讲常用的“实体“，如一扇门，如果我们能提供一个“门实体“，让用户能向添加直线一样方便，相信用户是很乐意接受由此功能的软件！这是，我们为这个“门“就相当于一个自定义实体”!(PS:希望没理解错)！ 本文将介
使用ObjectARX 2012向导生成的自定义实体类无法捕捉的问题解决方式
aeu9737的博客
07-30 570
使用ObjectARX 2012自定实体向导的时候,获取捕捉点的重写函数的向导中模板有点问题, C:\Program Files (x86)\Autodesk\ObjectARX 2019 Wizards\ArxWizCustomObject\Templates\1033 在ArxWizCustomObject的模板中.object.h和.cpp原来是 virtual ...
autocad objectarx 自定义实体实现各部分不同颜色或不同图层
05-28
### AutoCAD ObjectARX 实现自定义实体各部分不同颜色或不同图层 #### 背景介绍 在AutoCAD的开发过程中，ObjectARX是一个非常重要的开发平台，它允许开发者创建高度定制化的AutoCAD应用程序。其中的一个核心需求是...
ObjectARX 自定义实体
09-05
【ObjectARX自定义实体】是指在Autodesk的AutoCAD平台中，通过ObjectARX库进行编程，创建具有特定功能和特性的自定义图形对象。这些实体不仅在图形界面中显示，还可以根据需要存储额外的数据，响应用户的各种操作，...
ObjectARX自定义实体的简单实现
12-05
在这个特定的项目“ObjectARX自定义实体的简单实现”中，我们将探讨如何利用VS2017开发环境和ObjectARX2019库来创建一个自定义实体——楼梯，并赋予它夹点编辑和捕捉点功能。 首先，我们需要了解ObjectARX的基本...
ObjectARX自定义实体教程
08-24
### ObjectARX自定义实体教程 #### 一、前言 本教程旨在通过逐步操作的方式指导读者学习如何在AutoCAD中创建自定义实体。ObjectARX是基于C++的AutoCAD二次开发工具包，它提供了丰富的API接口供开发者扩展AutoCAD的...
ARX自定义实体常用虚函数explode/worldDraw/transformBy/getOsnapPoints/getGripPoints
春夜喜雨的专栏
09-01 8431
i.              统一说明- sub/非sub sub开头函数用于vc90以及上版本继承函数，对应的不带sub开头的为vc80及以下版本继承函数。 原因是对于vc90以上版本AcGiDrawable/AcDbEntity类: Sub开头函数为protect纯虚函数； 对应不带sub开头函数为public实现函数—定义为了非可重载函数。   另外注意: vc90及以上
夹点getGripPoints/moveGripPointsAt/捕捉点getOsnapPoints
weixin_34341117的博客
11-21 1981
2019独角兽企业重金招聘Python工程师标准>>> ...
[转]ObjectARX 使用 AcDbMultiModesGripPE 夹点上下文菜单
edata的博客
03-27 900
这是一个使用 AcDbMultiModesGripPE 为自定义实体实现夹点上下文菜单的示例项目。它演示了使用多模式夹点来获取与自定义实体相关的输入。 为了让它变得有趣，我创建了一个类似于树的自定义实体。它的夹点上下文菜单显示两种模式 - “春季”和“冬季”。创建树自定义实体后，当夹点变热时将出现上下文菜单。选择“春天”将确保树有叶子，选择“冬天”将使树脱落叶子。
ObjectArx自定义实体入门(C++)及注意事项
湘君阿道夫的不老格
10-11 9500
本文介绍了构造自定义实体的步骤、必须继承的函数和必须注意的事项1.新建一个从AcDbEntity继承的类，如EntTest，必须添加的头文件: "stdarx.h","acadstrc.h", "geassign.h"。 2.在该类头文件的类声明中添加宏:ACRX_DECLARE_MEMBERS(EntTest);3.在该类的cpp文件中，类的前面添加宏：ACRX_DXF_DEFI
专题---自定义实体类
阿a楞的博客
11-26 788
专题---自定义实体类
ObjectArx 创建自定义实体的步骤（一）
zou_ys88的博客
02-21 1011
我使用的环境是cad2018+objectarx2018+vs2015+win10。先要安装desk向导程序，用向导创建项目对于初学者来说是很方便的，然后在配置程序编译链接的环境，最后就可以写一个项目了。在这里我建立了两个项目，一个是提供输入命令的常规项目，另一个是自定义实体的项目。 创建好这两个项目要设置依赖关系。 最后就是编译链接项目了，这里需要注意的是，这两个项目的输出文件的路径不能是同一路径，不然编译其中一个的时候就会把另一个覆盖掉，而在cad2018使用appload加载的时候，需
ObjectARX bnp
02-02
ObjectARX是由Autodesk开发的一套用于AutoCAD和其他Autodesk产品的编程接口。它允许开发者使用C++语言来创建自定义的AutoCAD应用程序和插件，以扩展AutoCAD的功能和实现特定的需求。 ObjectARX提供了一系列的类和函数，开发者可以利用这些API来访问和操作AutoCAD的对象模型，包括图形、图层、块、实体等。通过ObjectARX，开发者可以实现自定义命令、自定义对象、自定义界面等功能，从而满足特定的设计和工程需求。 BNP（Batch Name Property)是ObjectARX中的一个重要概念，它用于管理和操作AutoCAD中的命名对象。通过BNP，开发者可以获取和设置对象的名称、标签、描述等属性信息，实现对对象的批量操作和管理。 总结一下，ObjectARX是Autodesk提供的一套用于AutoCAD和其他Autodesk产品的编程接口，而BNP是其中的一个重要概念，用于管理和操作AutoCAD中的命名对象。
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值