#include "stdafx.h"
#include "AecDbHanger.h"
#include "MFCDbDwgFiler.h"
#include "AecDbEwPipe.h"
#include "dbgrip.h"
#include "AecGripCback.h"
#include "AcGiViewDraw.h"
#include "ImpMD5.h"

extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
extern BOOL DLLIMPEXP GetDimGripOff();
extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);

Adesk::UInt32 AecDbHanger::kCurrentVersionNumber = 1;
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;

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


AecDbHanger::AecDbHanger(void)
{
	m_pGripAppData = new AecGripData[GRIP_MAXNUM];
	m_mapSpecXData.SetAt(KEY_NAME,_T("吊架"));
}

AecDbHanger::~AecDbHanger(void)
{
	delete [] m_pGripAppData;
	deleteContainerOfStd(m_solids);
	deleteContainerOfStd(m_pipes);
}

Acad::ErrorStatus AecDbHanger::SetPosition(const AcGePoint3d& ptPos,const AcGeVector3d& vtL)
{
	AssertWriteEnabled();
	m_mapSpecXData.SetAt(KEY_POS,ptPos);
	m_mapSpecXData.SetAt(PIPE_DIR,vtL);
	return Acad::eOk;
}

AcGePoint3d AecDbHanger::GetPosition(AcGeVector3d& vtL) const
{
	assertReadEnabled();

	AcGePoint3d pt;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);
	return pt;
}

void AecDbHanger::SetHanger(const XHanger& data)
{
	AssertWriteEnabled();

	/*
	// 吊杆数 1,2,3...
	int nHs;

	// 行数 
	int N;

	// 吊杆直径
	double dD;

	// 是否角钢吊杆
	bool bdDAsW;

	// 行间距(m)
	double V;

	// 支架臂长度(mm)
	double L;

	// 角钢宽度(mm)
	double W;

	// 角钢厚度(mm)
	double t;

	// 材质
	TCHAR szMat[33];

	// 用途
	TCHAR szUsage[33];
	*/
	m_mapSpecXData.SetAt(KEY_NHS,data.nHs);
	m_mapSpecXData.SetAt(KEY_N,data.N);
	m_mapSpecXData.SetAt(KEY_DD,data.dD);
	m_mapSpecXData.SetAt(KEY_DASW,data.bdDAsW);
	m_mapSpecXData.SetAt(KEY_V,data.V);
	m_mapSpecXData.SetAt(KEY_L,data.L);
	m_mapSpecXData.SetAt(KEY_W,data.W);
	m_mapSpecXData.SetAt(KEY_T,data.t);
	m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
	m_mapSpecXData.SetAt(KEY_PURPOSE,data.szUsage);
}

bool AecDbHanger::GetASteelLength(ASteel& aSteel) const
{
	assertReadEnabled();

	XHanger hanger;
	GetHanger(hanger);

	memset(&aSteel, 0,sizeof(ASteel));
	if (hanger.bdDAsW)
	{
		aSteel.W = hanger.W;
		aSteel.t = hanger.t;
		aSteel.L = hanger.L * hanger.N;
		aSteel.L += hanger.N * hanger.V * 2;
		_tcscpy(aSteel.szMat, hanger.szMat);
	}
	else
	{
		aSteel.W = hanger.W;
		aSteel.t = hanger.t;
		aSteel.L = hanger.L * hanger.N;
		_tcscpy(aSteel.szMat, hanger.szMat);

		aSteel.L2 = hanger.N * hanger.V * 2;
		aSteel.D = hanger.dD;
	}

	return true;
}

bool AecDbHanger::GetHanger(XHanger& data) const
{
	assertReadEnabled();

	BOOL bHasData = m_mapSpecXData.GetAt(KEY_NHS,data.nHs);
	m_mapSpecXData.GetAt(KEY_N,data.N);
	m_mapSpecXData.GetAt(KEY_DD,data.dD);
	m_mapSpecXData.GetAt(KEY_DASW,data.bdDAsW);
	m_mapSpecXData.GetAt(KEY_V,data.V);
	m_mapSpecXData.GetAt(KEY_L,data.L);
	m_mapSpecXData.GetAt(KEY_W,data.W);
	m_mapSpecXData.GetAt(KEY_T,data.t);

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(data.szMat,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_PURPOSE,sTemp);
	_tcscpy(data.szUsage,(LPCTSTR)sTemp);

	return bHasData ? true : false;
}

Acad::ErrorStatus AecDbHanger::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		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 > AecDbHanger::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	m_mapSpecXData.dwgInFields(pFiler);

	return Acad::eOk;
}	

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

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgOutFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

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

	m_mapSpecXData.dwgOutFields(pFiler);

	return Acad::eOk;
}

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

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

Acad::ErrorStatus AecDbHanger::subExplode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

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

	acutPrintf(_T("\n属性数据:"));
	m_mapSpecXData.List();
	acutPrintf(_T("\n"));
}

bool AecDbHanger::GetBimInfoTip(CString& sInfoTip) const
{
	assertReadEnabled();

	XHanger data;
	memset(&data,0,sizeof(XHanger));
	GetHanger(data);

	CString sField,sFmt;
	sField = _T("吊架:\n");
	sInfoTip += sField;

	MAKEFIELD(_T("支架臂长度"),_T("%d"),(int)(data.L+0.5),sInfoTip);

	MAKEFIELD(_T("行数"),_T("%d"),data.N,sInfoTip);
	MAKEFIELD(_T("行间距"),_T("%.1f"),data.V,sInfoTip);

	AcGePoint3d pt;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	MAKEFIELD(_T("顶部标高"),_T("%.1f"),pt.z,sInfoTip);

	MAKEFIELD(_T("角钢宽度"),_T("%.1f"),data.W,sInfoTip);
	MAKEFIELD(_T("角钢厚度"),_T("%.1f"),data.t,sInfoTip);

	MAKEFIELD(_T("材质"),_T("%s"),data.szMat,sInfoTip);
	MAKEFIELD(_T("用途"),_T("%s"),data.szUsage,sInfoTip);

	return true;
}

Acad::ErrorStatus AecDbHanger::copyFrom(const AcRxObject* pSrc)
{
	AssertWriteEnabled();

	AecDbHanger* pFit = AecDbHanger::cast(pSrc);
	if (pFit != NULL)
	{
		m_mapSpecXData.Empty();
		m_mapSpecXData.CopyFrom(&pFit->m_mapSpecXData);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	AcGePoint3d pt;
	AcGeVector3d vtL;

	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	pt.transformBy(xform);
	vtL.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_POS,pt);
	m_mapSpecXData.SetAt(PIPE_DIR,vtL);

	return Acad::eOk;
}

#if ARX>16	
Acad::ErrorStatus AecDbHanger::subGetGripPoints(AcDbGripDataPtrArray& grips,
												const double curViewUnitSize,
												const int gripSize,
												const AcGeVector3d& curViewDir,
												const int bitflags) const
{

	assertReadEnabled();

	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	XHanger holder;
	GetHanger(holder);

	vtL.normalize();
	vtL *= holder.L;

	pt += 0.5 * vtL;
	AcGePoint3d pt2 = pt - vtL;

	AcDbGripData* pGripData = NULL;

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

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

	if (!vtL.isZeroLength())
	{
		i = 1;
		pGripData = new AcDbGripData;
		memset(&m_pGripAppData[i],0,sizeof(AecGripData));
		m_pGripAppData[i].nIndex = i;
		m_pGripAppData[i].nColor = kBlue;
		m_pGripAppData[i].ePos = eEnd;
		m_pGripAppData[i].ptGrip = pt2;
		_tcscpy(m_pGripAppData[i].szTip,_T("方位夹点"));
		m_pGripAppData[i].pOwner = (AcDbEntity*)this;
		m_pGripAppData[i].idHost = objectId();

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

	//动态标注
	//直线,半径 标注风格
	if (!grips.isEmpty())
	{
		SubAddDimPoints(grips,curViewDir);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();

	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	XHanger holder;
	GetHanger(holder);

	vtL.normalize();
	if(!vtL.isZeroLength())
	{
		vtL *= holder.L;
		AcGePoint3d pt2 = pt + vtL;
		stretchPoints.append(pt);
		stretchPoints.append(pt2);
	}
	else
	{
		stretchPoints.append(pt);
	}
	return Acad::eOk;
}

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

	AecGripData* pAppData = NULL;
	AcDbIntArray arIndex;

	if ( !appData.isEmpty() )
	{
		pAppData = (AecGripData*)appData.first();
		arIndex.append(pAppData->nIndex);
	}
	else
	{
		return Acad::eOk;
	}

	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	int nGripIndex = arIndex.first();
	if (nGripIndex == 0)
	{
		pt += offset;
		m_mapSpecXData.SetAt(KEY_POS,pt);
		return Acad::eOk;
	}

	if (nGripIndex == 1)
	{
		XHanger holder;
		GetHanger(holder);

		vtL.normalize();
		vtL *= holder.L;

		AcGePoint3d pt2 = pt + vtL;

		pt2 -= offset;//反向

		double dL = pt2.distanceTo(pt);
		if (dL > 10.0)
		{
			vtL = pt2 - pt;
			vtL.normalize();
			m_mapSpecXData.SetAt(KEY_L,dL);
			m_mapSpecXData.SetAt(PIPE_DIR,vtL);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::SubAddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir) const
{
	if (GetDimGripOff())
		return Acad::eOk;

	AcGePoint3d pt,pt2;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	XHanger holder;
	GetHanger(holder);

	vtL.normalize();
	pt += 0.5 * vtL * holder.L;
	pt2 = pt - vtL * holder.L;

	AcGeVector3d vtDirX;
	AcGePoint3d ptGe[3],ptMid;
	ptGe[0] = pt;ptGe[0].z += 100.0;
	ptGe[1] = pt2;ptGe[1].z += 100.0;

	vtDirX = vtL;
	vtDirX.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtDirX.normalize();
	ptMid = MidPoint(ptGe[0],ptGe[1]);
	vtDirX.normalize();
	ptMid += vtDirX * 10.0 * 100.0;//标注文字位置
	AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);

	ptGe[0] = pt;
	ptGe[1] = pt;
	ptGe[1].z -= holder.N * holder.V;
	ptGe[0] -= vtL * 10.0;
	ptGe[1] -= vtL * 10.0;

	ptMid = MidPoint(ptGe[0],ptGe[1]);
	vtDirX.normalize();
	ptMid -= vtL * 10.0 * 100.0;//标注文字位置
	AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::AddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir,
											const AcGePoint3d& ptSta,const AcGePoint3d& ptEnd,
											const AcGePoint3d& ptMid,int nDimType,double dVal/* = -1.0*/,double dt) const
{
	int i = grips.length();
	EPosition ePos = eDim0;
	memset(&m_pGripAppData[i],0,sizeof(AecGripData));
	m_pGripAppData[i].nIndex = i;
	m_pGripAppData[i].ePos = ePos;
	m_pGripAppData[i].nColor = kGreen;
	m_pGripAppData[i].ptGrip = ptMid;
	m_pGripAppData[i].ptDim[0] = ptSta;
	m_pGripAppData[i].ptDim[1] = ptEnd;
	m_pGripAppData[i].nDimType = nDimType;

	if (dVal > 1.e-3)
	{
		if (nDimType == 1)
		{
			_stprintf(m_pGripAppData[i].szTip,_T("R%.1f"),dVal);
		}
		else if (nDimType == 2)//@100 标注
		{
			_stprintf(m_pGripAppData[i].szTip,_T("Ø%.1f"),dVal);
		}
		else if (nDimType == 3)//角度标注
		{
			_stprintf(m_pGripAppData[i].szTip,_T("%.1f°"),dVal);
		}
		else if (nDimType == 4)//@107x3.5
		{
			_stprintf(m_pGripAppData[i].szTip,_T("Ø%.1fx%.1f"),dVal,dt);
		} 
	}
	else
	{
		_tcscpy(m_pGripAppData[i].szTip,_T(" "));
	}
	_tcscpy(m_pGripAppData[i].szID,_T(" "));
	m_pGripAppData[i].pOwner = (AcDbEntity*)this;

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	if (indices.isEmpty())
		return Acad::eOk;

	AssertWriteEnabled();

	AcGeMatrix3d xformM;
	xformM.setToTranslation(offset);

	if (indices.length() == 1)
	{
		AcGePoint3d pt;
		AcGeVector3d vtL;
		m_mapSpecXData.GetAt(KEY_POS,pt);
		m_mapSpecXData.GetAt(PIPE_DIR,vtL);

		int nGripIndex = indices.first();
		if (nGripIndex == 0)
		{
			pt += offset;
			m_mapSpecXData.SetAt(KEY_POS,pt);
			return Acad::eOk;
		}

		if (nGripIndex == 1)
		{
			XHanger holder;
			GetHanger(holder);

			vtL.normalize();
			vtL *= holder.L;
			AcGePoint3d pt2 = pt + vtL;

			pt2 += offset;

			double dL = pt2.distanceTo(pt);
			if (dL > 10.0)
			{
				vtL = pt2 - pt;
				vtL.normalize();

				m_mapSpecXData.SetAt(PIPE_DIR,vtL);
			}
		}
	}
	else if (indices.length() == 2)
	{
		AcGePoint3d pt;
		m_mapSpecXData.GetAt(KEY_POS,pt);

		pt += offset;
		m_mapSpecXData.SetAt(KEY_POS,pt);
	}
	return Acad::eOk;
}

void AecDbHanger::GetGripText(int nPos, CString& sText)
{

}

#endif

//AEC 派生
Acad::ErrorStatus AecDbHanger::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

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

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

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

	if (Has2DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);
			//pEnt->setColorIndex(nColor);
			dc.DrawEntity(*pEnt);
		}

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

	XHanger holder;
	GetHanger(holder);

	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	pt.z = 0.0;//2D
	vtL.z = 0.0;//2D
	vtL.normalize();

	if (vtL.isZeroLength())//单杆
	{
		AcDbLine* pLn = NULL;
		vtL = AcGeVector3d::kXAxis;
		AcGeVector3d vtV = AcGeVector3d::kYAxis;

		AcGePoint3d ptGe[5];
		ptGe[1] = pt;
		ptGe[1] -= 0.5 * vtL * holder.W;
		ptGe[2] = ptGe[1] + vtL * holder.W;

		pLn = new AcDbLine(ptGe[1],ptGe[2]);
		pLn->setLayer(idLay);
		dc.DrawEntity(pLn);
		Add2DBuffer(pLn);

		ptGe[0] = ptGe[1];
		ptGe[0] += vtL * 0.5 * holder.W;
		ptGe[0] += vtV * 0.5 * holder.W;
		ptGe[3] -= vtV * holder.W;

		pLn = new AcDbLine(ptGe[1],ptGe[2]);
		pLn->setLayer(idLay);
		dc.DrawEntity(pLn);
		Add2DBuffer(pLn);

		AcDbCircle* pCir = new AcDbCircle;
		pCir->setCenter(pt);
		pCir->setRadius(0.25 * holder.W);
		pCir->setNormal(AcGeVector3d::kZAxis);
		dc.DrawEntity(pCir);
		Add2DBuffer(pCir);
	}
	else
	{
		AcGeVector3d vtV = vtL;
		vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

		//居中
		pt -= 0.5 * holder.L * vtL;

		//
		AcGePoint3d ptGe[5];
		ptGe[0] = pt;
		ptGe[0] += vtV * 0.5 * holder.W;

		ptGe[1] = ptGe[0] + vtL * holder.L;
		ptGe[2] = ptGe[1] - vtV * holder.W;

		ptGe[3] = ptGe[0] - vtV * holder.W;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl = FormatPolyline(ptGe,5);
		if (pPl != NULL)
		{
			pPl->setLayer(idLay);
			dc.DrawEntity(pPl);
			Add2DBuffer(pPl);
		}

		//+ 字
		if (holder.nHs > 1)
		{
			ptGe[1] = MidPoint(ptGe[0],ptGe[3]);
			AcDbLine* pLn = NULL;
			AcDbCircle* pCir = NULL;

			double dLx = holder.L / (holder.nHs - 1);
			for (int i = 0;i < holder.nHs;i++)
			{
				ptGe[1] -= 0.5 * vtL * holder.W;
				ptGe[2] = ptGe[1] + vtL * holder.W;

				pLn = new AcDbLine(ptGe[1],ptGe[2]);
				pLn->setLayer(idLay);
				dc.DrawEntity(pLn);
				Add2DBuffer(pLn);

				ptGe[0] = ptGe[1];
				ptGe[0] += vtL * 0.5 * holder.W;
				ptGe[0] += vtV * 0.5 * holder.W;
				ptGe[2] = ptGe[0];
				ptGe[2] -= vtV * holder.W;

				pLn = new AcDbLine(ptGe[0],ptGe[2]);
				pLn->setLayer(idLay);
				dc.DrawEntity(pLn);
				Add2DBuffer(pLn);

				pCir = new AcDbCircle;
				pCir->setCenter(MidPoint(ptGe[1],ptGe[2]));
				pCir->setRadius(0.25 * holder.W);
				pCir->setNormal(AcGeVector3d::kZAxis);
				dc.DrawEntity(pCir);
				Add2DBuffer(pCir);

				ptGe[1] += vtL * 0.5 * holder.W;
				ptGe[1] += vtL * dLx;
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbHanger::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	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 (Has3DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			pEnt->setTransparency(tr);
			dc.DrawEntity(*pEnt);
		}
		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	deleteContainerOfStd(m_solids);
	deleteContainerOfStd(m_pipes);

	XHanger holder;
	GetHanger(holder);

	//pt 中含有顶标高
	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);
	vtL.normalize();

	AcGePoint3d ptTo;
	if (vtL.isZeroLength())//单杆
	{
		ptTo = pt;
		ptTo.z -= holder.L;

		AcDb3dSolid* pSolid = Create3dRod(pt,ptTo,holder.dD,0.0,holder.bdDAsW);
		if (pSolid != NULL)
		{
			pSolid->setTransparency(tr);
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}

		//强固
		AcGePoint3d ptGe[2];
		if (holder.bdDAsW)
		{
			ptGe[0] = pt;
			ptGe[0].x -= 2.0 * holder.W;
			ptGe[1] = pt;
			ptGe[1].x += 2.0 * holder.W;

			pSolid = Create3dRod(ptGe[0],ptGe[1],holder.W,holder.t,holder.bdDAsW);
			if (pSolid != NULL)
			{
				pSolid->setTransparency(tr);
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
		}
		else
		{
			//绘制固定螺丝示意
			ptGe[0] = pt;
			ptGe[0].z += 8.0;//8mm
			ptGe[1] = pt;

			pSolid = Create3dRod(ptGe[0],ptGe[1],1.3 * holder.dD,0.0,holder.bdDAsW);
			if (pSolid != NULL)
			{
				pSolid->setTransparency(tr);
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
		}
	}
	else //多行
	{
		AcGeVector3d vtV = vtL;
		vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

		AcGePoint3d ptTo,ptL[2];
		AcGePoint3d ptFr = pt;
		ptL[0] = pt - vtL * 0.5 * holder.L;
		ptL[1] = pt + vtL * 0.5 * holder.L;

		ptL[0].z -= holder.N * holder.V;
		ptL[1].z -= holder.N * holder.V;

		AcDb3dSolid* pSolid = NULL;
		for (int i = 0;i < holder.N;i++)
		{
			pSolid = Create3dRod(ptL[0],ptL[1],holder.W,holder.t,1);
			if (pSolid != NULL)
			{
				pSolid->setTransparency(tr);
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
			ptL[0].z += holder.V;
			ptL[1].z += holder.V;
		}

		AcGePoint3d ptGe[2];
		//吊杆
		if (holder.nHs > 1)
		{
			pt -= vtL * 0.5 * holder.L;

			double dLx = holder.L / (holder.nHs - 1);
			ptL[0] = pt;
			ptL[1] = pt;
			ptL[1].z -= holder.N * holder.V;

			for (int i = 0;i < holder.nHs;i++)
			{
				if (i == holder.nHs - 1)
				{
					pSolid = Create3dRod(ptL[1],ptL[0],holder.bdDAsW ? holder.W : holder.dD,holder.bdDAsW ? holder.t : 0,holder.bdDAsW);
				}
				else
				{
					pSolid = Create3dRod(ptL[0],ptL[1],holder.bdDAsW ? holder.W : holder.dD,holder.bdDAsW ? holder.t : 0,holder.bdDAsW);
				}
				if (pSolid != NULL)
				{
					pSolid->setTransparency(tr);
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
				
				//强固
				if (holder.bdDAsW)//角钢
				{
					ptGe[0] = ptL[0];
					ptGe[0] -= 2.0 * holder.W * vtV;
					ptGe[1] = ptL[0];
					ptGe[1] += 2.0 * holder.W * vtV;

					pSolid = Create3dRod(ptGe[0],ptGe[1],holder.W,holder.t,holder.bdDAsW);
					if (pSolid != NULL)
					{
						pSolid->setTransparency(tr);
						dc.DrawEntity(pSolid);
						Add3DBuffer(pSolid);
					}
				}
				else
				{
					//绘制固定螺丝示意
					ptGe[0] = ptL[0];
					ptGe[0].z += 8.0;//8mm
					ptGe[1] = ptL[0];

					pSolid = Create3dRod(ptGe[0],ptGe[1],1.3 * holder.dD,0.0,holder.bdDAsW);
					if (pSolid != NULL)
					{
						pSolid->setTransparency(tr);
						dc.DrawEntity(pSolid);
						Add3DBuffer(pSolid);
					}
				}

				ptL[0] += vtL * dLx;
				ptL[1] += vtL * dLx;
			}
		}
	}
	return Acad::eOk;
}

//专业数据 和 绘制设置
AecDbObjXDataMap* AecDbHanger::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* AecDbHanger::GetSpecialtyData() const
{
	assertReadEnabled();
	return &m_mapSpecXData;
}

AcDb3dSolid* AecDbHanger::Create3dRod(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,double dL1,double dt,int nShape,double dRegRoate) const
{
	AcDb3dSolid* pPipe = NULL;
	AcGiViewDraw dcTmp(NULL,NULL);
	if (nShape == 0)//圆杆
	{
		AecDbEwPipe pipe;
		pipe.SetSection(dL1,0.0);
		pipe.SetStartPoint(ptFr);
		pipe.SetEndPoint(ptTo);
		m_pipes.push_back((AecDbEwPipe*)pipe.clone());

		pipe.Draw3d(dcTmp);
		pPipe = pipe.GetCreatPipe3dSolid();
	}
	else if(nShape == 1)//角钢
	{
		AecDbEwPipe pipe;
		pipe.SetSection3(dL1,dt);
		pipe.SetSectionRotation(dRegRoate);
		pipe.SetStartPoint(ptFr);
		pipe.SetEndPoint(ptTo);
		m_pipes.push_back((AecDbEwPipe*)pipe.clone());

		pipe.Draw3d(dcTmp);
		pPipe = pipe.GetCreatPipe3dSolid();
	}
	else if (nShape == 2)//矩形
	{
		AecDbEwPipe pipe;
		pipe.SetSection(dL1,dt,0.0);
		pipe.SetSectionRotation(dRegRoate);
		pipe.SetStartPoint(ptFr);
		pipe.SetEndPoint(ptTo);
		m_pipes.push_back((AecDbEwPipe*)pipe.clone());
		pipe.Draw3d(dcTmp);
		pPipe = pipe.GetCreatPipe3dSolid();
	}
	return pPipe;
}

int AecDbHanger::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegPtrs) const
{
	AcGeVector3d vtLn = ptTo - ptFr;
	AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);

	AcGePlane plan;
	plan.set(ptFr,vtNorm);

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	if (Get3DBuffer().length() == 0)
	{
		AcGiViewDraw dc(NULL,NULL);
		Draw3d(dc);
	}

	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;

	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);

		pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			//投影法
			OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrs);
		}
	}
	return arRegPtrs.length();
}

CString AecDbHanger::getUniqueName() const
{
	XHanger hanger;
	::memset(&hanger, 0, sizeof(XHanger));
	GetHanger(hanger);

	::memset(hanger.szMat, 0, 33 * sizeof(TCHAR));
	::memset(hanger.szUsage, 0, 33 * sizeof(TCHAR));

	return ImpMD5(&hanger, sizeof(XHanger)).toString16W().c_str();
}

SHJson::WValue &AecDbHanger::ToJson(bool bExprotGeo) const
{
	using namespace SHJson;
	assertReadEnabled();

	WValue &v = AecDbEntityBase::ToJson(bExprotGeo);

	if (bExprotGeo)
	{
		AecDbHanger *pNew = (AecDbHanger*)clone();
		pNew->SetPosition(AcGePoint3d::kOrigin, AcGeVector3d::kXAxis);
		pNew->Clean3DBuffer();
		AcGiViewDraw dc;
		pNew->Draw3d(dc);

		WValue ar;
		ar.SetArray();

		for (size_t i(0); i < pNew->m_solids.size(); ++i)
		{
			AcDbX3dSolid *pSolid(pNew->m_solids[i]);
			if (!pSolid) continue;
			WValue &x = pSolid->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_solids.empty())
			addMember(v, _T("__solids__"), ar);

		ar.SetArray();
		for (size_t i(0); i < pNew->m_pipes.size(); ++i)
		{
			AecDbEwPipeBase *pPipe(pNew->m_pipes[i]);
			if (!pPipe) continue;
			WValue &x = pPipe->ToJson();
			pushBack(ar, x);
		}
		if (!pNew->m_pipes.empty())
			addMember(v, _T("__pipes__"), ar);
		DELETE_PTR(pNew);
	}

	XHanger hanger;
	::memset(&hanger, 0, sizeof(XHanger));
	GetHanger(hanger);

	/*
	typedef struct XHanger	// 吊架 {
	int nHs;
	int N;
	double dD;
	BOOL bdDAsW;
	double V;
	double L;
	double W;
	double t;
	TCHAR szMat[33];
	TCHAR szUsage[33];
	double dResv[6];
	int    nResv[6];
	TCHAR  szResv[MAX_PATH]; }XHanger; 
	*/

	WValue data;
	addMember(data, _T("__nHs__"), hanger.nHs);
	addMember(data, _T("__N__"), hanger.N);
	addMember(data, _T("__dD__"), hanger.dD);
	addMember(data, _T("__bdDAsW__"), hanger.bdDAsW);
	addMember(data, _T("__V__"), hanger.V);
	addMember(data, _T("__L__"), hanger.L);
	addMember(data, _T("__W__"), hanger.W);
	addMember(data, _T("__t__"), hanger.t);
	addMember(data, _T("__szMat__"), hanger.szMat);
	addMember(data, _T("__szUsage__"), hanger.szUsage);
	addMember(data, _T("__szResv__"), hanger.szResv);

	WValue ar;
	ar.SetArray();
	for (int i(0); i < 6; ++i)
		pushBack(ar, hanger.dResv[i]);
	addMember(data, _T("__dResv__"), ar);

	ar.SetArray();
	for (int i(0); i < 6; ++i)
		pushBack(ar, hanger.nResv[i]);
	addMember(data, _T("__nResv__"), ar);

	addMember(v, _T("_hangerData_"), data);

	return v;
}