#include "stdafx.h"
#include "AecDbPipeHanger.h"
#include "KTExpressCalc.h"
#include "AecGripCback.h"


Adesk::UInt32 AecDbPipeHanger::kCurrentVersionNumber = 2;

static const Adesk::UInt16 kColorByBlock = 0;
static const Adesk::UInt16 kRed = 1;
static const Adesk::UInt16 kYellow = 2;
static const Adesk::UInt16 kGreen = 3;
static const Adesk::UInt16 kCyan = 4;
static const Adesk::UInt16 kBlue = 5;
static const Adesk::UInt16 kMagenta = 6;
static const Adesk::UInt16 kWhite = 7;
static const Adesk::UInt16 kColorByLayer = 256;

static void FreeBuffer(AcDbVoidPtrArray &arEntPtrs)
{
	AcDbEntity *pEnt = NULL;
	while ( !arEntPtrs.isEmpty() )
	{
		pEnt = (AcDbEntity *)arEntPtrs.last();
		delete pEnt;

		arEntPtrs.removeLast();
	}
}

static int ExtractSubString(CString& str, LPCTSTR pszSteps, CStringArray& arSubStrs)
{
	TCHAR* pchToken = _tcstok((LPTSTR)(LPCTSTR)str, pszSteps);
	while (pchToken != NULL)
	{
		arSubStrs.Add(pchToken);
		pchToken = _tcstok(NULL, pszSteps);
	}
	return arSubStrs.GetSize();
}

static AcDbRegion *CreateRegFromCurves(AcDbVoidPtrArray& arCurs)
{
	AcDbVoidPtrArray arRegPtrs;
	AcDbRegion *pReg = NULL;
	if (Acad::eOk == AcDbRegion::createFromCurves(arCurs, arRegPtrs))
	{
		return (AcDbRegion *)arRegPtrs.first();
	}
	return NULL;
}

static AcDbRegion *CreateRegFromCurve(AcDbCircle& cir)
{
	AcDbVoidPtrArray arCurs;
	arCurs.append(&cir);

	AcDbVoidPtrArray arRegPtrs;
	AcDbRegion *pReg = NULL;
	if (Acad::eOk == AcDbRegion::createFromCurves(arCurs, arRegPtrs))
	{
		return (AcDbRegion *)arRegPtrs.first();
	}
	return NULL;
}

static AcDbObjectId AddToModelSpace(AcDbEntity* pEnt, bool bClose = true)
{
	if (!pEnt) return AcDbObjectId::kNull;

	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
	AcDbObjectId id(AcDbObjectId::kNull);

	AcDbBlockTable* pTbl = NULL;
	Acad::ErrorStatus es;
	if (Acad::eOk == (es = pDb->getBlockTable(pTbl, AcDb::kForRead)))
	{
		AcDbBlockTableRecord* pBTR = NULL;
		if (Acad::eOk == (es = pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite)))
		{
			pTbl->close();
			es = pBTR->appendAcDbEntity(id, pEnt);
			pBTR->close();
			if (bClose) pEnt->close();
		}
	}
	return id;
}

static AcDbRegion * CreatePointsRegion(AcGePoint3dArray& arPts,bool bTest = false) 
{
	int nSize = arPts.length();
	AcDbVoidPtrArray arCurPtrs;
	for (int i = 0; i < nSize - 1; i++)//5
	{
		AcDbLine *pLine = new AcDbLine(arPts[i], arPts[i + 1]);
		arCurPtrs.append(pLine);
	}

	AcDbVoidPtrArray arRegPtrs;
	AcDbRegion *pReg = NULL;
	if (Acad::eOk == AcDbRegion::createFromCurves(arCurPtrs, arRegPtrs))
	{
		//FREE
		if (bTest)
		{
			AcDbEntity* pEnt = NULL;
			for (int i = 0; i < arCurPtrs.length(); i++)
			{
				pEnt = (AcDbEntity*)arCurPtrs.at(i);
				pEnt->setColorIndex(1);
				AddToModelSpace(pEnt);
			}
		}
		else
		{
			FreeBuffer(arCurPtrs);
		}
		return (AcDbRegion *)arRegPtrs.first();
	}
	
	//FREE
	if (bTest)
	{
		AcDbEntity* pEnt = NULL;
		for (int i = 0; i < arCurPtrs.length(); i++)
		{
			pEnt = (AcDbEntity*)arCurPtrs.at(i);
			pEnt->setColorIndex(1);
			AddToModelSpace(pEnt);
		}
	}
	else
	{
		FreeBuffer(arCurPtrs);
	}
	return NULL;
}

static AcDbRegion * CreateCirRegion(AcGePoint3d& pt, double dR, const AcGeVector3d& vtDir)
{
	AcDbCircle cir;
	cir.setCenter(pt);
	cir.setRadius(dR);
	cir.setNormal(vtDir);

	AcDbVoidPtrArray arCurPtrs;
	arCurPtrs.append(&cir);

	AcDbVoidPtrArray arRegPtrs;
	AcDbRegion *pReg = NULL;
	if (Acad::eOk == AcDbRegion::createFromCurves(arCurPtrs, arRegPtrs))
	{
		return (AcDbRegion *)arRegPtrs.first();
	}
	return NULL;
}

typedef CMap<CString, LPCTSTR, AcGePoint2d, AcGePoint2d> CMapStringToPoint;
static CMapStringToPoint g_mapMx;

ACRX_DXF_DEFINE_MEMBERS(AecDbPipeHanger, AecDbEntityBase,
	AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
	AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
	AEC_PIPEHNGR,
	"AecDbPipeHanger"
	"|Product Desc:     shanghua earthworm app obj"
	"|Company:          shanghua inc"
	"|WEB Address:      www.shanghuasoft.com")

AecDbPipeHanger::AecDbPipeHanger()
{
	if (g_mapMx.IsEmpty())
	{
		g_mapMx.SetAt(_T("M5"), AcGePoint2d(4.6, 7.64));
		g_mapMx.SetAt(_T("M6"), AcGePoint2d(5.6, 9.64));
		g_mapMx.SetAt(_T("M8"), AcGePoint2d(7.25, 12.57));
		g_mapMx.SetAt(_T("M10"), AcGePoint2d(8.75, 16.57));
		g_mapMx.SetAt(_T("M12"), AcGePoint2d(10.75, 18.48));
		g_mapMx.SetAt(_T("M16"), AcGePoint2d(13.9, 23.16));
		g_mapMx.SetAt(_T("M20"), AcGePoint2d(16.9, 29.16));
		g_mapMx.SetAt(_T("M22"), AcGePoint2d(18.9, 31.0));
		g_mapMx.SetAt(_T("M24"), AcGePoint2d(20.05, 35.0));
		g_mapMx.SetAt(_T("M27"), AcGePoint2d(23.05, 40.0));
		g_mapMx.SetAt(_T("M30"), AcGePoint2d(25.05, 45.0));
	}

	m_ptIns.set(0,0,0);
	m_dRot = 0;
	m_pElbowArc = NULL;
	m_dElbowOD = 0;
	m_pGripAppData = new AecGripData[GRIP_MAXNUM];
}

AecDbPipeHanger::~AecDbPipeHanger()
{
	if (m_pElbowArc != NULL)
		delete m_pElbowArc;
	m_pElbowArc = NULL;
}

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

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEntityBase::dwgInFields(pFiler);
	if (es != Acad::eOk)
			return (es);
	
	//----- Object version number needs to be read first
	Adesk::UInt32 version = 0;
	if ((es = pFiler->readUInt32(&version)) != Acad::eOk)
		return (es);

	if (version > AecDbPipeHanger::kCurrentVersionNumber)
		return (Acad::eMakeMeProxy);

	Adesk::UInt32 nLen = 0;
	pFiler->readUInt32(&nLen);

	m_arLines.RemoveAll();
	TCHAR *pszTmp = NULL;
	for (int i = 0;i < nLen;i++)
	{
		pszTmp = NULL;
		pFiler->readString(&pszTmp);
		if (pszTmp != NULL)
		{
			m_arLines.Add(pszTmp);
			acutDelString(pszTmp);
		}
	}

	pFiler->readPoint3d(&m_ptIns);
	pFiler->readDouble(&m_dRot);

	m_mapSpecXData.dwgInFields(pFiler);

	if (version > 1)
	{
		AcGePoint3d ptC;
		double dr = 0, dSA = 0, dEA = 0;
		AcGeVector3d vtN(0,0,0);

		pFiler->readPoint3d(&ptC);
		pFiler->readDouble(&dr);
		pFiler->readDouble(&dSA);
		pFiler->readDouble(&dEA);
		pFiler->readVector3d(&vtN);

		if (!vtN.isZeroLength() && dr > 1.e-3)
		{
			if (m_pElbowArc == NULL)
			{
				m_pElbowArc = new AcDbArc;
			}
			m_pElbowArc->setCenter(ptC);
			m_pElbowArc->setRadius(dr);
			m_pElbowArc->setStartAngle(dSA);
			m_pElbowArc->setEndAngle(dEA);
			m_pElbowArc->setNormal(vtN);
		}
		pFiler->readDouble(&m_dElbowOD);
	}

	AcGePoint3d pt = m_ptIns;
	double dRot = m_dRot;
	Insert(pt, dRot);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbPipeHanger::dwgOutFields(AcDbDwgFiler *pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	es = AecDbEntityBase::dwgOutFields(pFiler);
		if (es != Acad::eOk)
			return (es);

	//----- Object version number needs to be saved first
	if ((es = pFiler->writeUInt32(AecDbPipeHanger::kCurrentVersionNumber)) != Acad::eOk)
		return (es);

	Adesk::UInt32 nLen = m_arLines.GetSize();
	pFiler->writeUInt32(nLen);

	CString sLn;
	for (int i = 0;i < nLen;i++)
	{
		sLn = m_arLines.GetAt(i);
		pFiler->writeString((LPCTSTR)sLn);
	}

	pFiler->writePoint3d(m_ptIns);
	pFiler->writeDouble(m_dRot);

	m_mapSpecXData.dwgOutFields(pFiler);

	AcGePoint3d ptC;
	AcGeVector3d vtN(0, 0, 0);
	double dr = 0, dSA = 0, dEA = 0;
	if (m_pElbowArc != NULL)
	{
		ptC = m_pElbowArc->center();
		dr = m_pElbowArc->radius();
		dSA = m_pElbowArc->startAngle();
		dEA = m_pElbowArc->endAngle();
		vtN = m_pElbowArc->normal();

		pFiler->writePoint3d(ptC);
		pFiler->writeDouble(dr);
		pFiler->writeDouble(dSA);
		pFiler->writeDouble(dEA);
		pFiler->writeVector3d(vtN);
	}
	else
	{
		pFiler->writePoint3d(ptC);
		pFiler->writeDouble(dr);
		pFiler->writeDouble(dSA);
		pFiler->writeDouble(dEA);
		pFiler->writeVector3d(vtN);
	}
	pFiler->writeDouble(m_dElbowOD);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbPipeHanger::dxfInFields(AcDbDxfFiler *pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbPipeHanger::dxfOutFields(AcDbDxfFiler *pFiler) const
{
	return Acad::eOk;
}

void AecDbPipeHanger::subList() const
{
	assertReadEnabled();
	AecDbEntityBase::subList();

	CString sName;
	m_mapSpecXData.GetAt(KEY_NAME, sName);
	acutPrintf(_T("\n托架名称:%s"),sName);

	m_mapSpecXData.List();
}

Acad::ErrorStatus AecDbPipeHanger::copyFrom(const AcRxObject *pSrc)
{
	assertWriteEnabled();

	AecDbPipeHanger *pFit = AecDbPipeHanger::cast(pSrc);
	if (pFit != NULL)
	{
		m_arLines.RemoveAll();
		m_arLines.Append(pFit->m_arLines);

		m_mapSpecXData.Empty();
		m_mapSpecXData.AppendFrom(&pFit->m_mapSpecXData);

		if (pFit->m_pElbowArc != NULL)
		{
			if (m_pElbowArc == NULL)
				m_pElbowArc = new AcDbArc;

			m_pElbowArc->copyFrom(pFit->m_pElbowArc);
		}

		m_dElbowOD = pFit->m_dElbowOD;
		m_ptIns = pFit->m_ptIns;
		m_dRot = pFit->m_dRot;
		m_arRecPts.removeAll();
		//m_ar3DSlds.removeAll();
		FreeBuffer(m_ar3DSlds);

		AcGePoint3d pt = m_ptIns;
		double dRot = m_dRot;
		Insert(pt, dRot);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbPipeHanger::subTransformBy(const AcGeMatrix3d &xform)
{
	assertWriteEnabled();

	m_arRecPts.removeAll();
	m_ptIns.transformBy(xform);

	if (m_pElbowArc != NULL)
		m_pElbowArc->transformBy(xform);

	AcGeVector3d vt(1,0,0);
	vt.rotateBy(m_dRot, AcGeVector3d::kZAxis);
	vt.transformBy(xform);

	m_dRot = AcGeVector3d::kXAxis.angleTo(vt, AcGeVector3d::kZAxis);

	AcGePoint3d pt = m_ptIns;
	double dRot = m_dRot;
	Insert(pt, dRot);

	return Acad::eOk;
}

#ifndef KEY_MODE
#define KEY_MODE _T("MODE")
#endif

static void Get45Pts(AcGePoint3d& pt0, AcGePoint3d& pt1, AcGeLineSeg3d& ln, double dW, int nDir)
{
	AcGeVector3d vt = pt1 - pt0;
	vt.normalize();

	AcGePoint3d ptGe[2];

	ptGe[0] = pt0 + vt * 0.5 * dW;

	double dAng = nDir * PI / 4.0;
	vt.rotateBy(dAng, AcGeVector3d::kZAxis);

	ptGe[1] = ptGe[0] + 0.707 * dW * vt;
	ptGe[0] -= 0.707 * dW * vt;

	ln.set(ptGe[0], ptGe[1]);
}

static void Get45Pts(AcGePoint3d& pt0, AcGePoint3d& pt1, AcDbLine* pLn, double dW, int nDir)
{
	if (pLn == NULL)
		return;

	AcGeVector3d vt = pt1 - pt0;
	vt.normalize();

	AcGePoint3d ptGe[2];

	ptGe[0] = pt0 + vt * 0.5 * dW;

	double dAng = nDir * PI / 4.0;
	vt.rotateBy(dAng, AcGeVector3d::kZAxis);

	ptGe[1] = ptGe[0] + 0.707 * dW * vt;
	ptGe[0] -= 0.707 * dW * vt;

	pLn->setStartPoint(ptGe[0]);
	pLn->setEndPoint(ptGe[1]);
}

#ifndef KEY_2DStyle
#define KEY_2DStyle _T("2dStl")
#endif

Acad::ErrorStatus AecDbPipeHanger::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	int nMode = 0,n2dStyle = 0;
	m_mapSpecXData.GetAt(KEY_MODE, nMode);
	m_mapSpecXData.GetAt(KEY_2DStyle, n2dStyle);

	AcGePoint3d pt0, pt1, ptM;
	AcGeLineSeg3d ln;

	if (nMode == 4)//弯管支座
	{
		for (int i = 0; i < m_arRecPts.length() - 1; i++)
		{
			ln.set(m_arRecPts.at(i), m_arRecPts.at(i + 1));
			dc.DrawLine(ln);
		}

		if (m_arRecPts.length() >= 4)
		{
			ln.set(m_arRecPts.at(0), m_arRecPts.at(2));
			dc.DrawLine(ln);
			ln.set(m_arRecPts.at(1), m_arRecPts.at(3));
			dc.DrawLine(ln);
		}
		return Acad::eOk;
	}

	switch (n2dStyle)
	{
		case 0://[x]
		{
			for (int i = 0; i < m_arRecPts.length() - 1; i++)
			{
				ln.set(m_arRecPts.at(i), m_arRecPts.at(i + 1));
				dc.DrawLine(ln);
			}

			if (m_arRecPts.length() >= 4)
			{
				ln.set(m_arRecPts.at(0), m_arRecPts.at(2));
				dc.DrawLine(ln);
				ln.set(m_arRecPts.at(1), m_arRecPts.at(3));
				dc.DrawLine(ln);
			}
			break;
		}
		case 1://*---*
		{
			Midpoint(m_arRecPts.at(0), m_arRecPts.at(3),pt0);
			Midpoint(m_arRecPts.at(1), m_arRecPts.at(2),pt1);
			ln.set(pt0, pt1);
			dc.DrawLine(ln);

			Get45Pts(pt0, pt1, ln,m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
			dc.DrawLine(ln);

			Get45Pts(pt0, pt1, ln,m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
			dc.DrawLine(ln);

			Get45Pts(pt1, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
			dc.DrawLine(ln);

			Get45Pts(pt1, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
			dc.DrawLine(ln);

			break;
		}
		case 2://--*--
		{
			Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
			Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
			ln.set(pt0, pt1);
			dc.DrawLine(ln);

			Midpoint(pt0,pt1,ptM);

			Get45Pts(ptM, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
			dc.DrawLine(ln);

			Get45Pts(ptM, pt0, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
			dc.DrawLine(ln);

			Get45Pts(ptM, pt1, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
			dc.DrawLine(ln);

			Get45Pts(ptM, pt1, ln, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
			dc.DrawLine(ln);

			break;
		}
		default:
			break;
	}
	return Acad::eOk;
}

//获取二维视图显示的图形
int  AecDbPipeHanger::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();

	AecDbObjXDataMap xData;
	xData.CopyFrom(&m_mapSpecXData);

	AcDbLine* pLn = NULL;
	int nMode = 0, n2dStyle = 0;
	m_mapSpecXData.GetAt(KEY_MODE, nMode);
	m_mapSpecXData.GetAt(KEY_2DStyle, n2dStyle);

	AcGePoint3d pt0, pt1, ptM;
	AcGeLineSeg3d ln;

	if (nMode == 4)//弯管支座
	{
		for (int i = 0; i < m_arRecPts.length() - 1; i++)
		{
			pLn = new AcDbLine(m_arRecPts.at(i), m_arRecPts.at(i + 1));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);
		}

		if (m_arRecPts.length() >= 4)
		{
			pLn = new AcDbLine(m_arRecPts.at(0), m_arRecPts.at(2));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);

			pLn = new AcDbLine(m_arRecPts.at(1), m_arRecPts.at(3));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);
		}
		return arEntPtrs.length();
	}

	switch (n2dStyle)
	{
	case 0://[x]
	{
		for (int i = 0; i < m_arRecPts.length() - 1; i++)
		{
			pLn = new AcDbLine(m_arRecPts.at(i), m_arRecPts.at(i + 1));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);
		}

		if (m_arRecPts.length() >= 4)
		{
			pLn = new AcDbLine(m_arRecPts.at(0), m_arRecPts.at(2));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);

			pLn = new AcDbLine(m_arRecPts.at(1), m_arRecPts.at(3));
			pLn->setLayer(layerId());
			xData.Write(pLn, BIMDATA_APP);
			arEntPtrs.append(pLn);
		}
		break;
	}
	case 1://*---*
	{
		Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
		Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);

		pLn = new AcDbLine(pt0, pt1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(pt0, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(pt0, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(pt1, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(pt1, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		break;
	}
	case 2://--*--
	{
		Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
		Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
		
		pLn = new AcDbLine(pt0, pt1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		Midpoint(pt0, pt1, ptM);

		pLn = new AcDbLine;
		Get45Pts(ptM, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(ptM, pt0, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(ptM, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), 1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		pLn = new AcDbLine;
		Get45Pts(ptM, pt1, pLn, m_arRecPts.at(0).distanceTo(m_arRecPts.at(3)), -1);
		pLn->setLayer(layerId());
		xData.Write(pLn, BIMDATA_APP);
		arEntPtrs.append(pLn);

		break;
	}
	default:
		break;
	}
	return arEntPtrs.length();
}

//获取三维显示图形
int AecDbPipeHanger::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const
{
	assertReadEnabled();

	AecDbObjXDataMap xData;
	xData.CopyFrom(&m_mapSpecXData);

	AcDbEntity* pEnt = NULL, *pEntClone = NULL;
	for (int i = 0;i < m_ar3DSlds.length();i++)
	{
		pEnt = (AcDbEntity*)m_ar3DSlds.at(i);
		pEntClone = (AcDbEntity*)pEnt->clone();

		pEntClone->setLayer(layerId());
		if (bWriteBimInfo)
		{
			m_mapSpecXData.Write(pEntClone, BIMDATA_APP);
		}
		arEntPtrs.append(pEntClone);
	}
	return arEntPtrs.length();
}

Acad::ErrorStatus AecDbPipeHanger::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	BOOL nHlr = 0;
	const AecDbObjXDataMap *pMap(&m_mapSpecXData);
	const_cast<AecDbObjXDataMap *>(pMap)->GetAt(HLR_CALC, nHlr);
	if (nHlr)
		return Acad::eOk;

	AcCmTransparency tr = transparency();

	//管线系统屏蔽掉
	if (dc.IsDragging())
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

	int nCrBk = dc.GetColor();
	int nColor = nCrBk;
	if (m_mapSpecXData.GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}

	if (!m_ar3DSlds.isEmpty())
	{
		AcDbEntity *pEnt = NULL;
		for (int i = 0; i < m_ar3DSlds.length(); i++)
		{
			pEnt = (AcDbEntity *)m_ar3DSlds.at(i);
			dc.DrawEntity(*pEnt);
		}

		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}
	return Acad::eOk;
}

AecDbObjXDataMap *AecDbPipeHanger::GetSpecialtyData(AcDb::OpenMode bMode/* = AcDb::kForWrite*/)
{
	switch (bMode)
	{
	case AcDb::kForRead:
	{
		assertReadEnabled();
		break;
	}
	case AcDb::kForWrite:
	{
		if (!isWriteEnabled())
		{
			upgradeOpen();
		}
		assertWriteEnabled();
		break;
	}
	case AcDb::kForNotify:
	{
		assertReadEnabled();
	}
	default:
		break;
	}
	return &m_mapSpecXData;
}

const AecDbObjXDataMap *AecDbPipeHanger::GetSpecialtyData() const
{
	assertReadEnabled();
	return &m_mapSpecXData;
}

Acad::ErrorStatus AecDbPipeHanger::subGetGripPoints(AcDbGripDataPtrArray &grips,
	const double curViewUnitSize,
	const int gripSize,
	const AcGeVector3d &curViewDir,
	const int bitflags) const
{
	assertReadEnabled();

	int i = 0;
	AcDbGripData* pGripData = new AcDbGripData;
	memset(&m_pGripAppData[i], 0, sizeof(AecGripData));
	m_pGripAppData[i].nIndex = i;
	m_pGripAppData[i].ePos = eStart;
	m_pGripAppData[i].ptGrip = m_ptIns;
	m_pGripAppData[i].nColor = kBlue;
	_tcscpy(m_pGripAppData[i].szTip, _T("位置夹点"));
	m_pGripAppData[i].pOwner = (AcDbEntity *)this;
	m_pGripAppData[i].idHost = objectId();

	pGripData->setGripPoint(m_ptIns);
	pGripData->setAppData((void *)&m_pGripAppData[i]);
	pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
	pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
	grips.append(pGripData);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbPipeHanger::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
{
	assertWriteEnabled();

	m_ptIns += offset;

	AcGePoint3d pt = m_ptIns;
	double dRot = m_dRot;
	Insert(pt, dRot);

	return Acad::eOk;
}

BOOL AecDbPipeHanger::AddVar(AecDbObjXDataMap *pXData)
{
	assertWriteEnabled();
	m_mapSpecXData.SetAt(_T("PI"), 3.1415926);
	return m_mapSpecXData.AppendFrom(pXData);
}

BOOL AecDbPipeHanger::GetVar(AecDbObjXDataMap& xData) const
{
	assertReadEnabled();
	xData.CopyFrom(&m_mapSpecXData);
	return TRUE;
}

BOOL AecDbPipeHanger::CLC(CString &sTxt)
{
	assertWriteEnabled();

	CString sKey, sVal;
	AecXData xData;
	AecDbObjXDataMap::It it = m_mapSpecXData.Begin();
	AecDbObjXDataMap::It end = m_mapSpecXData.End();
	KTExpressCalc cal;

	for (; it != end; )
	{
		m_mapSpecXData.GetNext(it, sKey, xData);
		if (xData.nVt == VT_UI4 ||
			xData.nVt == VT_I4)
		{
			cal.SetVariableData(sKey, 1.0 * xData.nVal);
		}
		else if (xData.nVt == VT_R8)
		{
			cal.SetVariableData(sKey, xData.dVal[0]);
		}
		else
		{
			//...
		}
	}

	double dVal = 0.0;
	if (cal.Calculate(sTxt, dVal))
		sTxt.Format(_T("%.3f"), dVal);
	
	return TRUE;
}

BOOL AecDbPipeHanger::AddLine(LPCTSTR pszLine)
{
	assertWriteEnabled();
	CString sLine = pszLine;
	int nPos = sLine.Find(_T(';'));
	if (nPos == 0)
		return FALSE;

	m_arLines.Add(pszLine);
	return TRUE;
}

BOOL AecDbPipeHanger::LoadPmsFile(LPCTSTR pszSrcFullFile)
{
	assertWriteEnabled();

	CStdioFile file;
	if (file.Open(pszSrcFullFile, CFile::modeRead | CFile::typeText))
	{
		m_arLines.RemoveAll();
		FreeBuffer(m_ar3DSlds);

		CString sLn;
		while (file.ReadString(sLn))
		{
			sLn.TrimRight();
			AddLine(sLn);
		}
		file.Close();
		return TRUE;
	}
	return FALSE;
}

BOOL AecDbPipeHanger::SetElbow(AcDbArc* pElbowBase, double dOD)
{
	assertWriteEnabled();

	m_pElbowArc = pElbowBase;
	m_dElbowOD = dOD;
	return TRUE;
}

void AecDbPipeHanger::CLC(CStringArray &arLt)
{
	CString sTmp;
	for (int i = 0; i < arLt.GetSize(); i++)
	{
		sTmp = arLt.GetAt(i);
		CLC(sTmp);
		arLt.SetAt(i, sTmp);
	}
}

static AcDbRegion *CreateFromPoints(AcGePoint3dArray& arPts)
{
	AcDbLine *pLn = NULL;
	AcDbVoidPtrArray arLns;
	for (int i = 0; i < arPts.length() - 1; i++)
	{
		pLn = new AcDbLine(arPts.at(i), arPts.at(i + 1));
		arLns.append(pLn);
	}

	AcDbVoidPtrArray arRgs;
	AcDbRegion::createFromCurves(arLns, arRgs);

	FreeBuffer(arLns);
	//TEST
	/*static int nColor = 1;
	AcDbEntity *pEnt = NULL;
	while (!arLns.isEmpty())
	{
		pEnt = (AcDbEntity *)arLns.last();
		pEnt->setColorIndex(nColor);
		AddToModelSpace(pEnt);
		arLns.removeLast();
	}
	nColor += 1;*/

	if (!arRgs.isEmpty())
	{
		return (AcDbRegion *)arRgs.first();
	}
	return NULL;
}

AcDbRegion *AecDbPipeHanger::AI(CStringArray& arLt,AcGePoint3d& ptOrg)
{
	if (arLt.GetSize() >= 8)
	{
		CLC(arLt);

		double dL = _ttof(arLt.GetAt(0)), dt = _ttof(arLt.GetAt(1));
		
		AcGeVector3d vtX(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));
		AcGeVector3d vtY(_ttof(arLt[5]), _ttof(arLt[6]), _ttof(arLt[7]));
		vtX.normalize(); vtY.normalize();

		AcGePoint3d pt = ptOrg, pt1;

		AcGePoint3dArray arPts;
		arPts.append(pt);

		pt += vtX * dL;
		arPts.append(pt);

		pt += vtY * dt;
		arPts.append(pt);

		double dX1 = (dL - dt);
		pt -= vtX * dX1;
		arPts.append(pt);

		pt += vtY * dX1;
		arPts.append(pt);

		pt -= vtX * dt;
		arPts.append(pt);

		arPts.append(arPts.first());

		return CreateFromPoints(arPts);
	}
	return NULL;
}

AcDbRegion *AecDbPipeHanger::CS(CStringArray& arLt, AcGePoint3d& ptOrg)
{
	if (arLt.GetSize() >= 9)
	{
		CLC(arLt);

		double dL = _ttof(arLt.GetAt(0));
		double dt = _ttof(arLt.GetAt(1));
		double db = _ttof(arLt.GetAt(2));

		AcGeVector3d vtX(_ttof(arLt[3]), _ttof(arLt[4]), _ttof(arLt[5]));
		AcGeVector3d vtY(_ttof(arLt[6]), _ttof(arLt[7]), _ttof(arLt[8]));
		vtX.normalize(); vtY.normalize();

		AcGePoint3d pt = ptOrg, pt1;

		AcGePoint3dArray arPts;
		arPts.append(pt);

		pt += vtX * dL;
		arPts.append(pt);

		pt += vtY * db;
		arPts.append(pt);

		pt -= vtX * dt;
		arPts.append(pt);

		double dbt = (db - dt);
		pt -= vtY * dbt;
		arPts.append(pt);

		double dl2t = (dL - 2.0 * dt);
		pt -= vtX * dl2t;
		arPts.append(pt);

		pt += vtY * dbt;
		arPts.append(pt);

		pt -= vtX * dt;
		arPts.append(pt);

		arPts.append(arPts.first());

		return CreateFromPoints(arPts);
	}
	return NULL;
}

AcDbRegion *AecDbPipeHanger::RX(CStringArray &arLt, AcGePoint3d &ptOrg)
{
	if (arLt.GetSize() >= 8)
	{
		CLC(arLt);

		double dX = _ttof(arLt.GetAt(0));
		double dY = _ttof(arLt.GetAt(1));

		AcGeVector3d vtX(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));
		AcGeVector3d vtY(_ttof(arLt[5]), _ttof(arLt[6]), _ttof(arLt[7]));
		vtX.normalize(); vtY.normalize();

		AcGePoint3d pt = ptOrg;
		AcGePoint3dArray arPts;

		pt -= vtX * 0.5 * dX;
		pt -= vtY * 0.5 * dY;
		arPts.append(pt);

		pt += vtX * dX;
		arPts.append(pt);

		pt += vtY * dY;
		arPts.append(pt);

		pt -= vtX * dX;
		arPts.append(pt);

		arPts.append(arPts.first());

		return CreateFromPoints(arPts);
	}
	return NULL;
}

BOOL AecDbPipeHanger::Ex(AcDbRegion* pRg, const AcGePoint3d& pt0, const AcGePoint3d & pt1, BOOL bDelRg)
{
	if (pRg != NULL)
	{
		AcDbLine ln(pt0, pt1);
		return Ex(pRg, &ln, 0.0, bDelRg);
	}
	return FALSE;
}

static void Mir(AcGePoint3dArray& arPts, AcGePoint3d& ptOrg, AcGeVector3d& vtN)
{
	AcGePlane plan;
	plan.set(ptOrg, vtN);

	AcGePoint3dArray arPts2;
	arPts2.append(arPts);

	AcGePoint3d pt;
	while(!arPts2.isEmpty())
	{
		pt = arPts2.last();
		arPts2.removeLast();

		pt.mirror(plan);
		arPts.append(pt);
	}
}

AcDbRegion* AecDbPipeHanger::HS(CStringArray& arLt, AcGePoint3d& ptOrg)
{
	if (arLt.GetSize() >= 10)
	{
		CLC(arLt);

		double dH = _ttof(arLt.GetAt(0));
		double dB = _ttof(arLt.GetAt(1));
		double dt1 = _ttof(arLt.GetAt(2));
		double dt2 = _ttof(arLt.GetAt(3));

		AcGeVector3d vtX(_ttof(arLt[4]), _ttof(arLt[5]), _ttof(arLt[6]));
		AcGeVector3d vtZ(_ttof(arLt[7]), _ttof(arLt[8]), _ttof(arLt[9]));
		vtX.normalize(); vtZ.normalize();

		AcGePoint3d pt = ptOrg;
		AcGePoint3dArray arPts;

		pt += vtZ * dH;
		pt += vtX * 0.5 * dB;
		arPts.append(pt);

		pt -= vtZ * dt2;
		arPts.append(pt);

		pt -= vtX * (0.5 * dB - 0.5 * dt1);
		arPts.append(pt);

		pt -= vtZ * (dH - 2.0 * dt2);
		arPts.append(pt);

		pt += vtX * (0.5 * dB - 0.5 * dt1);
		arPts.append(pt);

		pt -= vtZ * dt2;
		arPts.append(pt);

		Mir(arPts, ptOrg, vtX);
		arPts.append(arPts.first());

		return CreatePointsRegion(arPts);
	}
	return NULL;
}

AcDbRegion* AecDbPipeHanger::PIP(CStringArray& arLt, AcGePoint3d& ptOrg)
{
	if (arLt.GetSize() >= 5)
	{
		CLC(arLt);

		double dID = _ttof(arLt.GetAt(0));
		double dt = _ttof(arLt.GetAt(1));

		AcGeVector3d vtN(_ttof(arLt[2]), _ttof(arLt[3]), _ttof(arLt[4]));

		AcDbCircle cirI;
		cirI.setCenter(ptOrg);
		cirI.setRadius(0.5*dID);
		cirI.setNormal(vtN);

		AcDbCircle cirO;
		cirO.setCenter(ptOrg);
		cirO.setRadius(0.5*dID + dt);
		cirO.setNormal(vtN);

		AcDbRegion *pRgO = CreateRegFromCurve(cirO);
		if (pRgO != NULL)
		{
			if (dt < 1.e-6)
			{
				return pRgO;
			}
			else
			{
				AcDbRegion *pRgI = CreateRegFromCurve(cirI);
				if (pRgI != NULL)
				{
					if (Acad::eOk == pRgO->booleanOper(AcDb::kBoolSubtract, pRgI))
					{
						return pRgO;
					}
				}
			}
		}
	}
	return NULL;
}

BOOL AecDbPipeHanger::EX(CString &sLn)
{
	int nPos1 = -1, nPos2 = -1;
	nPos1 = sLn.Find(_T('('));
	nPos2 = sLn.Find(_T(')'));

	CString sTxt,sXYZ;
	CStringArray arTxts;

	if (nPos1 != -1 && nPos2 != -1)
	{
		//pt ... 
		sTxt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
		ExtractSubString(sTxt, _T(","), arTxts);

		AcGeDoubleArray arVals;
		for (int j = 0;j < arTxts.GetSize();j++)
		{
			sXYZ = arTxts.GetAt(j);
			CLC(sXYZ);

			arVals.append(_ttof(sXYZ));
		}

		if (arVals.length() >= 6)
		{
			AcGePoint3d pt0(arVals[0], arVals[1], arVals[2]);
			AcGePoint3d pt1(arVals[3], arVals[4], arVals[5]);
			CString sSec, sLt;
			CStringArray arLt;

			nPos1 = sLn.Find( _T(':') );
			if (nPos1 != -1)
			{
				sSec = sLn.Mid(nPos1 + 1);

				if (sSec.Find(_T("AI")) != -1)
				{
					nPos1 = sSec.Find(_T('('));
					nPos2 = sSec.Find(_T(')'));

					if (nPos1 != -1 && nPos2 != -1)
					{
						sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
						ExtractSubString(sLt, _T(","), arLt);

						if (arLt.GetSize() >= 8)
						{
							AcDbRegion *pRg = AI(arLt, pt0);
							if (pRg != NULL)
							{
								Ex(pRg, pt0, pt1,TRUE);
							}
						}
					}
				}
				else if (sSec.Find(_T("CS")) != -1)
				{
					nPos1 = sSec.Find(_T('('));
					nPos2 = sSec.Find(_T(')'));

					if (nPos1 != -1 && nPos2 != -1)
					{
						sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
						ExtractSubString(sLt, _T(","), arLt);

						if (arLt.GetSize() >= 9)
						{
							CString sb = arLt.GetAt(2);
							CLC(sb);

							double db = _ttof(sb);
							if (db < 1.e-3)//L
							{
								arLt.RemoveAt(2);
								AcDbRegion *pRg = AI(arLt, pt0);
								if (pRg != NULL)
								{
									Ex(pRg, pt0, pt1, TRUE);
								}
							}
							else//[
							{
								AcDbRegion *pRg = CS(arLt, pt0);
								if (pRg != NULL)
								{
									Ex(pRg, pt0, pt1, TRUE);
								}
							}
						}
					}
				}
				else if (sSec.Find(_T("RX")) != -1)
				{
					nPos1 = sSec.Find(_T('('));
					nPos2 = sSec.Find(_T(')'));

					if (nPos1 != -1 && nPos2 != -1)
					{
						sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
						ExtractSubString(sLt, _T(","), arLt);

						if (arLt.GetSize() >= 8)
						{
							AcDbRegion *pRg = RX(arLt, pt0);
							if (pRg != NULL)
							{
								Ex(pRg, pt0, pt1, TRUE);
							}
						}
					}
				}
				else if (sSec.Find(_T("PL")) != -1)
				{
					if (nPos1 != -1 && nPos2 != -1)
					{

					}
				}
				else if (sSec.Find(_T("HS")) != -1)
				{
					if (nPos1 != -1 && nPos2 != -1)
					{
						nPos1 = sSec.Find(_T('('));
						nPos2 = sSec.Find(_T(')'));

						if (nPos1 != -1 && nPos2 != -1)
						{
							sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
							ExtractSubString(sLt, _T(","), arLt);

							if (arLt.GetSize() >= 10)
							{
								AcDbRegion* pRg = HS(arLt, pt0);
								if (pRg != NULL)
								{
									Ex(pRg, pt0, pt1, TRUE);
								}
							}
						}
					}
				}
				else if (sSec.Find(_T("PIP")) != -1)
				{
					if (nPos1 != -1 && nPos2 != -1)
					{
						nPos1 = sSec.Find(_T('('));
						nPos2 = sSec.Find(_T(')'));
						if (nPos1 != -1 && nPos2 != -1)
						{
							sLt = sSec.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
							ExtractSubString(sLt, _T(","), arLt);

							if (arLt.GetSize() >= 5)
							{
								AcDbRegion* pRg = PIP(arLt, pt0);
								if (pRg != NULL)
								{
									Ex(pRg, pt0, pt1, TRUE);
								}
							}
						}
					}
				}
				else
				{
					//...
				}
			}
		}
	}
	return TRUE;
}

BOOL AecDbPipeHanger::SLC(CString &sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));

	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sTxt;
		sTxt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arXYZ;
		ExtractSubString(sTxt, _T(","), arXYZ);

		for (int i = 0;i < arXYZ.GetSize();i++)
		{
			sTxt = arXYZ.GetAt(i);
			CLC(sTxt);
			
			arXYZ.SetAt(i, sTxt);
		}

		if (arXYZ.GetSize() == 6)
		{
			AcGePoint3d ptOrg( _ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
			AcGeVector3d vtNm( _ttof(arXYZ[3]), _ttof(arXYZ[4]), _ttof(arXYZ[5]));

			AcGePlane pln;
			pln.set(ptOrg, vtNm);

			if ( !m_ar3DSlds.isEmpty() )
			{
				AcDb3dSolid *pSld = (AcDb3dSolid *)m_ar3DSlds.last();
				if (pSld != NULL)
				{
					AcDb3dSolid *pNeg = NULL;
					if (Acad::eOk == pSld->getSlice(pln, Adesk::kFalse, pNeg))
					{
						return TRUE;
					}
				}
			}
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::NUT(AcGePoint3d& pt, CString& sMx, const AcGeVector3d& vtDir,AcGePoint3d& ptTo,BOOL bGst)
{
	CString sMxKey;
	sMxKey.Format(_T("M%d"), _ttoi(sMx));

	AcGePoint2d ptMs;
	if (!g_mapMx.Lookup(sMxKey, ptMs))
		return FALSE;

	int nDn = _ttoi(sMx);

	AcGeVector3d vtP = vtDir.perpVector();
	vtP.normalize();

	double dR = 0.5 * ptMs.y / cos(PI / 6.0);
	AcGePoint3d pt2 = pt + vtP * dR;

	AcGePoint3dArray arPts;
	arPts.append(pt2);

	for (int i = 0; i < 6; i++)
	{
		pt2.rotateBy(PI / 3.0, vtDir, pt);
		arPts.append(pt2);
	}

	AcDbRegion *pRg = CreatePointsRegion(arPts);
	if (pRg != NULL)
	{
		AcDbEntity *p3dEnt = NULL;
		if (bGst)
		{
			AcDbRegion *pRgGst = CreateCirRegion(pt, dR, vtDir);
			if (pRgGst != NULL)
			{
				AcGePoint3d pt1 = pt + vtDir * 1.5;
				AcDbLine ln2(pt, pt1);
				Ex(pRgGst, &ln2);
			}
		}

		AcGeVector3d vtM;
		vtM = vtDir;
		if (bGst)
		{
			vtM *= 1.5;
			AcGeMatrix3d xM;
			xM.setToTranslation(vtM);
			pRg->transformBy(xM);
		}

		AcGePoint3d ptF, ptT;
		ptF = pt + vtM;
		ptT = ptF + ptMs.x * vtDir;
		ptTo = ptT;
		AcDbLine ln1(ptF, ptT);
		Ex(pRg, &ln1);
	}
	return TRUE;
}

BOOL AecDbPipeHanger::PZT(AcGePoint3d &pt, CString &sMx, AcGeVector3d &vtDir)
{
	CString sMxKey;
	sMxKey.Format(_T("M%d"), _ttoi(sMx));

	AcGePoint2d ptMs;
	if (!g_mapMx.Lookup(sMxKey, ptMs))
		return FALSE;

	int nDn = _ttoi(sMx);

	AcGeVector3d vtP = vtDir.perpVector();
	vtP.normalize();

	double dR = 0.5 * ptMs.y;
	AcDbRegion *pRg = CreateCirRegion(pt, dR, vtDir);
	if (pRg != NULL)
	{
		AcDbEntity *p3dEnt = NULL;
	
		AcGeVector3d vtM;
		vtM = vtDir;
		
		AcGePoint3d ptF, ptT;
		ptF = pt + vtM;
		ptT = ptF + ptMs.x * vtDir;
		AcDbLine ln1(ptF, ptT);
		Ex(pRg, &ln1, PI / 36.0,TRUE);
	}
	return TRUE;
}

BOOL AecDbPipeHanger::SCR(AcGePoint3d &pt, CString &sMx, const AcGeVector3d &vtDir, double dL)
{
	CString sMxKey;
	sMxKey.Format(_T("M%d"), _ttoi(sMx));

	AcGePoint2d ptMs;
	if (!g_mapMx.Lookup(sMxKey, ptMs))
		return FALSE;

	int nDn = _ttoi(sMx);

	AcDbRegion *pRgH = CreateCirRegion(pt, 0.5 * nDn, vtDir);
	if (pRgH != NULL)
	{
		AcGePoint3d pt1 = pt + vtDir * dL;
		AcDbLine ln2(pt, pt1);
		Ex(pRgH, &ln2);
	}
	return TRUE;
}

BOOL AecDbPipeHanger::Blt(AcGePoint3d& pt, CString& sMx, AcGeVector3d& vtDir,double dL,int nNutE)
{
	AcGeVector3d vt = vtDir;
	vt.negate();

	AcGePoint3d ptTo1;
	NUT(pt, sMx, vt,ptTo1,TRUE);

	SCR(pt,sMx,vtDir,dL);

	if (nNutE > 0)
	{
		pt += vtDir * dL;
		vtDir.negate();

		AcGePoint3d ptTo2;
		NUT(pt, sMx, vt, ptTo2, FALSE);
	}
	else
	{
		pt += vtDir * dL;
		vtDir.negate();
		PZT(pt, sMx, vt);
	}
	return TRUE;
}

BOOL AecDbPipeHanger::BLT(CString &sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));

	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sBt = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arTxts;
		ExtractSubString(sBt, _T(","), arTxts);

		CString sTx;
		for (int i = 0;i < arTxts.GetSize();i++)
		{
			sTx = arTxts.GetAt(i);
			CLC(sTx);
			
			arTxts.SetAt(i, sTx);
		}

		int nNutE = 1;
		if (arTxts.GetSize() > 8)
		{
			nNutE = _ttoi(arTxts.GetAt(arTxts.GetSize()-1));
		}

		if (arTxts.GetSize() >= 8)
		{
			AcGePoint3d pt(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
			CString sMx = arTxts.GetAt(3);

			AcGeVector3d vtDir(_ttof(arTxts[4]), _ttof(arTxts[5]), _ttof(arTxts[6]));
			double dL = _ttof(arTxts[7]);

			return Blt(pt,sMx,vtDir,dL,nNutE);
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::Ex(double dr, AcDbCurve* pCur)
{
	if (pCur != NULL)
	{
		AcGeVector3d vtN;
		double dS = 0.0;
		pCur->getStartParam(dS);
		pCur->getFirstDeriv(dS, vtN);
		
		AcGePoint3d ptS;
		pCur->getStartPoint(ptS);
			
		AcDbCircle cir;
		cir.setCenter(ptS);
		cir.setRadius(dr);
		cir.setNormal(vtN);

		AcDbRegion *pRg = CreateRegFromCurve(cir);
		if (pRg != NULL)
		{
			Acad::ErrorStatus es;
			AcDb3dSolid *pSolid = new AcDb3dSolid;
			if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, pCur)))
			{
				m_ar3DSlds.append(pSolid);
				delete pRg;
				return TRUE;
			}
			else
			{
				delete pRg;
				delete pSolid;
			}
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::Ex(AcDbRegion* pRg, AcDbCurve* pCur, double dTrag, BOOL bDeleteRg)
{
	if (pRg != NULL)
	{
		Acad::ErrorStatus es;
		AcDb3dSolid* pSolid = new AcDb3dSolid;
		if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, pCur,dTrag)))
		{
			m_ar3DSlds.append(pSolid);
			if (bDeleteRg) delete pRg;
			return TRUE;
		}
		else
		{
			if (bDeleteRg) delete pRg;
			delete pSolid;
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::PCP(CString &sLn)
{
	return PCP6(sLn);
}

BOOL AecDbPipeHanger::PCP5(CString &sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		AcGeVector3d vtPip = AcGeVector3d::kYAxis;
		AcGeVector3d vtNUT = AcGeVector3d::kZAxis;

		int nNPs1 = sLn.Find(_T('['));
		int nNPs2 = sLn.Find(_T(']'));
		if (nNPs1 != -1 && nNPs2 != -1)
		{
			CString sPipeDir = sLn.Mid(nNPs1 + 1, nNPs2 - nNPs1 - 1);

			CStringArray arXYZ;
			ExtractSubString(sPipeDir, _T(","), arXYZ);
			if (arXYZ.GetSize() == 3)
			{
				vtPip.set(_ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
			}
		}

		CStringArray arTxts;
		ExtractSubString(sPIPECP, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		if (arTxts.GetSize() >= 17)
		{
			AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
			AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));

			vtNUT = vtDir.crossProduct(vtPip);//XxY=Z
			vtNUT.normalize();//Z

			double dA = _ttof(arTxts[12]);
			double dt = _ttof(arTxts[15]);
			double dH = _ttof(arTxts[10]);
			double dd = _ttof(arTxts.GetAt(8));
			double dR = _ttof(arTxts.GetAt(7));
			double dw = _ttof(arTxts.GetAt(13));
			double db = _ttof(arTxts.GetAt(14));
			CString sMx = arTxts.GetAt(6);

			AcGePoint3d ptNut1, ptNut2, ptA1, ptA2, ptNs, ptNe,ptNut11,ptNut22;
			ptNut1 = ptPos;

			ptNut1 -= vtDir * 0.5 * dA;
			ptNut1 -= vtNUT * dt;

			NUT(ptNut1, sMx, -vtNUT, ptNut11,TRUE);

			ptNut2 = ptNut1 + vtDir * dA;
			NUT(ptNut2, sMx, -vtNUT, ptNut22,TRUE);

			double dLS = dR + dt;//不可以用H,H为冗长
			ptA1 = ptNut1 + vtNUT * dLS;
			ptA2 = ptNut2 + vtNUT * dLS;

			ptNs = ptNut11 - vtNUT * 5.0;
			ptNe = ptNut22 - vtNUT * 5.0;

			AcDbLine ln(ptNs, ptA1);
			Ex(0.5 * dd, &ln);

			ln.setStartPoint(ptNe);
			ln.setEndPoint(ptA2);
			Ex(0.5 * dd, &ln);

			AcGePoint3d ptCen = ptA1 + vtDir * 0.5 * dA;
			AcDbArc arc;
			arc.setCenter(ptCen);
			arc.setRadius(0.5 * dA);
			arc.setStartAngle(0);
			arc.setEndAngle(PI);
			arc.setNormal(vtPip);

			Ex(0.5 * dd, &arc);
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::OMG(AcGePoint3d& ptPos, double dR, double dA, double da1, double db,double dt2,double dr,AcGeVector3d& vtDir)
{
	AcGePoint3d pt;
	AcDbPolyline pl;
	pl.setNormal(AcGeVector3d::kYAxis);
	pl.setElevation(ptPos.y);

	AcGePlane pln(AcGePoint3d::kOrigin, AcGeVector3d::kYAxis);

	int i = 0;
	pt = ptPos;
	pt += AcGeVector3d(0, 0, 1) * dt2;

	pt -= vtDir * 0.5 * dA;
	pt -= vtDir * da1;
	pl.addVertexAt(i++, pt.convert2d(pln));

	pt += vtDir * (2.0 * da1 - dr - 0.5 * dt2);
	pl.addVertexAt(i++, pt.convert2d(pln), -tan(PI / 8.0));

	pt += vtDir * dr;
	pt += AcGeVector3d::kZAxis * dr;
	pl.addVertexAt(i++, pt.convert2d(pln), 0);

	pt += AcGeVector3d::kZAxis * (dR - dr - db);
	pl.addVertexAt(i++, pt.convert2d(pln), 1.0);

	pt += vtDir * (2.0 * dR + 2.0 * dt2);
	pl.addVertexAt(i++, pt.convert2d(pln));

	pt -= AcGeVector3d::kZAxis * (dR - dr - db);
	pl.addVertexAt(i++, pt.convert2d(pln), -tan(PI / 8.0));

	pt -= AcGeVector3d::kZAxis * dr;
	pt += vtDir * dr;
	pl.addVertexAt(i++, pt.convert2d(pln));

	pt = ptPos;
	pt += vtDir * 0.5 * dA;
	pt += vtDir * da1;
	pt += AcGeVector3d(0, 0, 1) * dt2;
	pl.addVertexAt(i++, pt.convert2d(pln));
	
	double dX = db;
	double dY = dt2;

	AcGeVector3d vtX = AcGeVector3d(0,1,0);
	AcGeVector3d vtY = AcGeVector3d(0, 0, -1);
	vtX.normalize(); vtY.normalize();

	pt = ptPos;
	pt += AcGeVector3d(0, 0, 1) * dt2;

	pt -= vtDir * 0.5 * dA;
	pt -= vtDir * da1;

	AcGePoint3dArray arPts;

	pt -= vtX * 0.5 * dX;
	arPts.append(pt);

	pt += vtX * dX;
	arPts.append(pt);

	pt += vtY * dY;
	arPts.append(pt);

	pt -= vtX * dX;
	arPts.append(pt);

	arPts.append(arPts.first());

	AcDbRegion* pRg = CreateFromPoints(arPts);
	return Ex(pRg, &pl);
}

BOOL AecDbPipeHanger::PCP7(CString& sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arTxts;
		ExtractSubString(sPIPECP, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		if (arTxts.GetSize() >= 20)
		{
			AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
			AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));

			double dA = _ttof(arTxts[13]);
			double dt3 = _ttof(arTxts[9]);
			double dt2 = _ttof(arTxts[16]);
			double dt1 = _ttof(arTxts[17]);
			double dt_ = _ttof(arTxts[18]);
			double dr = _ttof(arTxts[19]);
			double da1 = _ttof(arTxts[10]);
			double dR = _ttof(arTxts[7]);
			double db = _ttof(arTxts[15]);

			CString sMx = arTxts.GetAt(6);

			AcGePoint3d ptNut1, ptNut2, ptA1, ptA2, ptNs, ptNe, ptNut11, ptNut22,pt;
			ptNut1 = ptPos;

			ptNut1 -= vtDir * 0.5 * dA;
			ptNut1 -= AcGeVector3d::kZAxis * dt2;

			NUT(ptNut1, sMx, -AcGeVector3d::kZAxis, ptNut11, TRUE);
			
			SCR(ptNut1, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2 );

			ptNut2 = ptNut1 + vtDir * dA;
			NUT(ptNut2, sMx, -AcGeVector3d::kZAxis, ptNut22, TRUE);

			SCR(ptNut2, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2 );

			SCR(ptNut2, sMx, AcGeVector3d(0, 0, 1), dt3 + dt2);

			ptNut1 = ptPos;
			ptNut1 -= vtDir * 0.5 * dA;
			ptNut1 += AcGeVector3d::kZAxis * dt1;
			NUT(ptNut1, sMx, AcGeVector3d(0,0,1), ptNut11, TRUE);

			SCR(ptNut11, sMx, AcGeVector3d(0, 0, 1), 5.0);

			ptNut2 = ptNut1 + vtDir * dA;
			NUT(ptNut2, sMx, AcGeVector3d(0,0,1), ptNut22, TRUE);

			SCR(ptNut22, sMx, AcGeVector3d(0, 0, 1), 5.0);

			OMG(ptPos,dR,dA,da1, db,dt1,dr,vtDir);

			return TRUE;
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::PCP6(CString &sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sPIPECP = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);
		
		AcGeVector3d vtPip = AcGeVector3d::kYAxis;
		AcGeVector3d vtNUT = AcGeVector3d::kZAxis;

		int nNPs1 = sLn.Find(_T('['));
		int nNPs2 = sLn.Find(_T(']'));
		if (nNPs1 != -1 && nNPs2 != -1)
		{
			CString sPipeDir = sLn.Mid(nNPs1 + 1, nNPs2 - nNPs1 - 1);

			CStringArray arXYZ;
			ExtractSubString(sPipeDir, _T(","), arXYZ);
			if (arXYZ.GetSize() == 3)
			{
				vtPip.set(_ttof(arXYZ[0]), _ttof(arXYZ[1]), _ttof(arXYZ[2]));
			}
		}

		CStringArray arTxts;
		ExtractSubString(sPIPECP, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		if (arTxts.GetSize() >= 17)
		{
			if (arTxts.GetSize() >= 20)
			{
				return PCP7(sLn);
			}

			double dt1 = _ttof(arTxts[16]);
			double dt2 = _ttof(arTxts.GetAt(9));
			if (dt1 < 1.e-3 || dt2 < 1.e-3)
			{
				return PCP5(sLn);
			}

			AcGePoint3d ptPos(_ttof(arTxts[0]), _ttof(arTxts[1]), _ttof(arTxts[2]));
			AcGeVector3d vtDir(_ttof(arTxts[3]), _ttof(arTxts[4]), _ttof(arTxts[5]));
			vtNUT = vtDir.crossProduct(vtPip);//XxY=Z
			vtNUT.normalize();//Z

			double dA = _ttof(arTxts[12]);
			double dt = _ttof(arTxts[15]);
			double dH = _ttof(arTxts[10]);
			double dd = _ttof(arTxts.GetAt(8));
			double dR = _ttof(arTxts.GetAt(7));
			double dw = _ttof(arTxts.GetAt(13));
			double db = _ttof(arTxts.GetAt(14));
			CString sMx = arTxts.GetAt(6);

			AcGePoint3d ptNut1, ptNut2,ptA1,ptA2,ptNs,ptNe, ptNut11, ptNut22;
			ptNut1 = ptPos;

			ptNut1 -= vtDir * 0.5 * dA;
			ptNut1 -= vtNUT * dt;

			NUT(ptNut1, sMx, -vtNUT, ptNut11, TRUE);

			ptNut2 = ptNut1 + vtDir * dA;
			NUT(ptNut2, sMx, -vtNUT, ptNut22, TRUE);

			double dLS = dR + dt2+ dt;//不可以用H,H为冗长
			ptA1 = ptNut1 + vtNUT * dLS;
			ptA2 = ptNut2 + vtNUT * dLS;

			//伸出
			ptNs = ptNut11 - vtNUT * 5.0;
			ptNe = ptNut22 - vtNUT * 5.0;

			AcDbLine ln(ptNs, ptA1);
			Ex(0.5 * dd, &ln);

			ln.setStartPoint(ptNe);
			ln.setEndPoint(ptA2);
			Ex(0.5 * dd, &ln);

			AcGePoint3d ptCen = ptA1 + vtDir * 0.5*dA;
			AcDbArc arc;
			arc.setCenter(ptCen);
			arc.setRadius(0.5*dA);
			arc.setStartAngle(0);
			arc.setEndAngle(PI);
			arc.setNormal(vtPip);

			Ex(0.5 * dd, &arc);

			AcDbArc arc1;
			arc1.setCenter(ptCen);
			arc1.setRadius(dR);
			arc1.setStartAngle(1.25*PI);
			arc1.setEndAngle(1.74*PI);
			arc1.setNormal(vtPip);

			AcDbArc arc2;
			arc2.setCenter(ptCen);
			arc2.setRadius(dR + dt2);
			arc2.setStartAngle(1.25 * PI);
			arc2.setEndAngle(1.74 * PI);
			arc2.setNormal(vtPip);

			AcGePoint3d pt1, pt2;
			arc1.getStartPoint(pt1);
			arc2.getStartPoint(pt2);
			AcDbLine ln1(pt1, pt2);

			arc1.getEndPoint(pt1);
			arc2.getEndPoint(pt2);
			AcDbLine ln2(pt1, pt2);

			AcDbVoidPtrArray arCrs;
			arCrs.append(&arc1);
			arCrs.append(&arc2);
			arCrs.append(&ln1);
			arCrs.append(&ln2);
			AcDbRegion* pRg = CreateRegFromCurves(arCrs);

			if (pRg != NULL)
			{
				Ex(pRg, ptCen, ptCen + dw * vtPip,FALSE);
				Ex(pRg, ptCen, ptCen - dw * vtPip,TRUE);
			}

			arCrs.removeAll();
			AcDbCircle cir1;
			cir1.setRadius(dR-dt1);
			cir1.setCenter(ptCen);
			cir1.setNormal(vtPip);
			arCrs.append(&cir1);
			AcDbRegion* pRg1 = CreateRegFromCurves(arCrs);

			AcDbCircle cir2;
			cir2.setRadius(dR);
			cir2.setCenter(ptCen);
			cir2.setNormal(vtPip);
			arCrs.removeAll();
			arCrs.append(&cir2);
			AcDbRegion *pRg2 = CreateRegFromCurves(arCrs);
			if (pRg2 != NULL)
			{
				pRg2->booleanOper(AcDb::kBoolSubtract, pRg1);
			}

			if (pRg2 != NULL)
			{
				Ex(pRg2, ptCen, ptCen + dw * vtPip, FALSE);
				Ex(pRg2, ptCen, ptCen - dw * vtPip, TRUE);
			}
		}
	}
	return TRUE;
}

BOOL AecDbPipeHanger::YL(CString& sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sYD = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arTxts;
		ExtractSubString(sYD, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		double dY = _ttof(arTxts.GetAt(6));
		if (dY == 0)//不建模Y
			return FALSE;

		AcGePoint3d ptF = AcGePoint3d(_ttof(arTxts.GetAt(0)),_ttof(arTxts.GetAt(1)),_ttof(arTxts.GetAt(2)));
		AcGeVector3d vt = AcGeVector3d(_ttof(arTxts.GetAt(3)), _ttof(arTxts.GetAt(4)), _ttof(arTxts.GetAt(5)));
		vt.normalize();

		double dL = _ttof(arTxts.GetAt(7));
		double dt = _ttof(arTxts.GetAt(8));
		double dYX = 10.0;
		double dLx = dY - dYX;

		AcGePoint3d ptT = ptF - AcGeVector3d::kZAxis * dL;
		AcGePoint3d pt = ptF;
		AcGePoint3dArray arPts;
		arPts.append(pt);

		pt.x -= dLx;
		arPts.append(pt);

		pt.y -= dt;
		arPts.append(pt);

		pt.x += dLx;
		arPts.append(pt);

		arPts.append(arPts.first());

		AcDbRegion *pRg = CreatePointsRegion(arPts);
		if (pRg != NULL)
		{
			Ex(pRg, ptF, ptT, TRUE);

			AcGeVector3d vtV1(-1, 1, 0);//XY面左上
			vtV1.normalize();

			AcGeVector3d vtV2(-1, -1, 0);//XY面左下
			vtV2.normalize();

			AcGeVector3d vt3(1, 1, 0);
			vt3.normalize();

			AcGeVector3d vt4(1, -1, 0);
			vt4.normalize();

			pt = arPts.at(1);

			AcGePoint3dArray arPts1;
			arPts1.append(arPts);
			arPts.removeAll();

			//0
			arPts.append(pt);

			//1
			pt += vtV1 * 14.14;
			arPts.append(pt);

			//2
			pt += vtV2 * dt;
			arPts.append(pt);

			//3
			arPts.append(pt);
			//4
			arPts.append(pt);
			//5
			arPts.append(pt);

			//6
			pt = arPts1.at(2);
			arPts.append(pt);

			//5
			pt += vtV2 * 14.14;
			arPts.setAt(5, pt);

			//4
			pt += vtV1 * dt;
			arPts.setAt(4, pt);

			AcDbXline xLn1;
			xLn1.setBasePoint(arPts.at(2));
			xLn1.setUnitDir(vtV1);

			AcDbXline xLn2;
			xLn2.setBasePoint(arPts.at(4));
			xLn2.setUnitDir(vtV2);

			arPts1.removeAll();
			xLn1.intersectWith(&xLn2, AcDb::kOnBothOperands, arPts1);

			if (!arPts1.isEmpty())
			{
				arPts.setAt(3,arPts1.first());
			}
			arPts.append(arPts.first());

			pRg = CreatePointsRegion(arPts);
			if (pRg != NULL)
			{
				ptF = arPts.first();
				ptT = ptF - AcGeVector3d::kZAxis * dL;
				
				Ex(pRg, ptF, ptT, TRUE);
			}
			return TRUE;
		}
	}
	return FALSE;
}

BOOL AecDbPipeHanger::CX(CString &sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sEXPL = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arTxts;
		ExtractSubString(sEXPL, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		if (arTxts.GetSize() >= 12)
		{
			double dr = _ttof(arTxts.GetAt(6));
			double dR = _ttof(arTxts.GetAt(10));
			double dL1 = _ttof(arTxts.GetAt(3));
			double dL0 = _ttof(arTxts.GetAt(11));
			double dL11 = dL1 - dR;// _ttof(arTxts.GetAt(11));

			AcGePoint3d pt0 = AcGePoint3d(_ttof(arTxts.GetAt(0)), _ttof(arTxts.GetAt(1)), _ttof(arTxts.GetAt(2)));
			AcGePoint3d pt1 = AcGePoint3d(_ttof(arTxts.GetAt(3)), _ttof(arTxts.GetAt(4)), _ttof(arTxts.GetAt(4)));
			AcGeVector3d vt = pt1 - pt0;
			vt.normalize();

			int nSePs = sLn.Find(_T(":"));
			if (nSePs != -1)
			{
				nPos1 = sLn.Find(_T('('), nSePs);
				if (nPos1 != -1)
				{
					CString sSe = sLn.Mid(nSePs + 1, nPos1 - nSePs - 1);
					if (sSe.CompareNoCase(_T("SE")) == 0)
					{
						nPos1 = sLn.Find(_T('('), nSePs);
						nPos2 = sLn.Find(_T(')'), nSePs);

						if (nPos1 != -1 && nPos2 != -1)
						{
							CString sSe = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

							CStringArray arSeTxts;
							ExtractSubString(sSe, _T(","), arSeTxts);

							for (int i = 0; i < arSeTxts.GetSize(); i++)
							{
								sTxt = arSeTxts.GetAt(i);
								CLC(sTxt);
								arSeTxts.SetAt(i, sTxt);
							}

							if (arSeTxts.GetSize() >= 4)
							{
								double dY = _ttof(arSeTxts[3]);
								double dL = _ttof(arSeTxts[0]);
								double dt3 = _ttof(arSeTxts[1]);
								double dd = _ttof(arSeTxts[2]);
								double dAng = atan(dL0 / (dR + dd));

								AcDbPolyline pl;
								double dr = 0;
								AcGePoint3d pt = pt0;
								if (dY < 1.e-3)//圆钩
								{
									AcDbLine ln;
									dr = dd;
									ln.setStartPoint(pt);

									pt.x += (dL11+dt3);
									ln.setEndPoint(pt);

									Ex(0.5*dd, &ln);

									AcDbArc cir;
									pt = pt0;
									pt.x += dL1;
									pt.y += 0.5*dd;
									cir.setCenter(pt);
									cir.setRadius(dR);
									cir.setStartAngle(PI);
									cir.setEndAngle(PI + 1.5*PI + dAng);
									cir.setNormal(AcGeVector3d::kZAxis);

									Ex(0.5*dd, &cir);
								}
								else//矩形钩
								{
									pt = pt0;

									AcGePoint3dArray arPts;
									pt.z += 0.5 * dL;
									arPts.append(pt);

									pt.y += dt3;
									arPts.append(pt);

									pt.z -= dL;
									arPts.append(pt);

									pt.y -= dt3;
									arPts.append(pt);

									arPts.append(arPts.first());

									AcDbRegion* pRg = CreateFromPoints(arPts);
									if (pRg != NULL)
									{
										AcDbLine ln;
										dr = dd;
										ln.setStartPoint(pt);

										pt.x += (dL11 + dt3);
										
										ln.setEndPoint(pt);

										Ex(pRg, &ln, 0.0, TRUE);

										AcDbArc cir;
										pt = pt0;
										pt.x += dL1;
										pt.y += dt3;

										cir.setCenter(pt);
										cir.setRadius(dR);
										cir.setStartAngle(PI);
										cir.setEndAngle(PI + 1.5*PI + dAng);
										cir.setNormal(AcGeVector3d::kZAxis);

										pt = pt0;
										pt.x += dL11;

										arPts.removeAll();
										pt.z += 0.5 * dL;
										arPts.append(pt);

										pt.x += dt3;
										arPts.append(pt);

										pt.z -= dL;
										arPts.append(pt);

										pt.x -= dt3;
										arPts.append(pt);

										arPts.append(arPts.first());

										pRg = CreateFromPoints(arPts);
										if (pRg != NULL)
										{
											Ex(pRg, &cir, 0.0, TRUE);
										}
									}
								}
								return TRUE;
							}
						}
					}
				}
			}
		}
	}
	return FALSE;
}

AcDbRegion* AecDbPipeHanger::PL(CString& sPl, AcGeVector3d& vtNm)
{
	CStringArray arTxts;
	ExtractSubString(sPl, _T(","), arTxts);

	CString sTxt;
	for (int i = 0; i < arTxts.GetSize(); i++)
	{
		sTxt = arTxts.GetAt(i);
		CLC(sTxt);
		arTxts.SetAt(i, sTxt);
	}

	int nMod = arTxts.GetSize() % 3;
	if (nMod != 0)
	{
		return NULL;
	}

	int nPts = arTxts.GetSize() / 3;

	AcGePoint3d pt;
	AcGePoint3dArray arPts;

	for (int i = 0;i < nPts;i++)
	{
		pt.set(_ttof(arTxts[i*3]), _ttof(arTxts[i*3 + 1]), _ttof(arTxts[i*3 + 2]));
		arPts.append(pt);
	}

	if (!arPts.isEmpty())
	{
		vtNm = arPts.last().asVector();
		arPts.removeLast();

		return CreatePointsRegion(arPts);
	}
	return NULL;
}

AcDbRegion* AecDbPipeHanger::POR(CString& sPl, AcGeVector3d& vtNm)
{
	CStringArray arTxts;
	ExtractSubString(sPl, _T(","), arTxts);

	CString sTxt;
	for (int i = 0; i < arTxts.GetSize(); i++)
	{
		sTxt = arTxts.GetAt(i);
		CLC(sTxt);
		arTxts.SetAt(i, sTxt);
	}

	ads_point pt0, pt1;
	if (arTxts.GetSize() >= 3)
	{
		pt0[X] = _ttof(arTxts[0]);
		pt0[Y] = _ttof(arTxts[1]);
		pt0[Z] = _ttof(arTxts[2]);

		if (arTxts.GetSize() >= 6)
		{
			int nLast = arTxts.GetSize() - 1 - 1 - 1;
			vtNm.set(_ttof(arTxts[nLast]), _ttof(arTxts[nLast + 1]), _ttof(arTxts[nLast + 2]));

			arTxts.RemoveAt(arTxts.GetSize() - 1);
			arTxts.RemoveAt(arTxts.GetSize() - 1);
			arTxts.RemoveAt(arTxts.GetSize() - 1);

			arTxts.RemoveAt(0);
			arTxts.RemoveAt(0);
			arTxts.RemoveAt(0);

			int nPors = arTxts.GetSize() / 2;
			int nPorsM = arTxts.GetSize() % 2;
			if (nPorsM == 0)
			{
				AcGePoint3dArray arPts;
				arPts.append(asPnt3d(pt0));

				double dAng = 0;
				double dLen = 0;
				for (int i = 0;i < nPors;i++)
				{
					dAng = _ttof(arTxts.GetAt(2*i));
					dAng *= PI / 180.0;
					dLen = _ttof(arTxts.GetAt(2 * i+1));
					
					ads_polar(asDblArray(arPts.last()), dAng, dLen, pt1);
					arPts.append(asPnt3d(pt1));
				}
				arPts.append(arPts.first());
				AcDbRegion* pRg = CreatePointsRegion(arPts);
				if (pRg != NULL)
				{					
					AcGeMatrix3d xm;
					xm.setToPlaneToWorld(vtNm);
					pRg->transformBy(xm);

					return pRg;
				}
			}
		}
	}
	return NULL;
}

BOOL AecDbPipeHanger::PLR(CString& sLn)
{
	int nPos1 = sLn.Find(_T('('));
	int nPos2 = sLn.Find(_T(')'));
	if (nPos1 != -1 && nPos2 != -1)
	{
		CString sPlr = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

		CStringArray arTxts;
		ExtractSubString(sPlr, _T(","), arTxts);

		CString sTxt;
		for (int i = 0; i < arTxts.GetSize(); i++)
		{
			sTxt = arTxts.GetAt(i);
			CLC(sTxt);
			arTxts.SetAt(i, sTxt);
		}

		if (arTxts.GetSize() >= 4)
		{
			AcGePoint3d pt(0, 0, 0);
			double dR = _ttof(arTxts.GetAt(0));
			double dAng = _ttof(arTxts.GetAt(1));
			double dZ = _ttof(arTxts.GetAt(2));
			double dt = _ttof(arTxts.GetAt(3));

			dAng *= PI / 180.0;

			//水平移动
			AcGeVector3d vtM(dR, 0, 0);
			
			int nPlPos = sLn.Find(_T(":"));
			if (nPlPos != -1)
			{
				nPos1 = sLn.Find(_T('('), nPlPos);
				nPos2 = sLn.ReverseFind(_T(')'));

				if (nPos1 != -1 && nPos2 != -1)
				{
					CString sPl = sLn.Mid(nPos1 + 1, nPos2 - nPos1 - 1);

					//0123:POR(--- 4 -- 8-4-1
					CString sPLType = sLn.Mid(nPlPos + 1, nPos1 - nPlPos - 1);
					if (sPLType.CompareNoCase(_T("PL")) == 0)
					{
						AcGeVector3d vtNm;
						AcDbRegion* pRg = PL(sPl, vtNm);
						if (pRg != NULL)
						{
							AcDbLine ln;
							ln.setStartPoint(AcGePoint3d(0, 0, 0));
							ln.setEndPoint(AcGePoint3d(0, 0, 0) + vtNm * dt);

							AcGeMatrix3d xM;
							xM.setToTranslation(vtM);

							AcGeVector3d vZ(0, 0, 1);
							vZ *= dZ;
							AcGeMatrix3d xZ;
							xZ.setTranslation(vZ);

							AcGeMatrix3d xR;
							xR.setToRotation(dAng, AcGeVector3d::kZAxis);

							//off
							pRg->transformBy(xM);
							//rot
							pRg->transformBy(xR);
							//z--
							pRg->transformBy(xZ);

							//off
							ln.transformBy(xM);
							//rot
							ln.transformBy(xR);
							//z
							ln.transformBy(xZ);

							if (pRg != NULL)
							{
								return Ex(pRg, &ln, 0.0, TRUE);
							}
						}
					}
					else if (sPLType.CompareNoCase(_T("POR")) == 0)
					{
						AcGeVector3d vtNm;
						AcDbRegion* pRg = POR(sPl, vtNm);
						if (pRg != NULL)
						{
							AcDbLine ln;
							ln.setStartPoint(AcGePoint3d(0, 0, 0));
							ln.setEndPoint(AcGePoint3d(0, 0, 0) + vtNm * dt);

							AcGeMatrix3d xM;
							xM.setToTranslation(vtM);

							AcGeVector3d vZ(0, 0, 1);
							vZ *= dZ;
							AcGeMatrix3d xZ;
							xZ.setTranslation(vZ);

							AcGeMatrix3d xR;
							xR.setToRotation(dAng, AcGeVector3d::kZAxis);

							//off
							pRg->transformBy(xM);
							//rot
							pRg->transformBy(xR);
							//z--
							pRg->transformBy(xZ);

							//off
							ln.transformBy(xM);
							//rot
							ln.transformBy(xR);
							//z
							ln.transformBy(xZ);

							if (pRg != NULL)
							{
								return Ex(pRg, &ln, 0.0, TRUE);
							}
						}
					}
				}
			}
		}
	}
	return FALSE;
}

void AecDbPipeHanger::SwitchVar()
{
	int nVt = 0;
	CString sKey,sKey2;
	AecXData xdata1,xdata2;
	CStringArray arKeys;
	for (AecDbObjXDataMap::It it = m_mapSpecXData.Begin(); it != m_mapSpecXData.End(); )
	{
		if (!m_mapSpecXData.GetNext(it, sKey, xdata1))
		{
			break;
		}
		if (sKey.Find(_T("#")) != -1)
		{
			arKeys.Add(sKey);
		}
	}

	//切换
	for (int i = 0;i < arKeys.GetSize();i++)
	{
		//A#
		sKey = arKeys.GetAt(i);

		//A
		sKey2 = sKey;
		sKey2.TrimRight(_T('#'));

		//A#
		memset(&xdata1, 0, sizeof(AecXData));
		m_mapSpecXData.GetAt(sKey, xdata1);

		//A
		memset(&xdata2, 0, sizeof(AecXData));
		m_mapSpecXData.GetAt(sKey2, xdata2);

		//A#
		m_mapSpecXData.SetAt(sKey, xdata2);

		//A
		m_mapSpecXData.SetAt(sKey2, xdata1);
	}
}

BOOL AecDbPipeHanger::Insert(const AcGePoint3d &pt, double dRot,BOOL bAddDraw)
{
	FreeBuffer(m_ar3DSlds);

	CString sLn;
	int nPCP = 0;
	int nPCPMinIndex = -1;
	m_mapSpecXData.GetAt(_T("PCP#"), nPCPMinIndex);

	for (int i = 0; i < m_arLines.GetSize(); i++)
	{
		sLn = m_arLines.GetAt(i);
		if (sLn.Find(_T("EX")) != -1)
		{
			EX(sLn);
		}
		else if (sLn.Find(_T("SLC")) != -1)
		{
			SLC(sLn);
		}
		else if (sLn.Find(_T("BLT")) != -1)
		{
			BLT(sLn);
		}
		else if (sLn.Find(_T("PCP")) != -1)
		{
			if (nPCPMinIndex == nPCP)
			{
				//使用变量切换#
				SwitchVar();
			}

			PCP(sLn);

			if (nPCPMinIndex == nPCP)
			{
				//切换回变量切换
				SwitchVar();
			}

			nPCP += 1;
		}
		else if (sLn.Find(_T("YL")) != -1)
		{
			YL(sLn);
		}
		else if (sLn.Find(_T("CX")) != -1)
		{
			CX(sLn);
		}
		else if (sLn.Find(_T("PLR")) != -1)
		{
			PLR(sLn);
		}
		else
		{
			//...
		}
	}

	AcDb3dSolid* pElbowSolid = NULL;
	if (m_pElbowArc != NULL && m_dElbowOD > 1.e-3)
	{
		AcGePoint3d ptS;
		AcGeVector3d vtN;
		m_pElbowArc->getStartPoint(ptS);
		m_pElbowArc->getFirstDeriv(ptS, vtN);

		AcDbRegion* pRg = CreateCirRegion(ptS, 0.5*m_dElbowOD, vtN);
		if (pRg != NULL)
		{
			Acad::ErrorStatus es;
			AcDb3dSolid* pSolid = new AcDb3dSolid;
			if (Acad::eOk == (es = pSolid->extrudeAlongPath(pRg, m_pElbowArc)))
			{
				pElbowSolid = pSolid;
				delete pRg;
			}
			else
			{
				delete pRg;
				delete pSolid;
			}
		}
	}

	//2D

	m_ptIns = pt;
	m_dRot = dRot;

	AcGeMatrix3d xr;
	xr.setToRotation(m_dRot, AcGeVector3d::kZAxis);

	AcGeVector3d vt = m_ptIns.asVector();
	AcGeMatrix3d xm;
	xm.setToTranslation(vt);

	AcDbExtents ext, ext1;
	AcDbEntity* pEnt3d = NULL;
	for (int i = 0; i < m_ar3DSlds.length(); i++)
	{
		pEnt3d = (AcDbEntity*)m_ar3DSlds.at(i);

		pEnt3d->getGeomExtents(ext1);
		ext.addExt(ext1);

		pEnt3d->transformBy(xr);
		pEnt3d->transformBy(xm);

		if (pElbowSolid != NULL)
		{
			AcDb3dSolid* pSolid = AcDb3dSolid::cast(pEnt3d);
			if (pSolid != NULL)
			{
				AcDb3dSolid* pElbow3d = (AcDb3dSolid*)pElbowSolid->clone();
				if (pElbow3d != NULL)
				{
					pSolid->booleanOper(AcDb::kBoolSubtract, pElbow3d);
				}
			}
		}
	}

	//TEST
	if (bAddDraw)
	{
		AcDbObjectId id;
		for (int i = 0; i < m_ar3DSlds.length(); i++)
		{
			AcDbEntity *pEnt = (AcDbEntity *)m_ar3DSlds.at(i);
			if (pEnt != NULL)
			{
				id = AddToModelSpace(pEnt);
			}
		}
	}

	m_arRecPts.removeAll();

	AcGePoint3d ptMin = ext.minPoint();
	AcGePoint3d ptMax = ext.maxPoint();
	//ptMin.z = 0; ptMax.z = 0;
	ptMin.z = ptMax.z;

	AcGePoint3d ptT;
	ptT = ptMin;

	//0
	ptT.transformBy(xr);
	ptT.transformBy(xm);
	m_arRecPts.append(ptT);

	//1
	ptT = ptMax;
	ptT.y = ptMin.y;
	ptT.transformBy(xr);
	ptT.transformBy(xm);
	m_arRecPts.append(ptT);

	//2
	ptT = ptMax;
	ptT.transformBy(xr);
	ptT.transformBy(xm);
	m_arRecPts.append(ptT);

	//3
	ptT = ptMin;
	ptT.y = ptMax.y;
	ptT.transformBy(xr);
	ptT.transformBy(xm);
	m_arRecPts.append(ptT);

	//4
	m_arRecPts.append(m_arRecPts.first());//closed

	return TRUE;
}

BOOL AecDbPipeHanger::GetDirLine(AcDbLine& lnDir) const
{
	assertReadEnabled();
	if (m_arRecPts.length() >= 4)
	{
		AcGePoint3d pt0, pt1;
		Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
		Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
		lnDir.setStartPoint(pt0);
		lnDir.setEndPoint(pt1);
	}
	return FALSE;
}

AcGePoint3d AecDbPipeHanger::position() const
{
	assertReadEnabled();
	return m_ptIns;
}

double AecDbPipeHanger::rotation() const
{
	assertReadEnabled();
	return m_dRot;
}

#include "HlrCutOption.h"
void AecDbPipeHanger::ProcessHlrResult(const AcArray<AcDbEntity *> &ar
	, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr
	, AcArray<AcDbEntity *> &output) const
{
	const AecDbObjXDataMap *pMap(&m_mapSpecXData);
	const_cast<AecDbObjXDataMap *>(pMap)->SetAt(HLR_CALC, FALSE);
	if (ar.isEmpty() && preAr.empty()) return;
	HlrCutOption::ProcessHlrResult(this
		, false
		, .0
		, HlrCutOption::getHlrBLK_EQU()
		, ar
		, preAr
		, output);
}

void AecDbPipeHanger::PreprocessForHlr(const AcGePoint3d &ptPlnO, const AcGeVector3d &vtPlnN, AcArray<AcDbEntity *> &ar) const
{
	const AecDbObjXDataMap *pMap(&m_mapSpecXData);

	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(m_dRot,AcGeVector3d::kZAxis);

	AcGePoint3d pt0, pt1,ptMid;
	if (m_arRecPts.length() >= 4)
	{
		Midpoint(m_arRecPts.at(0), m_arRecPts.at(3), pt0);
		Midpoint(m_arRecPts.at(1), m_arRecPts.at(2), pt1);
	}
	double dLx = pt1.distanceTo(pt0);
	Midpoint(pt0, pt1, ptMid);

	// 原2d绘制平面
	AcGePlane _pln(m_ptIns, vtPlnN);
	AcGeMatrix3d mat(AcGeMatrix3d::kIdentity)
		, mat2(AcGeMatrix3d::kIdentity)
		, mat3(AcGeMatrix3d::kIdentity);

	mat3.setToTranslation(AcGeVector3d(-vtPlnN).normalize() * dLx);

	if (vtPlnN.isParallelTo(AcGeVector3d::kZAxis))		// 俯视图
	{
		AcDbEntity *pEnt = NULL;
		AcDbVoidPtrArray ar2d;
		GetDraw2dables(0, ar2d);
		for (int n = 0;n < ar2d.length();n++)
		{
			ar.append((AcDbEntity*)ar2d.at(n));
		}

		ar2d.removeAll();
		GetDraw2dables(0, ar2d);
		for (int n = 0; n < ar2d.length(); n++)
		{
			pEnt = (AcDbEntity *)ar2d.at(n);
			pEnt->transformBy(mat3);
			ar.append(pEnt);
		}
	}
	else
	{
		//投影
		return;
	}
	const_cast<AecDbObjXDataMap *>(pMap)->SetAt(HLR_CALC, TRUE);
}