#include "stdafx.h"
//#include "Resource.h"
#include "KTCadUtility.h"
#include <dbidmap.h>
#include <acutil.h>
#include "Kingtouch.h"
#include "KTCadTempOverrides.h"
#include "EarThwormDef.h"

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

#if !defined(KTCHECK)
#define KTCHECK(EXPRESION)			assert(EXPRESION)
#endif // !defined(KTCHECK)

// 比较计算的精度
double CKTCadUtility::m_KTTol = AcGeContext::gTol.equalPoint();


BOOL CKTCadUtility::CanHighLight(AcDbObjectId idObj)
{
	AcDbObject* pObj;
	if (acdbOpenObject(pObj, idObj, AcDb::kForRead) != Acad::eOk)
		return FALSE;

	if (!pObj->isKindOf(AcDbEntity::desc())
		|| pObj->isKindOf(AcDbBlockBegin::desc())
		|| pObj->isKindOf(AcDbBlockEnd::desc()))
	{
		pObj->close();
		return FALSE;
	}

	pObj->close();

	return TRUE;
}

BOOL CKTCadUtility::HighLightEntity(AcDbObjectId idObj, BOOL bHighLight,AcApDocument* pDoc)
{
	acDocManager->lockDocument(pDoc);
	acDocManager->activateDocument(pDoc);

	AcDbObject* pObj;
	if (acdbOpenObject(pObj, idObj, AcDb::kForRead) != Acad::eOk)
	{
		acDocManager->unlockDocument(pDoc);
		return FALSE;
	}

	if (!pObj->isKindOf(AcDbEntity::desc())
		|| pObj->isKindOf(AcDbBlockBegin::desc())
		|| pObj->isKindOf(AcDbBlockEnd::desc()))
	{
		pObj->close();
		acDocManager->unlockDocument(pDoc);
		return FALSE;
	}

	if (pDoc->isQuiescent())
	{
		pObj->close();

		AcDbGroup* pGroup;
		AcDbObjectIdArray aridGroups;
		int iPos = GetItemGroups(idObj, aridGroups);

		if (bHighLight)
		{
			ads_name entName;
			acdbGetAdsName(entName, idObj);

			ads_name ssPick;
			acedSSAdd(entName, NULL, ssPick);
			while ((--iPos) >= 0)
			{
				AcDbObjectIdArray aridEnts;
				int iIdx = GetGroupItems(aridGroups[iPos], aridEnts);
				while ((--iIdx) >= 0)
				{
					acdbGetAdsName(entName, aridEnts[iIdx]);
					acedSSAdd(entName, ssPick, ssPick);
				}
			}

			acedSSSetFirst(ssPick, ssPick);
			acedSSFree(ssPick);
		}
		else
		{
			acedSSSetFirst(NULL, NULL);
			while ((--iPos) >= 0)
			{
				if (Acad::eOk != acdbOpenObject(pGroup, aridGroups[iPos], AcDb::kForRead))
					continue;
				pGroup->setHighlight(false);
				pGroup->close();
			}
		}
	}
	else
	{
		if (bHighLight) ((AcDbEntity*)pObj)->highlight();
		else ((AcDbEntity*)pObj)->unhighlight();
		pObj->close();
	}

	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();

	acDocManager->unlockDocument(pDoc);
	return TRUE;
}

AcDbObjectId CKTCadUtility::Initlayer(const TCHAR *szLayer, Adesk::UInt16 nCr/* = 256*/,AcDbDatabase *pDb)
{
	if (pDb == NULL) pDb = acdbCurDwg();

	AcDbObjectId idLayer = AcDbObjectId::kNull;
	AcDbLayerTable* pTable = NULL;
	BOOL bFind = FALSE;
	pDb->getLayerTable(pTable,AcDb::kForWrite);
	if (pTable != NULL)
	{
		if (Acad::eOk == pTable->getAt(szLayer,idLayer))
		{
			bFind = TRUE;
		}

		if (!bFind)
		{
			AcDbObjectId idLt;
			AcDbLinetypeTable *pLinetypeTbl = NULL;
			pDb->getLinetypeTable(pLinetypeTbl, AcDb::kForRead);
			pLinetypeTbl->getAt(_T("Continuous"),idLt);
			pLinetypeTbl->close();

			AcDbLayerTableRecord* pRec = new AcDbLayerTableRecord;
			pRec->setName(szLayer);
			pRec->setLinetypeObjectId(idLt);

			AcCmColor cr;
			cr.setColorIndex(nCr);
			pRec->setColor(cr);
			pTable->add(idLayer,pRec);
			pRec->close();
		}
		pTable->close();
	}

	return idLayer;
}

AcDbObjectId CKTCadUtility::InitTextStyle(const TCHAR *pszStyle, AcDbDatabase *pDb)
{
	if (pDb == NULL) pDb = acdbCurDwg();

	AcDbObjectId id;
	AcDbTextStyleTable* pTxtTbl = NULL;
	if (Acad::eOk == pDb->getTextStyleTable(pTxtTbl,AcDb::kForWrite))
	{
		if (Acad::eOk == pTxtTbl->getAt(pszStyle,id))
		{
			pTxtTbl->close();
			return id;
		}
		else
		{
			AcDbTextStyleTableRecord* pTxtRec = new AcDbTextStyleTableRecord;
			pTxtRec->setFileName(_T("gbenor"));
			pTxtRec->setBigFontFileName(_T("gbcbig"));
			pTxtRec->setXScale(0.75);
			pTxtRec->setName(pszStyle);
			pTxtTbl->add(id,pTxtRec);
			pTxtRec->close();
		}
		pTxtTbl->close();
	}
	return id;
}

// 取得系统变量值
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, short& iVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwgInt16 || iType == AcDb::kDwgInt8)
	{
		iVal = rb.resval.rint;
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, int& iVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwgInt16 || iType == AcDb::kDwgInt8)
	{
		iVal = rb.resval.rint;
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, long& lVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwgInt32)
	{
		lVal = rb.resval.rlong;
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, double& dVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwgReal)
	{
		dVal = rb.resval.rreal;
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, CString& sVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwgText)
	{
		sVal = rb.resval.rstring;
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
BOOL CKTCadUtility::GetSystemVar(LPCTSTR pszVarName, ads_point ptVal)
{
	BOOL bRet = FALSE;

	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	acedGetVar(pszVarName, &rb);
	AcDb::DwgDataType iType = ResBufType2DwgDataType(rb.restype);
	if (iType == AcDb::kDwg3Real)
	{
		CopyMemory(ptVal, rb.resval.rpoint, sizeof(ads_point));
		bRet = TRUE;
	}
	FreeResBuf(&rb);

	return bRet;
}
// 设置系统变量值
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, short iVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RTSHORT;
	rb.resval.rint = iVal;
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, int iVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RTSHORT;
	rb.resval.rint = iVal;
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, long lVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RTLONG;
	rb.resval.rlong = lVal;
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, double dVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RTREAL;
	rb.resval.rreal = dVal;
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, LPCTSTR pszVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RTSTR;
	rb.resval.rstring = (LPTSTR)pszVal;
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}
BOOL CKTCadUtility::SetSystemVar(LPCTSTR pszVarName, ads_point ptVal)
{
	struct resbuf rb;
	ZeroMemory(&rb, sizeof(struct resbuf));
	rb.restype = RT3DPOINT;
	CopyMemory(rb.resval.rpoint, ptVal, sizeof(ads_point));
	return (acedSetVar(pszVarName, &rb) == RTNORM);
}

// 加入块表记录
Acad::ErrorStatus
CKTCadUtility::AddToBlockTableRecord(AcDbEntity* pEnt,	// 实体对象
									LPCTSTR pszBlock,	// 块名, 默认为模型空间
									AcDbDatabase* pDb)	// 数据库名, 默认为当前数据库
{
	AcDbObjectId idEnt;
	return CKTCadUtility::AddToBlockTableRecord(idEnt, pEnt, pszBlock, pDb);
}

// 加入块表记录
Acad::ErrorStatus
CKTCadUtility::AddToBlockTableRecord(AcDbObjectId& idEnt,	// 返回对象ID
									AcDbEntity* pEnt,		// 实体对象
									LPCTSTR pszBlock,		// 块名, 默认为模型空间
									AcDbDatabase* pDb)		// 数据库名, 默认为当前数据库
{
	ASSERT(pEnt != NULL);

	if (pDb == NULL)
	{
		pDb = acdbHostApplicationServices()->workingDatabase();
	}
	ASSERT(pDb != NULL);

	if (pszBlock == NULL)
	{
		pszBlock = ACDB_MODEL_SPACE;
	}

	AcDbBlockTable* pBT = NULL;
	Acad::ErrorStatus es = pDb->getBlockTable(pBT, AcDb::kForRead);
	if (es == Acad::eOk)
	{
		ASSERT(pBT != NULL);

		AcDbBlockTableRecord* pBTR = NULL;
		es = pBT->getAt(pszBlock, pBTR, AcDb::kForWrite);
		pBT->close();

		if (es == Acad::eOk)
		{
			ASSERT(pBTR != NULL);

			es = pBTR->appendAcDbEntity(idEnt, pEnt);
			pBTR->close();
		}
	}

	return es;
}

Acad::ErrorStatus CKTCadUtility::AddToCurrentSpace(AcDbEntity* pEnt)
{
	ASSERT(pEnt != NULL);

	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
	ASSERT(pDb != NULL);

	AcDbBlockTableRecord* pBTR = NULL;
	Acad::ErrorStatus es = acdbOpenObject(pBTR, pDb->currentSpaceId(), AcDb::kForWrite);
	if (es != Acad::eOk)
		return es;

	es = pBTR->appendAcDbEntity(pEnt);
	pBTR->close();

	return es;
}

Acad::ErrorStatus CKTCadUtility::AddToCurrentSpace(AcDbEntity* pEnt, AcDbObjectId& idEnt)
{
	ASSERT(pEnt != NULL);

	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
	ASSERT(pDb != NULL);

	AcDbBlockTableRecord* pBTR = NULL;
	Acad::ErrorStatus es = acdbOpenObject(pBTR, pDb->currentSpaceId(), AcDb::kForWrite);
	if (es != Acad::eOk)
		return es;

	es = pBTR->appendAcDbEntity(idEnt, pEnt);
	pBTR->close();

	return es;
}

// 在相同Database中，拷贝实体, 仅适合简单实体, 且复制对象没有加入数据库
Acad::ErrorStatus CKTCadUtility::CloneObject(AcDbObject*& pObjDest, const AcDbObject* pObjSrc)
{
	ASSERT(pObjSrc != NULL);

	BOOL bCreate = FALSE;
	if (pObjDest == NULL)
	{
		pObjDest = (AcDbObject*)pObjSrc->isA()->create();
		KTCHECK(pObjDest != NULL);
		bCreate = TRUE;
	}
	else
	{
		if (!pObjDest->isKindOf(pObjSrc->isA()))
			return Acad::eWrongObjectType;
	}

	Acad::ErrorStatus es;
	AcDbDeepCloneFiler filer;
	if ((es = pObjSrc->dwgOut(&filer)) != Acad::eOk)
	{
		if (bCreate)
		{
			DELETE_PTR(pObjDest);
		}
		return es;
	}

	filer.seek(0l, AcDb::kSeekFromStart);
	if ((es = pObjDest->dwgIn(&filer)) != Acad::eOk)
	{
		if (bCreate)
		{
			DELETE_PTR(pObjDest);
		}
	}

	return es;
}

// 在相同Database中，拷贝实体数据, 仅适合加入数据库的实体, pObjDest必须传入NULL
Acad::ErrorStatus CKTCadUtility::DeepCloneObject(AcDbObject*& pObjDest,	// 返回目标对象
												AcDbObject* pObjSrc,		// 被拷贝对象
												AcDbObjectId idOwner)		// 目标对象的属主
{
	ASSERT(pObjDest == NULL && pObjSrc != NULL);

	AcDbObjectId id = pObjSrc->objectId();
	if (!id.isValid())
		return Acad::eNotInDatabase;

	AcDbDatabase* pDb = pObjSrc->database();
	ASSERT(pDb != NULL);

	BOOL bWrite = pObjSrc->isWriteEnabled();
	if (bWrite)
		pObjSrc->downgradeOpen();

	if (!idOwner.isValid())
		idOwner = pObjSrc->ownerId();

	AcDbIdMapping idMap;
	AcDbObjectIdArray arid;
	arid.append(id);
	Acad::ErrorStatus es = pDb->deepCloneObjects(arid, idOwner, idMap, false);

	if (bWrite)
		pObjSrc->upgradeOpen();

	if (es != Acad::eOk)
		return es;

	AcDbIdPair pair;
	pair.setKey(id);
	idMap.compute(pair);
	ASSERT(pair.value().isValid());

	return acdbOpenObject(pObjDest, pair.value(), AcDb::kForWrite);
}

// 创建一个块，如果块名为NULL则为无名块
AcDbObjectId CKTCadUtility::CreateBlockTableRecord(AcDbVoidPtrArray& arpEnt,
													const AcGePoint3d& ptOrigin,
													LPCTSTR pszBlk,
													AcDbDatabase* pDb,
													BOOL bDeleteSrc)
{
	AcDbObjectId id;

	if (pDb == NULL)
	{
		pDb = acdbHostApplicationServices()->workingDatabase();
	}
	ASSERT(pDb != NULL);

	AcDbBlockTable* pBT = NULL;
	pDb->getSymbolTable(pBT, AcDb::kForWrite);
	if (pBT == NULL)
		return id;

	BOOL bAnonymous = (pszBlk == NULL || _tcslen(pszBlk) <= 0);
	if (!bAnonymous && pBT->has(pszBlk))
	{
		pBT->close();
		return id;
	}

	AcDbBlockTableRecord* pBTR = new AcDbBlockTableRecord;
	KTCHECK(pBTR != NULL);

	pBT->add(id, pBTR);
	if (!id.isValid())
	{
		DELETE_PTR(pBTR);
		pBT->close();
		return id;
	}
	pBT->close();

	if (bAnonymous)
		pBTR->setName(_T("*U"));
	else
		pBTR->setName(pszBlk);
	pBTR->setOrigin(ptOrigin);

	AcDbEntity* pEnt;
	int iLen  = arpEnt.length();
	for (int i = iLen - 1; i >= 0; i--)
	{
		pEnt = (AcDbEntity*)arpEnt[i];
		ASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));

		if (pEnt->objectId().isValid())
			continue;

		if (pBTR->appendAcDbEntity(pEnt) == Acad::eOk)
			pEnt->close();
		else
			DELETE_PTR(pEnt);

		arpEnt.removeAt(i);
	}

	pBTR->close();

	AcDbEntity* pCpyEnt;
	iLen = arpEnt.length();
	for (int i = iLen - 1; i >= 0; i--)
	{
		pEnt = (AcDbEntity*)arpEnt[i];
		ASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));
		ASSERT(pEnt->objectId().isValid());

		pCpyEnt = NULL;
		CKTCadUtility::DeepCloneObject((AcDbObject*&)pCpyEnt, pEnt, id);
		pCpyEnt->close();

		if (bDeleteSrc && (pEnt->isWriteEnabled() || pEnt->upgradeOpen() == Acad::eOk))
			pEnt->erase();
		pEnt->close();

		arpEnt.removeAt(i);
	}

	return id;
}

AcDbObjectId CKTCadUtility::CreateBlockTableRecord(AcDbObjectIdArray& arid,
													const AcGePoint3d& ptOrigin,
													LPCTSTR pszBlk,
													AcDbDatabase* pDb,
													BOOL bDeleteSrc)
{
	AcDbObjectId id;

	if (pDb == NULL)
	{
		pDb = acdbHostApplicationServices()->workingDatabase();
	}
	ASSERT(pDb != NULL);

	AcDbBlockTable* pBT = NULL;
	pDb->getSymbolTable(pBT, AcDb::kForWrite);
	if (pBT == NULL)
		return id;

	BOOL bAnonymous = (pszBlk == NULL || _tcslen(pszBlk) <= 0);
	if (!bAnonymous && pBT->has(pszBlk))
	{
		pBT->close();
		return id;
	}

	AcDbBlockTableRecord* pBTR = new AcDbBlockTableRecord;
	KTCHECK(pBTR != NULL);

	pBT->add(id, pBTR);
	if (!id.isValid())
	{
		DELETE_PTR(pBTR);
		pBT->close();
		return id;
	}
	pBT->close();

	if (bAnonymous)
		pBTR->setName(_T("*U"));
	else
		pBTR->setName(pszBlk);
	pBTR->setOrigin(ptOrigin);
	pBTR->close();

	AcDbEntity* pEnt;
	AcDbEntity* pCpyEnt;
	int iLen  = arid.length();
	for (int i = iLen - 1; i >= 0; i--)
	{
		ASSERT(arid[i].isValid());
		if (acdbOpenObject(pEnt, arid[i], AcDb::kForRead) != Acad::eOk)
			continue;
		ASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));

		pCpyEnt = NULL;
		CKTCadUtility::DeepCloneObject((AcDbObject*&)pCpyEnt, pEnt, id);
		pCpyEnt->close();

		if (bDeleteSrc && pEnt->upgradeOpen() == Acad::eOk)
			pEnt->erase();
		pEnt->close();

		arid.removeAt(i);
	}

	return id;
}

AcDbObjectId CKTCadUtility::CreateBlockTableRecord(AcDbObjectIdArray& arid,
												   const AcGePoint3d& ptOrigin,
												   LPCTSTR pszBlk,
												   LPCTSTR pszComments,
												   AcDbDatabase* pDb,
												   BOOL bDeleteSrc)
{
	AcDbObjectId id;

	if (pDb == NULL)
	{
		pDb = acdbHostApplicationServices()->workingDatabase();
	}
	ASSERT(pDb != NULL);

	AcDbBlockTable* pBT = NULL;
	pDb->getSymbolTable(pBT, AcDb::kForWrite);
	if (pBT == NULL)
		return id;

	BOOL bAnonymous = (pszBlk == NULL || _tcslen(pszBlk) <= 0);
	if (!bAnonymous && pBT->has(pszBlk))
	{
		pBT->close();
		return id;
	}

	AcDbBlockTableRecord* pBTR = new AcDbBlockTableRecord;
	KTCHECK(pBTR != NULL);
	
	if (pszComments != NULL) 
		pBTR->setComments(pszComments);

	pBT->add(id, pBTR);
	if (!id.isValid())
	{
		DELETE_PTR(pBTR);
		pBT->close();
		return id;
	}
	pBT->close();

	if (bAnonymous)
		pBTR->setName(_T("*U"));
	else
		pBTR->setName(pszBlk);
	pBTR->setOrigin(ptOrigin);
	pBTR->close();

	AcDbEntity* pEnt;
	AcDbEntity* pCpyEnt;
	int iLen  = arid.length();
	for (int i = iLen - 1; i >= 0; i--)
	{
		ASSERT(arid[i].isValid());
		if (acdbOpenObject(pEnt, arid[i], AcDb::kForRead) != Acad::eOk)
			continue;
		ASSERT(pEnt != NULL && pEnt->isKindOf(AcDbEntity::desc()));

		pCpyEnt = NULL;
		CKTCadUtility::DeepCloneObject((AcDbObject*&)pCpyEnt, pEnt, id);
		pCpyEnt->close();

		if (bDeleteSrc && pEnt->upgradeOpen() == Acad::eOk)
			pEnt->erase();
		pEnt->close();

		arid.removeAt(i);
	}

	return id;
}

// 创建一个组，如果组名为NULL则为无名组
AcDbObjectId CKTCadUtility::CreateAcDbGroup(const AcDbObjectIdArray& arid,
													LPCTSTR pszGroup,
													bool bSelectable)
{
	AcDbObjectId id;

	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
	ASSERT(pDb != NULL);

	AcDbDictionary* pDict = NULL;
	pDb->getGroupDictionary(pDict, AcDb::kForWrite);
	if (pDict == NULL)
		return id;

	BOOL bAnonymous = (pszGroup == NULL || _tcslen(pszGroup) <= 0);
	if (!bAnonymous && pDict->has(pszGroup))
	{
		pDict->close();
		return id;
	}

	AcDbGroup* pGroup = new AcDbGroup;
	KTCHECK(pGroup != NULL);

	pDict->setAt(_T("*A"), pGroup, id);
	if (!id.isValid())
	{
		DELETE_PTR(pGroup);
		pDict->close();
		return id;
	}
	pDict->close();

	pGroup->setSelectable(bSelectable);
	if (bAnonymous)
		pGroup->setAnonymous();
	else
		pGroup->setName((LPTSTR)pszGroup);

	pGroup->append(arid);

	pGroup->close();

	return id;
}

bool CKTCadUtility::AddEntToGroup(AcDbObjectId &id2, AcDbObjectId &idGroup)
{
	AcDbGroup *pGroup = NULL;
	if (Acad::eOk == acdbOpenObject(pGroup, idGroup, AcDb::kForWrite))
	{
		pGroup->append(id2);
		pGroup->close();
		return true;
	}
	return false;
}

int CKTCadUtility::GetItemGroups(const AcDbObjectId& idObj, AcDbObjectIdArray& aridGroups)
{
	AcDbObject* pObj = NULL;
	acdbOpenObject(pObj, idObj, AcDb::kForRead);
	if (NULL == pObj)
		return 0;

	const AcDbVoidPtrArray* pReactors = pObj->reactors();
	pObj->close();
	if (NULL == pReactors)
		return 0;

    void *pSomething;
	AcDbGroup* pGroup;
	AcDbObjectId idGroup;
	int iPos = pReactors->length();
	while ((--iPos) >= 0)
	{
		pSomething = pReactors->at(iPos);
		if (!acdbIsPersistentReactor(pSomething))
			continue;

		idGroup = acdbPersistentReactorObjectId(pSomething);
		if (Acad::eOk != acdbOpenObject(pGroup, idGroup, AcDb::kForRead))
			continue;

		aridGroups.append(idGroup);

		pGroup->close();
	}

	return aridGroups.length();
}

int CKTCadUtility::GetGroupItems(const AcDbObjectId& idGroup, AcDbObjectIdArray& aridObjs)
{
	AcDbGroup* pGroup = NULL;
	acdbOpenObject(pGroup, idGroup, AcDb::kForRead);
	if (NULL == pGroup)
		return 0;

	pGroup->allEntityIds(aridObjs);

	pGroup->close();

	return aridObjs.length();
}

// 自动区分动态库类型，并加载它
HINSTANCE CKTCadUtility::LoadApplication(CString sPathName)
{
	// 保存当前路径设置
	CString sEnvironment;
	DWORD dwSize = GetEnvironmentVariable(_T("PATH"), NULL, 0);
	GetEnvironmentVariable(_T("PATH"), sEnvironment.GetBuffer(dwSize), dwSize);
	sEnvironment.ReleaseBuffer();

	// 设置加载路径
	sPathName.Replace(_T('/'), _T('\\'));
	int iFind = sPathName.ReverseFind(_T('\\')) + 1;
	if (iFind > 0)
	{
		CString sPath = sPathName.Left(iFind);
		SetEnvironmentVariable(_T("PATH"), sPath + _T(';') + sEnvironment);
	}

	// 装入动态库
	HINSTANCE hDll = AfxLoadLibrary(sPathName);
	if (hDll == NULL)
	{
		// 恢复路径设置
		if (!sEnvironment.IsEmpty())
			SetEnvironmentVariable(_T("PATH"), sEnvironment);
		return NULL;
	}

	// 判断文件类型
	KT::EAppType eType = KT::eUnknownApp;
	if (GetProcAddress(hDll, "acrxEntryPoint") != NULL)
		eType = KT::eArxApp;
	else
		eType = KT::eDllApp;

	// 根据不同类型, 使用不同方式加载
	switch (eType)
	{
	case KT::eArxApp:
		AfxFreeLibrary(hDll);
		if (acrxLoadModule(sPathName, FALSE))
			hDll = GetModuleHandle(sPathName);
		else
			hDll = NULL;
		break;
	case KT::eDllApp:
		break;
	default:
		AfxFreeLibrary(hDll);
		hDll = NULL;
		break;
	}

	// 恢复路径设置
	if (!sEnvironment.IsEmpty())
		SetEnvironmentVariable(_T("PATH"), sEnvironment);

	return hDll;
}

// 自动区分动态库类型，并卸载它
BOOL CKTCadUtility::UnloadApplication(HINSTANCE hDll)
{
	// 判断文件类型
	KT::EAppType eType = KT::eUnknownApp;
	if (GetProcAddress(hDll, "acrxEntryPoint") != NULL)
		eType = KT::eArxApp;
	else
		eType = KT::eDllApp;

	// 根据不同类型, 使用不同方式加载
	BOOL bSuccess = FALSE;
	CString sFile;
	switch (eType)
	{
	case KT::eArxApp:
		GetModuleFileName(hDll, sFile.GetBuffer(MAX_PATH), MAX_PATH);
		sFile.ReleaseBuffer();
		bSuccess = acrxUnloadModule(sFile);
		break;
	case KT::eDllApp:
		bSuccess = AfxFreeLibrary(hDll);
		break;
	default:
		break;
	}

	return bSuccess;
}

// 自动区分动态库类型，并卸载它
BOOL CKTCadUtility::UnloadApplication(LPCTSTR pszAppFile)
{
	HINSTANCE hDll = GetModuleHandle(pszAppFile);
	if (hDll != NULL)
	{
		return CKTCadUtility::UnloadApplication(hDll);
	}

	return FALSE;
}


// 取得当前视口的数据
BOOL CKTCadUtility::GetActiveViewPortInfo(double &dHeight,			// 高度
										double &dWidth,				// 宽度
										AcGePoint3d &ptTarget,		// 目标点
										AcGeVector3d &vecViewDir,	// 方向
										double &dViewTwist,			// ViewTwist
										BOOL bGetViewCenter)		// 是否取视口中心
{
	// get the working db
	AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase(); 
	// if not ok
	if (pDb == NULL)
		return FALSE;

	// lock current document
	CKTTempLockDoc docLock;

	// make sure the active view port is uptodate
	acedVports2VportTableRecords();

	// open the view port records
	AcDbViewportTable *pVTable = NULL;
	Acad::ErrorStatus es = pDb->getViewportTable(pVTable, AcDb::kForRead);
	// if we opened them ok
	if (es == Acad::eOk)
	{
		AcDbViewportTableRecord *pViewPortRec = NULL;
		es = pVTable->getAt(_T("*Active"), pViewPortRec, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			// get the height of the view
			dHeight = pViewPortRec->height();
			// get the width
			dWidth = pViewPortRec->width();
			// if the user wants the center of the viewport used
			if (bGetViewCenter)
			{
				struct resbuf rb;
				memset (&rb, 0, sizeof(struct resbuf));
				// get the system var VIEWCTR
				acedGetVar(_T("VIEWCTR"), &rb);
				// set that as the target
				ptTarget = AcGePoint3d(rb.resval.rpoint[X], rb.resval.rpoint[Y], rb.resval.rpoint[Z]);
			}
			else
			{
				// we want the viewports camera target setting
				// get the target of the view
				ptTarget = pViewPortRec->target();
			}		

			// get the view direction
			vecViewDir = pViewPortRec->viewDirection();
			// get the view twist of the viewport
			dViewTwist = pViewPortRec->viewTwist();
		}
		// close after use
		pVTable->close();
		pViewPortRec->close();			
	}

	return TRUE;
}

// 取得当前视口数据
BOOL CKTCadUtility::GetCurrentViewInfo(AcGePoint3d & ptPosition,	// 位置点
								AcGePoint3d & ptTarget,			// 目标点
								AcGeVector3d& vecUpVector,		// UpVector
								double& dFieldWidth,			// 宽度
								double& dFieldHeight)			// 高度
{
	// get the view port information - see parameter list
	double dHeight = 0.0, dWidth = 0.0, dViewTwist = 0.0;
	AcGePoint3d ptTargetView;
	AcGeVector3d vecViewDir;
	GetActiveViewPortInfo(dHeight, dWidth, ptTargetView, vecViewDir, dViewTwist, TRUE);

	// we are only interested in the directions of the view, not the sizes, so we normalise. 
	vecViewDir.normalize();

	// Our view coordinate space consists of z direction 
	// get a perp vector off the z direction
	// Make sure its normalised
	AcGeVector3d vecViewXDir = vecViewDir.perpVector().normal();
	// correct the x angle by applying the twist
	vecViewXDir = vecViewXDir.rotateBy (dViewTwist, -vecViewDir);
	// now we can work out y, this is of course perp to the x and z directions. No need to normalise this, 
	// as we know that x and z are of unit length, and perpendicular, so their cross product must be on unit length
	vecUpVector = vecViewDir.crossProduct (vecViewXDir);

	// the current editor drawing
	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase(); 
	// Calculate the extents in WCS
	AcGePoint3d ptExtMax = pDb->extmax();
	AcGePoint3d ptExtMin = pDb->extmin();

	// find a nice point around which to transform the view. We'll use the same point as the center of the view.
	ptTarget = ptExtMin + 0.5 * (ptExtMax - ptExtMin);

	ptPosition = ptTarget + vecViewDir;

	// create a transform from WCS to View space
	// this represents the transformation from WCS to the view space. (Actually not quite since 
	// we are keeping the fixed point as the center of the box for convenience )
	AcGeMatrix3d matView;
	matView = AcGeMatrix3d::alignCoordSys(ptTarget, AcGeVector3d::kXAxis, AcGeVector3d::kYAxis, AcGeVector3d::kZAxis,  
												ptTarget, vecViewXDir, vecUpVector, vecViewDir).inverse();

	AcDbExtents extWcsExtents(ptExtMin, ptExtMax);
	// now we have the view Extents
	AcDbExtents extViewExtents = extWcsExtents;
	// transforms the extents in WCS->view space
	extViewExtents.transformBy(matView);

	// get the extents of the AutoCAD view
	dFieldWidth = fabs(extViewExtents.maxPoint ().x - extViewExtents.minPoint ().x);
	dFieldHeight = fabs(extViewExtents.maxPoint ().y - extViewExtents.minPoint ().y);

	return TRUE;
}

#if ARX<20
// 取得ShadeMode系统变量值
AcGsView::RenderMode CKTCadUtility::GetShadeMode(int iVP)
{
	int iTileMode;
	GetSystemVar(_T("TILEMODE"), iTileMode);

	if (iTileMode == 0)
		return AcGsView::k2DOptimized;

	AcGsView * pView = acgsGetGsView(iVP, FALSE);
	return ((pView != NULL)? pView->mode() : AcGsView::k2DOptimized);
}

// 取得ShadeMode系统变量值
AcGsView::RenderMode CKTCadUtility::GetCurrentShadeMode()
{
	int iTileMode;
	GetSystemVar(_T("TILEMODE"), iTileMode);

	if (iTileMode == 0)
		return AcGsView::k2DOptimized;

	int iCurView;
	GetSystemVar(_T("CVPORT"), iCurView);

	AcGsView * pView = acgsGetGsView(iCurView, FALSE);
	return ((pView != NULL)? pView->mode() : AcGsView::k2DOptimized);
}
#endif

BOOL CKTCadUtility::GetCurrentViewSize(double& dWidth, double& dHeight)
{
	ads_point ptScreen;
	GetSystemVar(_T("VIEWSIZE"), dHeight);
	GetSystemVar(_T("SCREENSIZE"), ptScreen);
	dWidth = ptScreen[0] / ptScreen[1] * dHeight;

	return TRUE;
}

BOOL CKTCadUtility::GetCurrentViewSize(AcGePoint3d& ptMin, AcGePoint3d& ptMax)
{
	double dWidth, dHeight;
	GetCurrentViewSize(dWidth, dHeight);

	ads_point ptViewCtr;
	GetSystemVar(_T("VIEWCTR"), ptViewCtr);

	ptMin.set(ptViewCtr[0] - dWidth / 2.0, ptViewCtr[1] - dHeight / 2.0, ptViewCtr[2]);
	ptMax.set(ptViewCtr[0] + dWidth / 2.0, ptViewCtr[1] + dHeight / 2.0, ptViewCtr[2]);

	return TRUE;
}

// 缩放图形窗口
BOOL CKTCadUtility::ZoomExtents()
{
	ads_point pt1, pt2;
	CKTCadUtility::GetSystemVar(_T("EXTMIN"), pt1);
	CKTCadUtility::GetSystemVar(_T("EXTMAX"), pt2);

	return Zoom(asPnt3d(pt1), asPnt3d(pt2));
}

BOOL CKTCadUtility::Zoom(const AcGePoint3d& ptMin, const AcGePoint3d& ptMax)
{
	ads_point ptDir;
	GetSystemVar(_T("VIEWDIR"), ptDir);

	AcGePlane plane(GetUcsOrigin(), GetUcsZAxis());

	AcGePoint2d pt1 = ptMin.convert2d(plane);
	AcGePoint2d pt2 = ptMax.convert2d(plane);
	AcGePoint2d pt = GetMiddlePoint(pt1, pt2);

	AcDbViewTableRecord VTR;
	VTR.setCenterPoint(pt);
	VTR.setViewDirection(asVec3d(ptDir));
	VTR.setWidth(fabs(pt2.x - pt1.x));
	VTR.setHeight(fabs(pt2.y - pt1.y));

	return (acedSetCurrentView(&VTR, NULL) == Acad::eOk);
}

// 平移绘图窗口
BOOL CKTCadUtility::Pan(const AcGeVector3d& vecPan)
{
	ads_point ptDir;
	GetSystemVar(_T("VIEWDIR"), ptDir);

	ads_point ptCtr;
	GetSystemVar(_T("VIEWCTR"), ptCtr);

	AcGePlane plane(GetUcsOrigin(), GetUcsZAxis());
	AcGePoint3d ptNewCtr = asPnt3d(ptCtr) + vecPan;
	AcGePoint2d pt = ptNewCtr.convert2d(plane);

	double dWidth, dHeight;
	GetCurrentViewSize(dWidth, dHeight);

	AcDbViewTableRecord VTR;
	VTR.setCenterPoint(pt);
	VTR.setViewDirection(asVec3d(ptDir));
	VTR.setWidth(dWidth);
	VTR.setHeight(dHeight);

	return (acedSetCurrentView(&VTR, NULL) == Acad::eOk);
}

// 将窗口缩放/平移到当前视口中
BOOL CKTCadUtility::ZoomInCurrentView(const AcGePoint3d& ptMin, const AcGePoint3d& ptMax)
{
	AcGePlane plane(GetUcsOrigin(), GetUcsZAxis());

	AcGePoint3d ptView1, ptView2;
	GetCurrentViewSize(ptView1, ptView2);

	AcGePoint2d ptBox1 = ptView1.convert2d(plane);
	AcGePoint2d ptBox2 = ptView2.convert2d(plane);

	AcGePoint2d ptWnd1 = ptMin.convert2d(plane);
	AcGePoint2d ptWnd2 = ptMax.convert2d(plane);

	BOOL bPt1In = IsPointInBox(ptWnd1, ptBox1, ptBox2);
	BOOL bPt2In = IsPointInBox(ptWnd2, ptBox1, ptBox2);

	// 在视口中无需处理
	if (bPt1In && bPt2In)
		return FALSE;

	if (fabs(ptWnd2.x - ptWnd1.x) < fabs(ptBox2.x - ptBox1.x) && fabs(ptWnd2.y - ptWnd1.y) < fabs(ptBox2.y - ptBox1.y))
	{
		// 小于视口尺寸, 使用Pan方式
		Pan(GetMiddlePoint(ptMin, ptMax) - GetMiddlePoint(ptView1, ptView2));
	}
	else
	{
		// 大于视口尺寸, 使用Zoom方式
		Zoom(ptMin, ptMax);
	}

	return TRUE;
}

// 取得UCS坐标系统信息
AcGeVector3d CKTCadUtility::GetUcsXAxis()
{
	AcGeVector3d vec;
	GetSystemVar(_T("UCSXDIR"), asDblArray(vec));
	return vec;
}

AcGeVector3d CKTCadUtility::GetUcsYAxis()
{
	AcGeVector3d vec;
	GetSystemVar(_T("UCSYDIR"), asDblArray(vec));
	return vec;
}

AcGeVector3d CKTCadUtility::GetUcsZAxis()
{
	return GetUcsXAxis().crossProduct(GetUcsYAxis());
}

AcGePoint3d CKTCadUtility::GetUcsOrigin()
{
	AcGePoint3d pt;
	GetSystemVar(_T("UCSORG"), asDblArray(pt));
	return pt;
}

// 对角度Ucs和Wcs转换
double CKTCadUtility::Ucs2Wcs(double dAngle)
{
	ads_point adsPt = {cos(dAngle), sin(dAngle), 0.0};
	acdbUcs2Wcs(adsPt, adsPt, TRUE);
	ads_point adsOrg = {0.0, 0.0, 0.0};
	return acutAngle(adsOrg, adsPt);
}

double CKTCadUtility::Wcs2Ucs(double dAngle)
{
	ads_point adsPt = {cos(dAngle), sin(dAngle), 0.0};
	acdbWcs2Ucs(adsPt, adsPt, TRUE);
	ads_point adsOrg = {0.0, 0.0, 0.0};
	return acutAngle(adsOrg, adsPt);
}

// 点和向量Ucs和Wcs转换
AcGePoint3d CKTCadUtility::Ucs2Wcs(const AcGePoint3d& pt)
{
	ads_point adsPt;
	acdbUcs2Wcs(asDblArray(pt), adsPt, FALSE);
	return asPnt3d(adsPt);
}

AcGePoint3d CKTCadUtility::Wcs2Ucs(const AcGePoint3d& pt)
{
	ads_point adsPt;
	acdbWcs2Ucs(asDblArray(pt), adsPt, FALSE);
	return asPnt3d(adsPt);
}

AcGeVector3d CKTCadUtility::Ucs2Wcs(const AcGeVector3d& vec)
{
	ads_point adsPt;
	acdbUcs2Wcs(asDblArray(vec), adsPt, TRUE);
	return asVec3d(adsPt);
}

AcGeVector3d CKTCadUtility::Wcs2Ucs(const AcGeVector3d& vec)
{
	ads_point adsPt;
	acdbWcs2Ucs(asDblArray(vec), adsPt, TRUE);
	return asVec3d(adsPt);
}

// 取得屏幕和视口转换
int CKTCadUtility::Wcs2Pixel(double dLen)
{
	double dViewSize;
	ads_point ptScreen;
	GetSystemVar(_T("VIEWSIZE"), dViewSize);
	GetSystemVar(_T("SCREENSIZE"), ptScreen);

	if (_IsZero_(dViewSize))
		return 0;
	else
		return int((ptScreen[1] / dViewSize) * dLen + 0.5);
}

CPoint CKTCadUtility::Wcs2Pixel(const AcGePoint3d& pt)
{
	CPoint ptRet;
	int iCVPort = 2;
	GetSystemVar(_T("CVPORT"), iCVPort);
	acedCoordFromWorldToPixel(iCVPort, asDblArray(pt), ptRet);
	return ptRet;
}

double CKTCadUtility::Pixel2Wcs(int iLen)
{
	double dViewSize;
	ads_point ptScreen;
	GetSystemVar(_T("VIEWSIZE"), dViewSize);
	GetSystemVar(_T("SCREENSIZE"), ptScreen);

	if (_IsZero_(ptScreen[1]))
		return 0.0;
	else
		return ((dViewSize / ptScreen[1]) * iLen);
}

AcGePoint3d CKTCadUtility::Pixel2Wcs(const CPoint& pt)
{
	AcGePoint3d ptRet;
	int iCVPort = 2;
	GetSystemVar(_T("CVPORT"), iCVPort);
	acedCoordFromPixelToWorld(iCVPort, pt, asDblArray(ptRet));
	return ptRet;
}

// 得到耙区在WCS下的大小
double CKTCadUtility::GetApertureSize()
{
	int iAperture = 1;
	GetSystemVar(_T("APERTURE"), iAperture);
	return Pixel2Wcs(iAperture);
}

// 得到拾取框在WCS下的大小
double CKTCadUtility::GetPickBoxSize()
{
	int iPickBox = 0;
	GetSystemVar(_T("PICKBOX"), iPickBox);
	return Pixel2Wcs(iPickBox);
}

// 取得两点构成的立方体的最小点/最大点
AcGePoint3d CKTCadUtility::GetMinPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
{
	AcGePoint3d pt;
	pt.x = min(pt1.x, pt2.x);
	pt.y = min(pt1.y, pt2.y);
	pt.z = min(pt1.z, pt2.z);
	return pt;
}

AcGePoint3d CKTCadUtility::GetMaxPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
{
	AcGePoint3d pt;
	pt.x = max(pt1.x, pt2.x);
	pt.y = max(pt1.y, pt2.y);
	pt.z = max(pt1.z, pt2.z);
	return pt;
}

AcGePoint2d CKTCadUtility::GetMinPoint(const AcGePoint2d& pt1, const AcGePoint2d& pt2)
{
	AcGePoint2d pt;
	pt.x = min(pt1.x, pt2.x);
	pt.y = min(pt1.y, pt2.y);
	return pt;
}

AcGePoint2d CKTCadUtility::GetMaxPoint(const AcGePoint2d& pt1, const AcGePoint2d& pt2)
{
	AcGePoint2d pt;
	pt.x = max(pt1.x, pt2.x);
	pt.y = max(pt1.y, pt2.y);
	return pt;
}

// 判断点是否在立体框内
BOOL CKTCadUtility::IsPointInBox(const AcGePoint3d pt, const AcGePoint3d& ptBox1, const AcGePoint3d& ptBox2)
{
	AcGePoint3d pt1 = GetMinPoint(ptBox1, ptBox2);
	AcGePoint3d pt2 = GetMaxPoint(ptBox1, ptBox2);

	return (!(pt.x < pt1.x || pt.x > pt2.x || pt.y < pt1.y || pt.y > pt2.y || pt.z < pt1.z || pt.z > pt2.z));
}

BOOL CKTCadUtility::IsPointInBox(const AcGePoint2d pt, const AcGePoint2d& ptBox1, const AcGePoint2d& ptBox2)
{
	AcGePoint2d pt1 = GetMinPoint(ptBox1, ptBox2);
	AcGePoint2d pt2 = GetMaxPoint(ptBox1, ptBox2);

	return (!(pt.x < pt1.x || pt.x > pt2.x || pt.y < pt1.y || pt.y > pt2.y));
}

// 取得中点
AcGePoint3d CKTCadUtility::GetMiddlePoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
{
	AcGePoint3d pt((pt1.x + pt2.x) / 2.0, (pt1.y + pt2.y) / 2.0, (pt1.z + pt2.z) / 2.0);
	return pt;
}

AcGePoint2d CKTCadUtility::GetMiddlePoint(const AcGePoint2d& pt1, const AcGePoint2d& pt2)
{
	AcGePoint2d pt((pt1.x + pt2.x) / 2.0, (pt1.y + pt2.y) / 2.0);
	return pt;
}

// acutPolar包装
AcGePoint3d CKTCadUtility::GetPolarPoint(const AcGePoint3d& ptBase, double dAngle, double dDistance)
{
	AcGePoint3d pt;
	acutPolar(asDblArray(ptBase), dAngle, dDistance, asDblArray(pt));
	return pt;
}

// acutAngle包装
double CKTCadUtility::GetAngle(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
{
	return acutAngle(asDblArray(pt1), asDblArray(pt2));
}

double CKTCadUtility::GetAngle(const AcGePoint2d& pt1, const AcGePoint2d& pt2)
{
	return acutAngle(asDblArray(pt1), asDblArray(pt2));
}

double CKTCadUtility::GetAngle(const AcGeVector3d& vec)
{
	return acutAngle(asDblArray(AcGePoint3d::kOrigin), asDblArray(vec));
}

double CKTCadUtility::GetAngle(const AcGeVector2d& vec)
{
	return acutAngle(asDblArray(AcGePoint2d::kOrigin), asDblArray(vec));
}

double CKTCadUtility::GetAngle(const AcGeVector3d& vec1, const AcGeVector3d& vec2)
{
	AcGeVector3d v1 = vec1.project(vec2, vec2);
	AcGeVector3d v2 = vec2.perpVector();

	double dAngle = GetAngle(AcGePoint3d::kOrigin, (AcGePoint3d&)v1, vec2)
					- GetAngle(AcGePoint3d::kOrigin, (AcGePoint3d&)v2, vec2);
	if (dAngle < 0.0)
		dAngle += _2PI;
	if (dAngle < PI_2)
		dAngle = -dAngle;
	else if (dAngle < PI * 1.5)
		dAngle = PI - dAngle;
	else
		dAngle = _2PI - dAngle;

	v1 = vec1;
	v2 = vec2.crossProduct(v2);
	v1.rotateBy(dAngle, vec2);
	dAngle = GetAngle(AcGePoint3d::kOrigin, (AcGePoint3d&)v1, v2)
			- GetAngle(AcGePoint3d::kOrigin, (AcGePoint3d&)vec2, v2);

	return (dAngle < 0.0 ? _2PI + dAngle : dAngle);
}

double CKTCadUtility::GetAngle(const AcGePoint3d& pt1, const AcGePoint3d& pt2, const AcGeVector3d& vecNormal)
{
	AcGePlane plane(AcGePoint3d::kOrigin, vecNormal);
	return GetAngle(pt1.convert2d(plane), pt2.convert2d(plane));
}

// 由起点到终点和bulge定义的圆弧，求圆弧中心，半径，始末角
BOOL CKTCadUtility::GetArcParam(const AcGePoint3d& ptStart, const AcGePoint3d&ptEnd, double dBulge, const AcGeVector3d& vecNormal,
								AcGePoint3d& ptCenter, double& dRadius, double& dStartAngle, double& dEndAngle)
{
	if (fabs(dBulge) < m_KTTol || ptStart == ptEnd)
		return FALSE;

	// 圆心角
	double dAngle1 = atan(fabs(dBulge)) * 4.0;
	// 等腰三角形底角
	double dAngle2 = (PI - dAngle1) / 2.0;
	// 正弦定律求半径
	double dDistance = ptStart.distanceTo(ptEnd);
	dRadius = dDistance / sin(dAngle1) * sin(dAngle2);

	AcGeVector3d vec = ptEnd - ptStart;
	vec.normalize();
	vec.rotateBy(dBulge > 0.0 ? dAngle2 : -dAngle2, vecNormal);
	ptCenter = ptStart + vec * dRadius;

	if (dBulge > 0)
	{
		dStartAngle = GetAngle(ptCenter, ptStart, vecNormal);
		dEndAngle = GetAngle(ptCenter, ptEnd, vecNormal);
	}
	else
	{
		dEndAngle = GetAngle(ptCenter, ptStart, vecNormal);
		dStartAngle = GetAngle(ptCenter, ptEnd, vecNormal);
	}

	return TRUE;
}

// 比较resbuf数据>, =, <
int CKTCadUtility::CompareResBuf(const struct resbuf* pRb1, const struct resbuf* pRb2)
{
	ASSERT(pRb1 != NULL);
	ASSERT(pRb2 != NULL);

	int iCmp = pRb1->restype - pRb2->restype;
	if (iCmp != 0)
		return iCmp;

	double dSub;
	AcDbObjectId id1, id2;
	AcDbHandle handle1, handle2;
	switch (ResBufType2DwgDataType(pRb1->restype))
	{
	case AcDb::kDwgInt8:
		iCmp = pRb1->resval.rint - pRb2->resval.rint;
		break;
	case AcDb::kDwgInt16:
		iCmp = pRb1->resval.rint - pRb2->resval.rint;
		break;
	case AcDb::kDwgInt32:
		iCmp = pRb1->resval.rlong - pRb2->resval.rlong;
		break;
	case AcDb::kDwgReal:
		dSub = pRb1->resval.rreal - pRb2->resval.rreal;
		iCmp = int(dSub); iCmp += (dSub > iCmp); iCmp -= (dSub < iCmp);
		break;
	case AcDb::kDwgText:
		iCmp = _tcscmp(pRb1->resval.rstring, pRb2->resval.rstring);
		break;
	case AcDb::kDwg3Real:
		dSub = pRb1->resval.rpoint[0] - pRb2->resval.rpoint[0];
		iCmp = int(dSub); iCmp += (dSub > iCmp); iCmp -= (dSub < iCmp);
		if (iCmp == 0)
		{
			dSub = pRb1->resval.rpoint[1] - pRb2->resval.rpoint[1];
			iCmp = int(dSub); iCmp += (dSub > iCmp); iCmp -= (dSub < iCmp);
		}
		if (iCmp == 0)
		{
			dSub = pRb1->resval.rpoint[2] - pRb2->resval.rpoint[2];
			iCmp = int(dSub); iCmp += (dSub > iCmp); iCmp -= (dSub < iCmp);
		}
		break;
	case AcDb::kDwgHardOwnershipId:
	case AcDb::kDwgSoftOwnershipId:
	case AcDb::kDwgHardPointerId:
	case AcDb::kDwgSoftPointerId:
		acdbGetObjectId(id1, pRb1->resval.rlname);
		acdbGetObjectId(id2, pRb2->resval.rlname);
		iCmp = (int)(id1.asOldId() - id2.asOldId());
		break;
	case AcDb::kDwgHandle:
		handle1.copyFromOldType(pRb1->resval.ihandle);
		handle2.copyFromOldType(pRb1->resval.ihandle);
		iCmp = (Adesk::UInt32)handle1 - (Adesk::UInt32)handle2;
		break;
	case AcDb::kDwgBChunk:
		iCmp = pRb1->resval.rbinary.clen - pRb2->resval.rbinary.clen;
		break;
	case AcDb::kDwgNull:
		break;
	case AcDb::kDwgNotRecognized:
		break;
	default:
		break;
	}

	return iCmp;
}

// 拷贝Resbuf, 如有string和binary, 也拷贝
BOOL CKTCadUtility::CopyResBuf(struct resbuf* pRbDest, const struct resbuf* pRbSrc)
{
	ASSERT(pRbDest != NULL);
	ASSERT(pRbSrc != NULL);

	pRbDest->restype = pRbSrc->restype;
	CopyMemory(&pRbDest->resval, &pRbSrc->resval, sizeof(ads_u_val));
	switch (ResBufType2DwgDataType(pRbDest->restype))
	{
	case AcDb::kDwgText:
		if (acutNewString(pRbSrc->resval.rstring, pRbDest->resval.rstring) != Acad::eOk)
		{
			pRbDest->resval.rstring = NULL;
			return FALSE;
		}
		break;
	case AcDb::kDwgBChunk:
		if (acutNewBuffer(pRbDest->resval.rbinary.buf, pRbSrc->resval.rbinary.clen) != Acad::eOk)
		{
			pRbDest->resval.rbinary.clen = 0;
			pRbDest->resval.rbinary.buf = NULL;
			return FALSE;
		}
		CopyMemory(pRbDest->resval.rbinary.buf,
					pRbSrc->resval.rbinary.buf,
					pRbSrc->resval.rbinary.clen);
		break;
	}

	return TRUE;
}

// 将resbuf中的restype类型(AcDb::kDxfCode和RTREAL, RT..)转换为AcDb::DwgDataType类型
AcDb::DwgDataType CKTCadUtility::ResBufType2DwgDataType(int iType)
{
	AcDb::DwgDataType restype;
	switch (iType)
	{
	case RTSHORT:
		restype = AcDb::kDwgInt16;
		break;
	case RTLONG:
		restype = AcDb::kDwgInt32;
		break;
	case RTREAL:
	case RTANG:
	case RTORINT:
		restype = AcDb::kDwgReal;
		break;
	case RTSTR:
	case RTDXF0:
		restype = AcDb::kDwgText;
		break;
	case RTPOINT:
	case RT3DPOINT:
		restype = AcDb::kDwg3Real;
		break;
	case RTENAME:
	case RTPICKS:
		restype = AcDb::kDwgSoftPointerId;
		break;
	case RTNONE:
	case RTVOID:
		restype = AcDb::kDwgNull;
		break;
	case RTLB:
	case RTLE:
	case RTDOTE:
	case RTNIL:
	case RTT:
	case RTRESBUF:
		restype = AcDb::kDwgNotRecognized;
		break;
	default:
		restype = acdbGroupCodeToType(iType);
		break;
	}

	return restype;
}

// 将resbuf中有效的string和binary中的内容释放掉(释放当前节点), 其它数据不变
void CKTCadUtility::FreeResBuf(struct resbuf* pRb)
{
	ASSERT(pRb != NULL);

	switch (ResBufType2DwgDataType(pRb->restype))
	{
	case AcDb::kDwgText:
		if (pRb->resval.rstring != NULL)
		{
			acutDelString(pRb->resval.rstring);
			pRb->resval.rstring = NULL;
		}
		break;
	case AcDb::kDwgBChunk:
		if (pRb->resval.rbinary.buf != NULL)
		{
			acutDelBuffer(pRb->resval.rbinary.buf);
			pRb->resval.rbinary.buf = NULL;
			pRb->resval.rbinary.clen = 0;
		}
		break;
	}
}

// 将rbList中所有内容都释放掉
void CKTCadUtility::FreeRbList(struct resbuf* pRbList)
{
	for (struct resbuf* pTemp = pRbList; pTemp != NULL; pTemp = pTemp->rbnext)
	{
		FreeResBuf(pTemp);
	}

	acutRelRb(pRbList);
}

// 取得当前选择集
BOOL CKTCadUtility::GetCurrentPickSet(ads_name ssSet, const struct resbuf* pRbFilter)
{
	return (acedSSGet(_T("I"), NULL, NULL, pRbFilter, ssSet) == RTNORM);
}

// 判断实体是否符合过滤表
BOOL CKTCadUtility::FilterEntity(ads_name adsEnt, const struct resbuf* pRbFilter)
{
	if (pRbFilter == NULL)
		return TRUE;

	ads_name ssSet;
	if (acedSSGet(_T("X"), NULL, NULL, pRbFilter, ssSet) != RTNORM)
		return TRUE;

	BOOL bMatch = (acedSSMemb(adsEnt, ssSet) == RTNORM);

	acedSSFree(ssSet);

	return bMatch;
}

// 按给定的过滤表选择实体(考虑当前选择集)
int CKTCadUtility::SelectEntity(LPCTSTR pszPrompt, ads_name adsEnt, const struct resbuf* pRbFilter,
								 ads_point adsPt, int iFlag, LPCTSTR pszKeyWord)
{
	ads_name ssSet;
	if (adsPt == NULL && acedSSGet(_T("I"), NULL, NULL, pRbFilter, ssSet) == RTNORM)
	{
		Adesk::Int32 lLen = 0l;
		BOOL bFind = (acedSSLength(ssSet, &lLen) == RTNORM && lLen == 1l
			&& acedSSName(ssSet, 0l, adsEnt) == RTNORM);
		acedSSFree(ssSet);
		if (bFind)
		{
			return RTNORM;
		}
	}

	int iRet;
	ads_name ent;
	ads_point pt;

	while (TRUE)
	{
		if (iFlag >= 0)
			acedInitGet(iFlag, pszKeyWord);

		iRet = acedEntSel(pszPrompt, ent, pt);
		if (iRet != RTNORM)
			break;

		if (FilterEntity(ent, pRbFilter))
		{
			CopyMemory(adsEnt, ent, sizeof(ads_name));
			if (adsPt != NULL)
				CopyMemory(adsPt, pt, sizeof(ads_point));
			return RTNORM;
		}
	}

	return iRet;
}

int CKTCadUtility::SelectEntity1(LPCTSTR pszPrompt, ads_name adsEnt, const struct resbuf* pRbFilter,
								 ads_point adsPt, int iFlag, LPCTSTR pszKeyWord, double dPickTol)
{
	ads_name ssSet;
	if (adsPt == NULL && acedSSGet(_T("I"), NULL, NULL, pRbFilter, ssSet) == RTNORM)
	{
		Adesk::Int32 lLen = 0l;
		BOOL bFind = (acedSSLength(ssSet, &lLen) == RTNORM && lLen == 1l
			&& acedSSName(ssSet, 0l, adsEnt) == RTNORM);
		acedSSFree(ssSet);
		if (bFind)
		{
			return RTNORM;
		}
	}

	if (dPickTol < 0.0)
		dPickTol = GetPickBoxSize();

	int iRet;
	ads_point pt, pt1, pt2;
	
	while (TRUE)
	{
		if (iFlag >= 0)
			acedInitGet(iFlag, pszKeyWord);

		iRet = acedGetPoint(NULL, pszPrompt, pt);
		if (iRet != RTNORM)
			break;

		pt1[0] = pt[0] - dPickTol;
		pt1[1] = pt[1] - dPickTol;
		pt1[2] = pt[2];
		pt2[0] = pt[0] + dPickTol;
		pt2[1] = pt[1] + dPickTol;
		pt2[2] = pt[2];
		iRet = acedSSGet(_T("C"), pt1, pt2, pRbFilter, ssSet);

		if (iRet == RTNORM)
		{
			acedSSName(ssSet, 0, adsEnt);
			acedSSFree(ssSet);
			if (adsPt != NULL)
				CopyMemory(adsPt, pt, sizeof(ads_point));
			return RTNORM;
		}
	}
	return iRet;
}

int CKTCadUtility::SelectEntity2(LPCTSTR pszPrompt, ads_name adsEnt, const struct resbuf* pRbFilter)
{
	ads_name ssSet;
	LPCTSTR pszMsg[] = {pszPrompt, _T("")};
	int iRet = acedSSGet(_T(":S:$-I"), pszMsg, NULL, pRbFilter, ssSet);
	if (iRet != RTNORM)
		return iRet;

	acedSSName(ssSet, 0, adsEnt);

	acedSSFree(ssSet);

	return iRet;
}

// 按给定的过滤表选择多个实体(考虑当前选择集)
int CKTCadUtility::SelectEntities(LPCTSTR pszPrompt, ads_name ssSet, const struct resbuf* pRbFilter)
{
	LPCTSTR pszMsg[] = {pszPrompt, _T("")};
	return acedSSGet(_T(":$-I"), pszMsg, NULL, pRbFilter, ssSet);
}

int CKTCadUtility::SelectEntities2(LPCTSTR pszPrompt
	, ads_name ssSet
	, const resbuf *pRbFilter
	, LPCTSTR keyWordList
	, resbuf *(*key_func)(const ACHAR *))
{

	if (!key_func || !keyWordList)
	{
		return SelectEntities(pszPrompt, ssSet, pRbFilter);
	}
	else
	{
		resbuf *(*oldFunc) (const ACHAR *);
		acedSSGetKwordCallbackPtr(&oldFunc);

		acedSSSetKwordCallbackPtr(*key_func);
		LPCTSTR pszMsg[] = {pszPrompt, _T("")};
		int nRes = acedSSGet(_T(":K:$-I"), pszMsg, keyWordList, pRbFilter, ssSet);
		acedSSSetKwordCallbackPtr(*oldFunc);
		return nRes;
	}

	return 0;
}

// 将数组中的点都进行旋转变换
void CKTCadUtility::RotateBy(AcGePoint3dArray& arpt, double dAngle, const AcGeVector3d& vecNormal, const AcGePoint3d& ptOrg)
{
	int iLen = arpt.length();
	for (int i = 0; i < iLen; i++)
	{
		arpt[i].rotateBy(dAngle, vecNormal, ptOrg);
	}
}

// 将数组中的向量都进行旋转变换
void CKTCadUtility::RotateBy(AcGeVector3dArray& arvec, double dAngle, const AcGeVector3d& vecNormal)
{
	int iLen = arvec.length();
	for (int i = 0; i < iLen; i++)
	{
		arvec[i].rotateBy(dAngle, vecNormal);
	}
}

// 将数组中的点都进行比例变换
void CKTCadUtility::ScaleBy(AcGePoint3dArray& arpt, double dScale, const AcGePoint3d& ptOrg)
{
	int iLen = arpt.length();
	for (int i = 0; i < iLen; i++)
	{
		arpt[i] += (arpt[i] - ptOrg) * dScale;
	}
}

// 将数组中的向量都进行比例变换
void CKTCadUtility::ScaleBy(AcGeVector3dArray& arvec, double dScale)
{
	int iLen = arvec.length();
	for (int i = 0; i < iLen; i++)
	{
		arvec[i] *= dScale;
	}
}

// 将数组中的点都进行位移变换
void CKTCadUtility::MoveBy(AcGePoint3dArray& arpt, const AcGeVector3d& vecMove)
{
	int iLen = arpt.length();
	for (int i = 0; i < iLen; i++)
	{
		arpt[i] += vecMove;
	}
}

// 将数组中的点都通过xform变换
void CKTCadUtility::TransformBy(AcGePoint3dArray& arpt, const AcGeMatrix3d& xform)
{
	int iLen = arpt.length();
	for (int i = 0; i < iLen; i++)
	{
		arpt[i].transformBy(xform);
	}
}

// 将数组中的向量都通过xform变换
void CKTCadUtility::TransformBy(AcGeVector3dArray& arvec, const AcGeMatrix3d& xform)
{
	int iLen = arvec.length();
	for (int i = 0; i < iLen; i++)
	{
		arvec[i].transformBy(xform);
	}
}

// 将AcDbEntity对象通过矩阵变换，传入的元素必须是AcDbEntity派生的
void CKTCadUtility::TransformBy(AcDbVoidPtrArray& arpEnties, const AcGeMatrix3d& xform)
{
	int iLen = arpEnties.length();
	for (int i = 0; i < iLen; i++)
	{
		ASSERT(NULL != AcDbEntity::cast((AcRxObject*)arpEnties[i]));
		((AcDbEntity*)arpEnties[i])->transformBy(xform);
	}
}

// 取得一组点的中心点
AcGePoint3d CKTCadUtility::GetCenterPoint(const AcGePoint3dArray& arpt)
{
	AcDbExtents ext;
	int iLen = arpt.length();
	for (int i = 0; i < iLen; i++)
	{
		ext.addPoint(arpt[i]);
	}
	return GetMiddlePoint(ext.minPoint(), ext.maxPoint());
}

// 求点在直线上的投影点
AcGePoint3d CKTCadUtility::GetProjectPoint(const AcGePoint3d& pt, const AcGePoint3d& ptLine, const AcGeVector3d& vecLine)
{
	double dLen = pt.distanceTo(ptLine);
	if (dLen < m_KTTol)
		return pt;

	double dAngle = CKTCadUtility::GetAngle(vecLine, pt - ptLine);
	dLen *= cos(dAngle);

	return (ptLine + vecLine.normal() * dLen);
}

// 求旋转后的点
AcGePoint3d CKTCadUtility::GetRotatePoint(const AcGePoint3d& pt, double dAngle, const AcGeVector3d& vecNormal, const AcGePoint3d& ptOrg)
{
	AcGePoint3d ptRet(pt);
	ptRet.rotateBy(dAngle, vecNormal, ptOrg);
	return ptRet;
}

// 求旋转后的向量
AcGeVector3d CKTCadUtility::GetRotateVector(const AcGeVector3d& vec, double dAngle, const AcGeVector3d& vecNormal)
{
	AcGeVector3d vecRet(vec);
	vecRet.rotateBy(dAngle, vecNormal);
	return vecRet;
}

BOOL CKTCadUtility::GetTextBox(AcDbExtents& ext, LPCTSTR pszTextStr, LPCTSTR pszTextStyle, double dHeight, double dWidthFactor, double dOblique)
{
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("TEXT"), 1, pszTextStr, 7, pszTextStyle, 40, dHeight, 41, dWidthFactor, 51, dOblique, 0);
	ASSERT(NULL != pRb);

	ads_point ptLowLeft, ptUpRight;
	int iRet = acedTextBox(pRb, ptLowLeft, ptUpRight);

	ext.addPoint(asPnt3d(ptLowLeft));
	ext.addPoint(asPnt3d(ptUpRight));

	acutRelRb(pRb);

	return (RTNORM == iRet);
}

void EWDimData::writeXDataMap(AcDbEntity *pEnt, const EWSegment &seg, const int idx)
{
	EWFnctNode node = seg.pDeformationJoints[idx];
	_tcscpy(node.szStake, seg.szStake);

	writeXDataMap(pEnt, node);
};

void EWDimData::writeXDataMap(AcDbEntity *pEnt, const EWFnctNode &node)
{
	AecDbObjXDataMap map;
	map.SetAt(_T("dDistFromPre"), node.dDistFromPre);
	map.SetAt(_T("eFnType"), node.eFnType);

	CString strSpec(_T("")), strName(_T(""));
	switch (node.eFnType)
	{
	case kStartOrEnd:
		strSpec = _T("起始位置"); break;
	case kEspJoint:
		strSpec = _T("变形缝"); break;
	case kDrainWell:
		strSpec = _T("集水井"); break;
	case kPipeDoghouse:
		strSpec = _T("管类投料口"); break;
	case kCableDoghouse:
		strSpec = _T("线缆类投料口"); break;
	case kHeatDoghouse:
		strSpec = _T("热力投料口"); break;
	case kVenDoghouse:
		strSpec = _T("通风口"); break;
	case kFirwWall:
		strSpec = _T("防火墙"); break;
	case kEscapeHatch:
		strSpec = _T("逃生口"); break;
	case kFireOutlet:
		strSpec = _T("消防引出口"); break;
	case kEWOutLethouse:
		strSpec = _T("水电管廊引出口"); break;
	case kHTOutLetHouse:
		strSpec = _T("热力舱引出口"); break;
	case kCrossUplifted:
		strSpec = _T("管廊交叉隆起"); break;
	case kUserDoghouse:
		strSpec = _T("任意开口上下左右"); break;
	case kSinkOutletRoom:
		strSpec = _T("管廊交叉交叉下沉,预制结构"); break;
	case kSinkOutletRoom20:
		strSpec = _T("管廊交叉上部八边形上部结构"); break;
	case kSinkOutletRoom21:
		strSpec = _T("管廊交叉下沉八边形下部结构"); break;
	case kProModel:
		strSpec = node.szNodeDefSpec;
		strName = node.szNodeSpec;
		break;
	case kStackNode:
		strSpec = _T("里程节点"); break;
	case kBDOutLetHouse:
		strSpec = _T("直埋引出"); break;
	case kSubEspJoint:
		strSpec = _T("变形缝"); break;
	default: break;
	}

	CString str(_T(""));
	for (int i = 0; i < 64; ++i)
	{
		str.Format(_T("fNodeDef%d"), i);
		map.SetAt(str, node.fNodeDef[i]);
	}

	map.SetAt(_T("szStake"), node.szStake);
	map.SetAt(_T("szLockId"), node.szLockId);
	map.SetAt(_T("szNodeSpec"), strSpec);
	map.SetAt(_T("szNodeName"), strName);

	//map.SetAt(_T("szNodeDefSpec"), node.szNodeDefSpec);

	map.SetAt(_T("nRoomIndex"), node.nRoomIndex);
	map.SetAt(_T("nFlag"), node.nFlag);

	map.Write(pEnt, _T("DIM_DATA"), false, true);
}

CString CKTCadUtility::GetCurrentVS()
{
	AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
	if (pDb == NULL) return _T("");

	AcString s;

	AcDbViewportTable *pVTable = NULL;
	Acad::ErrorStatus es = pDb->getViewportTable(pVTable, AcDb::kForRead);
	if (es == Acad::eOk)
	{
		AcDbViewportTableRecord *pViewPortRec = NULL;
		es = pVTable->getAt(_T("*Active"), pViewPortRec, AcDb::kForRead);
		if (es == Acad::eOk)
		{
			AcDbObjectId vsid = pViewPortRec->visualStyle();
			AcDbDictionary *pDict;
			es = pDb->getVisualStyleDictionary(pDict, AcDb::kForRead);
			if (es == Acad::eOk)
			{
				pDict->nameAt(vsid, s);
				pDict->close();
			}
		}
		pVTable->close();
		pViewPortRec->close();
	}

	return (LPCTSTR)s;
}