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

extern AcDbRegion* CreatePolygonRegionOnly(AcGePoint3d* pPoints,int nSize);
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);
extern CString IDCreate();
Adesk::UInt32 AecDbBossHolder::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 (AecDbBossHolder, AecDbEntityBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBBOSSHOLDER,
						 "AecDbBossHolder"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")


AecDbBossHolder::AecDbBossHolder(void)
{
	m_pGripAppData = new AecGripData[GRIP_MAXNUM];
	m_mapSpecXData.SetAt(KEY_NAME,_T("支墩"));
}

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

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

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

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

/*
	type struct XBossHolder
	{
	int nType;

	//墩
	double W;//墩宽或角钢宽
	double t;//角钢厚度t 墩厚度
	double L;//长

	//角钢
	int N;
	double V;//垂直层间距
	double H;//支撑高度 > nLay * V

	// 材质
	TCHAR szMat[MAX_PATH];

	// 用途
	TCHAR szNo[MAX_PATH];

	}XBossHolder;
*/

void AecDbBossHolder::SetHolder(const XBossHolder& data)
{
	AssertWriteEnabled();

	m_mapSpecXData.SetAt(KEY_TYPE,data.nType);
	m_mapSpecXData.SetAt(KEY_W,data.W);//A
	m_mapSpecXData.SetAt(KEY_B, data.B);//A
	m_mapSpecXData.SetAt(KEY_C, data.C);//A
	m_mapSpecXData.SetAt(KEY_L,data.L);
	m_mapSpecXData.SetAt(KEY_N,data.N);
	m_mapSpecXData.SetAt(KEY_V,data.V);
	m_mapSpecXData.SetAt(KEY_VS,data.szVs);
	m_mapSpecXData.SetAt(KEY_T,data.t);//d
	m_mapSpecXData.SetAt(KEY_H,data.H);
	m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
	m_mapSpecXData.SetAt(KEY_NO,data.szNo);
}

bool AecDbBossHolder::GetHolder(XBossHolder& data) const
{
	assertReadEnabled();

	memset(&data,0,sizeof(XBossHolder));

	m_mapSpecXData.GetAt(KEY_TYPE,data.nType);
	m_mapSpecXData.GetAt(KEY_W,data.W);
	m_mapSpecXData.GetAt(KEY_B, data.B);//A
	m_mapSpecXData.GetAt(KEY_C, data.C);//A
	m_mapSpecXData.GetAt(KEY_L,data.L);
	m_mapSpecXData.GetAt(KEY_N,data.N);
	m_mapSpecXData.GetAt(KEY_V,data.V);
	m_mapSpecXData.GetAt(KEY_T,data.t);
	m_mapSpecXData.GetAt(KEY_H,data.H);

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

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_VS,sTemp);
	_tcscpy(data.szVs,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_NO,sTemp);
	_tcscpy(data.szNo,(LPCTSTR)sTemp);

	return true;
}

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

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	memset(&aSteel, 0, sizeof(ASteel));

	if (holder.nType == 1)
	{
		aSteel.W = holder.W;
		aSteel.t = holder.t;
		aSteel.L = holder.N * holder.L;
		aSteel.L += 2.0 * holder.H;
		aSteel.L += 2.0 * 4.0 * holder.W;//固定地面

		_tcscpy(aSteel.szMat,holder.szMat);
		return true;
	}
	return false;
}

Acad::ErrorStatus AecDbBossHolder::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 > AecDbBossHolder::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	m_mapSpecXData.dwgInFields(pFiler);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbBossHolder::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 (AecDbBossHolder::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	m_mapSpecXData.dwgOutFields(pFiler);

	return Acad::eOk;
}

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

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

void AecDbBossHolder::subList() const
{
	assertReadEnabled();

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

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

	CString sField,sFmt;

	XBossHolder bossholder;
	memset(&bossholder,0,sizeof(XBossHolder));

	GetHolder(bossholder);

	if (bossholder.nType == 0)
	{
		sField = _T("支撑:\n");
		sInfoTip += sField;

		MAKEFIELD(_T("支架长"),_T("%d"),(int)(bossholder.L + 0.5),sInfoTip);
		MAKEFIELD(_T("支架高"),_T("%d"),(int)(bossholder.H + 0.5),sInfoTip);

		MAKEFIELD(_T("角钢宽"),_T("%d"),(int)(bossholder.W + 0.5),sInfoTip);
		MAKEFIELD(_T("角钢厚"),_T("%.1f"),(int)(bossholder.t + 0.5),sInfoTip);

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

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

		MAKEFIELD(_T("编号"),_T("%s"),bossholder.szNo,sInfoTip);
	}
	else
	{
		sField = _T("支墩:\n");
		sInfoTip += sField;

		MAKEFIELD(_T("支墩长"),_T("%d"),(int)(bossholder.L + 0.5),sInfoTip);

		MAKEFIELD(_T("支墩宽"),_T("%d"),(int)(bossholder.W + 0.5),sInfoTip);

		MAKEFIELD(_T("支墩高"),_T("%d"),(int)(bossholder.H + 0.5),sInfoTip);

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

		MAKEFIELD(_T("编号"),_T("%s"),bossholder.szNo,sInfoTip);
	}

	return true;
}

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

	AecDbBossHolder* pFit = AecDbBossHolder::cast(pSrc);
	if (pFit != NULL)
	{
		m_mapSpecXData.Empty();
		m_mapSpecXData.CopyFrom(&pFit->m_mapSpecXData);

		//发送提资需要相同的ID
		Adesk::Int16 nVal = acdbCurDwg()->useri4();
		if (nVal != KEY_NOPROTECT)
		{
			int nVt = 0;
			CString sID = IDCreate();
			if (m_mapSpecXData.HasKey(KEY_NO, nVt))
				m_mapSpecXData.SetAt(KEY_NO, sID);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBossHolder::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;
}

Acad::ErrorStatus AecDbBossHolder::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);

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	vtL.normalize();

	//Y
	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	//位置点
	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].nColor = kBlue;
	m_pGripAppData[i].ptGrip = pt;
	_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);

	AcGePoint3d ptT;
	if (holder.nType == 0)//墩
	{
		ptT = pt + vtL * holder.L;//长度夹点

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

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

		i++;
		ptT = pt + vtV * 0.5 * holder.W;//宽度夹点
		pGripData = new AcDbGripData;
		memset(&m_pGripAppData[i],0,sizeof(AecGripData));
		m_pGripAppData[i].nIndex = i;
		m_pGripAppData[i].ePos = eStart;
		m_pGripAppData[i].nColor = kBlue;
		m_pGripAppData[i].ptGrip = ptT;
		_tcscpy(m_pGripAppData[i].szTip,_T("宽度夹点"));
		m_pGripAppData[i].pOwner = (AcDbEntity*)this;
		m_pGripAppData[i].idHost = objectId();

		pGripData->setGripPoint(ptT);
		pGripData->setAppData((void*)&m_pGripAppData[i]);
		pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
		pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
		grips.append(pGripData);
	}
	else//支撑
	{
		ptT = pt + vtV * 0.5 * holder.L;//长度夹点

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

		pGripData->setGripPoint(ptT);
		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 AecDbBossHolder::SubAddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir) const
{
	if (GetDimGripOff())
		return Acad::eOk;

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

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	vtL.normalize();

	//Y
	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	vtL *= holder.L;
	vtV *= holder.W;

	AcGePoint3d ptGe[2],ptMid;
	AcGeVector3d vtDirX = vtL;

	if (holder.nType == 0)
	{
		ptGe[0] = pt;
		ptGe[1] = pt + vtL;
		ptGe[0] -= 0.5 * vtV;
		ptGe[1] -= 0.5 * vtV;

		vtL.normalize();
		vtV.normalize();

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

		//W
		ptGe[0] = pt + 0.5 * vtV * holder.W;
		ptGe[1] = pt - 0.5 * vtV * holder.W;
		vtL.normalize();
		ptGe[0] -= vtL * 10.0;
		ptGe[1] -= vtL * 10.0;

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

		//高
		ptGe[1] = ptGe[0];
		ptGe[1].z -= holder.H;
		ptMid = MidPoint(ptGe[0],ptGe[1]);
		ptMid -= vtL * 10.0 * 100.0;//标注文字位置
		AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
	}
	else
	{
		vtL.normalize();
		vtV.normalize();

		ptGe[0] = pt + vtV * 0.5 * holder.L;//长度夹点
		ptGe[1] = ptGe[0] - vtV * holder.L;

		ptGe[0] -= vtL * 10.0;
		ptGe[1] -= vtL * 10.0;

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

		ptGe[1] = ptGe[0];
		ptGe[1].z -= holder.H;
		ptMid = MidPoint(ptGe[0],ptGe[1]);
		ptMid -= vtL * 10.0 * 100.0;//标注文字位置
		AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBossHolder::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 AecDbBossHolder::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	vtL.normalize();

	//Y
	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	//位置点
	stretchPoints.append(pt);

	AcGePoint3d ptT;
	if (holder.nType == 0)//墩
	{
		ptT = pt + vtL * holder.L;//长度夹点
		stretchPoints.append(ptT);

		ptT = pt + vtV * 0.5 * holder.W;//宽度夹点
		stretchPoints.append(ptT);
	}
	else//支撑
	{
		ptT = pt + vtV * holder.L;//长度夹点
		stretchPoints.append(ptT);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbBossHolder::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,pt2;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtL.normalize();
	vtV.normalize();

	int nGripIndex = arIndex.first();

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	if (holder.nType == 0)//墩
	{
		if (nGripIndex == 0)
		{
			pt += offset;
			m_mapSpecXData.SetAt(KEY_POS,pt);
		}
		else if (nGripIndex == 1)//长度
		{
			pt2 = pt + vtL * holder.L;
			pt2 += offset;
			holder.L = pt2.distanceTo(pt);
			m_mapSpecXData.SetAt(KEY_L,holder.L);
		}
		else if (nGripIndex == 2)//宽度
		{
			pt2 = pt + vtV * 0.5 * holder.W;
			pt2 += offset;
			holder.W = 2.0 * pt2.distanceTo(pt);
			m_mapSpecXData.SetAt(KEY_W,holder.W);
		}
	}
	else//支撑
	{
		if (nGripIndex == 0)
		{
			pt += offset;
			m_mapSpecXData.SetAt(KEY_POS,pt);
		}
		else if (nGripIndex == 1)//长度
		{
			pt2 = pt + vtL * holder.L;
			pt2 += offset;
			holder.L = pt2.distanceTo(pt);
			m_mapSpecXData.SetAt(KEY_L,holder.L);
		}
	}
	return Acad::eOk;
}

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

	AssertWriteEnabled();

	AcGeMatrix3d xformM;
	xformM.setToTranslation(offset);

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

	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtL.normalize();
	vtV.normalize();

	if (indices.find(0) != -1)//位置移动
	{
		pt += offset;
		m_mapSpecXData.SetAt(KEY_POS,pt);
		return Acad::eOk;
	}

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	if (indices.find(1) != -1)
	{
		pt2 = pt + vtL * holder.L;
		pt2 += offset;
		holder.L = pt2.distanceTo(pt);
		m_mapSpecXData.SetAt(KEY_L,holder.L);
		return Acad::eOk;
	}

	if (indices.find(2) != -1)
	{
		pt2 = pt + vtV * 0.5 * holder.W;
		pt2 += offset;
		holder.W = 2.0 * pt2.distanceTo(pt);
		m_mapSpecXData.SetAt(KEY_W,holder.W);
	}
	return Acad::eOk;
}

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

Acad::ErrorStatus AecDbBossHolder::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;
	}

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	AcGePoint3d pt;
	AcGeVector3d vtL;
	m_mapSpecXData.GetAt(KEY_POS,pt);
	pt.z = 0.0;

	m_mapSpecXData.GetAt(PIPE_DIR,vtL);

	pt.z = 0.0;//2D
	vtL.z = 0.0;//2D
	vtL.normalize();
	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	//        0|  |1
	//         |  |
	//         |  |
	//         |  | w
	//    pt+  |  |
	//         |  |
	//         |  |  
	//         |  |   
	//       3 |__| 2  
    //        L 

	//
	AcGePoint3d ptGe[5];
	double dW = 0.0,dL = 0.0;
	if ( holder.nType == 0) //墩
	{
		dL = holder.L;//墩长
		dW = holder.W;//墩宽
		pt -= vtL * 0.5 * dL;//中心
	}
	else//支撑
	{
		dL = holder.W;//角钢宽
		dW = holder.L;//长度
	}


	ptGe[0] = pt;
	ptGe[0] += vtV * 0.5 * dW;//中心布置

	ptGe[1] = ptGe[0] + vtL * dL;
	ptGe[2] = ptGe[1] - vtV * dW;

	ptGe[3] = ptGe[0] - vtV * dW;
	ptGe[4] = ptGe[0];

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

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

	//管线系统屏蔽掉
	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);
			dc.DrawEntity(*pEnt);
		}

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

	deleteContainerOfStd(m_solids);
	deleteContainerOfStd(m_pipes);

	XBossHolder holder;
	memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

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

	vtL.normalize();
	AcGeVector3d vtV = vtL;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	//pt 中含有顶标高
	AcGePoint3d ptTo = pt;
	AcGePoint3d ptFr;
	AcGePoint3d ptGe[5];

	double dW = 0.0,dL = 0.0,dH = 0.0,dt = 0.0;
	if (holder.nType == 0)//墩
	{
		ptFr = ptTo;
		ptFr.z -= holder.H;

		dL = holder.L;//长度
		dW = holder.W;//高度

		double dAngle = AcGeVector3d::kXAxis.angleTo(vtL, AcGeVector3d::kZAxis);

		AcDb3dSolid* pSolid = Create3dRod(ptFr, ptTo, dL, dW, 2, dAngle);
		if (pSolid != NULL)
		{
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}
	}
	else//支撑架
	{
		dL = holder.L;//长度
		dH = holder.H;//高度

		int nLay = holder.N;

		ptFr = pt;//顶部
		ptTo = pt;

		ptFr += vtV * 0.5 * dL;
		ptTo -= vtV * 0.5 * dL;

		AcGePoint3d ptL[2];
		ptL[0] = ptFr;
		ptL[1] = ptTo;

		CStringArray arInf;
		if (_tcsclen(holder.szVs) > 0)
		{
			SplitStrintToArray(holder.szVs,arInf,_T(';'));
			holder.N = arInf.GetSize();
		}

		//层水平
		AcDb3dSolid* pSolid = NULL;
		for (int i = 0;i <= holder.N;i++)
		{
			if (holder.nType == 2)
			{
				pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.B, holder.C, holder.t, 2,-PI/2.0);
			}
			else
			{
				pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.t, 1);
			}

			if (pSolid != NULL)
			{
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}

			//标准层,最后一层画完,退出
			if (i == (holder.N - 1) && arInf.GetSize() == 0)
			{
				break;
			}
			else if (i == holder.N && arInf.GetSize() > 0)
			{
				break;
			}

			if (arInf.GetSize() > 0)
			{
				ptL[0].z -= _ttof(arInf.GetAt(i));
				ptL[1].z -= _ttof(arInf.GetAt(i));
			}
			else
			{
				ptL[0].z -= holder.V;
				ptL[1].z -= holder.V;
			}
		}

		ptFr -= 0.5 * holder.W * vtV;
		ptFr -= 0.5 * holder.W * vtL;

		//Fr侧
		ptL[0] = ptFr;
		ptL[1] = ptFr;
		ptL[0] += 0.5 * holder.W * vtL;
		ptL[1] += 0.5 * holder.W * vtL;
		ptL[0] += 0.5 * holder.W * vtV;
		ptL[1] += 0.5 * holder.W * vtV;

		ptL[1].z -= dH;

		if (holder.nType == 2)
		{
			pSolid = Create3dRod(ptL[0], ptL[1], holder.W,holder.B,holder.C,holder.t, 1,PI/2.0);
		}
		else
		{
			pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.t, 1);
		}

		if (pSolid != NULL)
		{
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}

		//底部固定
		ptGe[0] = ptL[1];
		ptGe[0] -= 2.0 * holder.W * vtL;//两倍宽度长
		ptGe[1] = ptL[1];
		ptGe[1] += 2.0 * holder.W * vtL;//两倍宽度长
		ptGe[0] -= 0.5 * holder.W * vtV;
		ptGe[1] -= 0.5 * holder.W * vtV;

		pSolid = Create3dRod(ptGe[0], ptGe[1], holder.W, holder.t, 2);
		if (pSolid != NULL)
		{
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}

		//To侧
		ptTo += 0.5 * holder.W * vtV;
		ptTo -= 0.5 * holder.W * vtL;

		ptL[0] = ptTo;
		ptL[1] = ptTo;
		ptL[0] += 0.5 * holder.W * vtL;
		ptL[1] += 0.5 * holder.W * vtL;
		ptL[0] += 0.5 * holder.W * vtV;
		ptL[1] += 0.5 * holder.W * vtV;
		
		ptL[1].z -= dH;
		if (holder.nType == 2)
		{
			pSolid = Create3dRod(ptL[1], ptL[0], holder.W, holder.B, holder.C, holder.t, 1, -PI / 2.0);
		}
		else
		{
			pSolid = Create3dRod(ptL[1], ptL[0], holder.W, holder.t, 1);
		}
		if (pSolid != NULL)
		{
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}

		//底部固定
		ptGe[0] = ptL[1];
		ptGe[0] -= 2.0 * holder.W * vtL;//两倍宽度长
		ptGe[1] = ptL[1];
		ptGe[1] += 2.0 * holder.W * vtL;//两倍宽度长
		ptGe[0] -= 0.5 * holder.W * vtV;
		ptGe[1] -= 0.5 * holder.W * vtV;

		pSolid = Create3dRod(ptGe[0], ptGe[1], holder.W, holder.t, 2);
		if (pSolid != NULL)
		{
			dc.DrawEntity(pSolid);
			Add3DBuffer(pSolid);
		}
	}
	return Acad::eOk;
}

AecDbObjXDataMap* AecDbBossHolder::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* AecDbBossHolder::GetSpecialtyData() const
{
	assertReadEnabled();
	return &m_mapSpecXData;
}

AcDb3dSolid *AecDbBossHolder::Create3dRod(const AcGePoint3d &ptFr, const AcGePoint3d &ptTo, double dA, double dB, double dC, double dD, int nShape, double dRegRoate) const
{
	AcDb3dSolid *pPipe = NULL;
	AcGiViewDraw dcTmp(NULL, NULL);

	AcGePoint3d ptGe[9], ptGeT;
	ptGeT.set(0, 0, 0);


	ptGe[0] = ptGeT + 0.5 * dA * AcGeVector3d::kYAxis;
	ptGe[1] = ptGe[0] + dB * AcGeVector3d::kXAxis;
	ptGe[2] = ptGe[1] - dC * AcGeVector3d::kYAxis;
	ptGe[3] = ptGe[2] - (dB - dD)*AcGeVector3d::kXAxis;
	ptGe[4] = ptGe[3] - (dA - 2.0*dC) * AcGeVector3d::kYAxis;
	ptGe[5] = ptGe[4] + (dB - dD) * AcGeVector3d::kXAxis;
	ptGe[6] = ptGe[5] - dC * AcGeVector3d::kYAxis;
	ptGe[7] = ptGe[6] - dB * AcGeVector3d::kXAxis;
	ptGe[8] = ptGe[0];
	
	AcDbRegion *pReg = CreatePolygonRegionOnly(ptGe, 9);
	if (pReg != NULL)
	{
		AecDbEwPipe pipe;
		pipe.SetSection(pReg, AcGePoint3d::kOrigin);
		pipe.SetSectionRotation(dRegRoate);
		pipe.SetStartPoint(ptFr);
		pipe.SetEndPoint(ptTo);
		m_pipes.push_back((AecDbEwPipe *)pipe.clone());

		pipe.Draw3d(dcTmp);
		pPipe = pipe.GetCreatPipe3dSolid();
	}
	return pPipe;
}

AcDb3dSolid* AecDbBossHolder::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 AecDbBossHolder::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 AecDbBossHolder::getUniqueName() const
{
	XBossHolder holder;
	::memset(&holder, 0, sizeof(XBossHolder));
	GetHolder(holder);

	::memset(holder.szNo, 0, MAX_PATH * sizeof(TCHAR));
	::memset(holder.szMat, 0, MAX_PATH * sizeof(TCHAR));

	return ImpMD5(&holder, sizeof(XBossHolder)).toString16W().c_str();
}

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

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

	if (bExprotGeo)
	{
		AecDbBossHolder *pNew = (AecDbBossHolder*)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);
	}

	XBossHolder hanger;
	::memset(&hanger, 0, sizeof(XBossHolder));
	GetHolder(hanger);

	/*typedef struct XBossHolder {
		int nType;
		double W;//墩宽或角钢宽
		double t;//角钢厚度t 墩厚度
		double L;//长
		int N;
		double V;//垂直层间距
		TCHAR szVs[MAX_PATH];//不等层的间距集合;隔开
		double H;//支撑高度 > nLay * V
		TCHAR szMat[MAX_PATH];
		TCHAR szNo[MAX_PATH]; }XBossHolder;*/

	WValue data;
	addMember(data, _T("__nType__"), hanger.nType);
	addMember(data, _T("__W__"), hanger.W);
	addMember(data, _T("__t__"), hanger.t);
	addMember(data, _T("__L__"), hanger.L);
	addMember(data, _T("__N__"), hanger.N);
	addMember(data, _T("__V__"), hanger.V);
	addMember(data, _T("__H__"), hanger.H);
	addMember(data, _T("__szVs__"), hanger.szVs);
	addMember(data, _T("__szMat__"), hanger.szMat);
	addMember(data, _T("__szNo__"), hanger.szNo);
	addMember(v, _T("_bosshangerData_"), data);

	return v;
}