#include "stdafx.h"
#include "AecDbLineStair.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"

static const Adesk::UInt16 kRed            = 1;
static const Adesk::UInt16 kYellow         = 2;
static const Adesk::UInt16 kGreen          = 3;

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);
static const Adesk::UInt16 kColorByLayer   = 256;
Adesk::UInt32 AecDbLineStair::kCurrentVersionNumber = 1;
ACRX_DXF_DEFINE_MEMBERS (AecDbLineStair, AecDbBaseStair,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBLSTAIR,
						 "AecDbLineStair"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")

AecDbLineStair::AecDbLineStair(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("直梯"));
}

AecDbLineStair::~AecDbLineStair(void)
{

}

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

	//----- Read parent class information first.
	Acad::ErrorStatus es = AecDbBaseStair::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 > AecDbLineStair::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	return pFiler->filerStatus();
}

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

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

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

	return pFiler->filerStatus();
}

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

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

void AecDbLineStair::subList() const
{
	assertReadEnabled();
	acutPrintf(_T("\n直梯爬梯"));
	AecDbBaseStair::subList();
}

Acad::ErrorStatus AecDbLineStair::subTransformBy(const AcGeMatrix3d& xform)
{
	AecDbEwPipeBase::subTransformBy(xform);

	double dBomEl = 0;
	m_mapSpecXData.GetAt(KEY_BOMEL,dBomEl);

	AcGePoint3d pt(0,0,dBomEl);
	pt.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_BOMEL,pt.z);

	dBomEl = 0;
	m_mapSpecXData.GetAt(KEY_TOPEL,dBomEl);

	pt.set(0,0,dBomEl);
	pt.transformBy(xform);

	m_mapSpecXData.SetAt(KEY_TOPEL,pt.z);

	return Acad::eOk;
}

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

	CString sField,sFmt;

	sField = _T("直梯爬梯:\n");
	sInfoTip += sField;

	LineStair data;
	memset(&data,0,sizeof(LineStair));
	GetLineStairData(data);

	MAKEFIELD(_T("护栏高"),_T("%d"),(int)(data.bar.dH+0.5),sInfoTip);
	MAKEFIELD(_T("栅格间距"),_T("%d"),(int)(data.bar.dP+0.5),sInfoTip);
	MAKEFIELD(_T("高度H1"),_T("%d"),(int)(data.bar.dH1+0.5),sInfoTip);
	MAKEFIELD(_T("护栏管径"),_T("%d"),(int)(data.bar.dD+0.5),sInfoTip);

	MAKEFIELD(_T("踏步高度"),_T("%d"),(int)(data.dSteepH+0.5),sInfoTip);
	MAKEFIELD(_T("踏板厚度"),_T("%d"),(int)(data.dSteept+0.5),sInfoTip);
	MAKEFIELD(_T("踏板宽度"),_T("%d"),(int)(data.dSteepW+0.5),sInfoTip);
	MAKEFIELD(_T("楼梯总宽"),_T("%d"),(int)(data.dW+0.5),sInfoTip);

	MAKEFIELD(_T("侧板宽度"),_T("%d"),(int)(data.dSideW+0.5),sInfoTip);
	MAKEFIELD(_T("侧板厚度"),_T("%d"),(int)(data.dSidet+0.5),sInfoTip);

	MAKEFIELD(_T("底部标高"),_T("%.2f"),data.dBomEl,sInfoTip);
	MAKEFIELD(_T("顶部标高"),_T("%.2f"),data.dTopEl,sInfoTip);

	MAKEFIELD(_T("材质"),_T("%s"),data.m_sMaterial,sInfoTip);
	MAKEFIELD(_T("生产厂家"),_T("%s"),data.m_sFactory,sInfoTip);
	MAKEFIELD(_T("编号"),_T("%s"),data.m_sNo,sInfoTip);

	return true;
}

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

	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	Adesk::UInt16 nCrBk = colorIndex();

	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);
			dc.DrawEntity(*pEnt);
		}
		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);
		dc.SetLineType(idCurLty);
		return Acad::eOk;
	}

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			ptSta.z = ptEnd.z = 0.0;

			AcGeVector3d vtV = ptEnd - ptSta;
			AcGeVector3d vtL = vtV;

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

			//左线
			AcGePoint3d ptGe[5];
			ptGe[0] = ptSta;
			ptGe[0] += vtV * 0.5 * data.dW;
			
			ptGe[1] = ptEnd;
			ptGe[1] += vtV * 0.5 * data.dW;

			ptGe[2] = ptGe[1];
			ptGe[2] -= vtV * data.dSidet;

			ptGe[3] = ptGe[0];
			ptGe[3] -= vtV * data.dSidet;

			ptGe[4] = ptGe[0];

			//1.两侧边
			AcDbPolyline* pPl = FormatPolyline(ptGe,5);
			if (pPl != NULL)
			{
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}

			for (int i = 0;i < 5;i++)
			{
				ptGe[i] -= vtV * (data.dW - data.dSidet);
			}

			pPl = FormatPolyline(ptGe,5);
			if (pPl != NULL)
			{
				dc.DrawEntity(pPl);
				Add2DBuffer(pPl);
			}

			//2.内部踏板投影
			//水平长
			double dLen = ptEnd.distanceTo(ptSta);

			//垂直高
			double dH = data.dTopEl - data.dBomEl;

			//踏步数
			int nCount = (int)(dLen / data.dSteepW);

			ptGe[0] = ptSta;
			ptGe[0] += vtV * 0.5 * (data.dW - 2 * data.dSidet);
			ptGe[1] = ptSta;
			ptGe[1] -= vtV * 0.5 * (data.dW - 2 * data.dSidet);

			AcDbLine* pLn = NULL;
			vtL.normalize();
			for (int i = 0;i < nCount;i++)
			{
				ptGe[0] += vtL * data.dSteepW;
				ptGe[1] += vtL * data.dSteepW;

				pLn = new AcDbLine;
				pLn->setStartPoint(ptGe[0]);
				pLn->setEndPoint(ptGe[1]);

				dc.DrawEntity(pLn);
				Add2DBuffer(pLn);
			}

			//绘制增高方向线 ----->
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);

			ptSta = ptEnd;
			vtL.normalize();
			ptSta -= vtL * 0.25 * data.dSteepW;
			ptSta += vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);

			ptSta = ptEnd;
			vtV.normalize();
			ptSta -= vtL * 0.25 * data.dSteepW;
			ptSta -= vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);
		}

		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);
		dc.SetLineType(idCurLty);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineStair::Draw3d(AcGiDraw &dc) const
{
	//样子参照 PDMS 的样子
	assertReadEnabled();

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

	if (m_pBaseCurve == NULL)
		return Acad::eInvalidInput;

	//图层
	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())
	{
		//Clean3DBuffer();
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			pEnt->setColorIndex(nColor);
			dc.DrawEntity(*pEnt);
		}

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

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			
			ptSta.z = data.dBomEl;
			ptEnd.z = data.dTopEl;

			DrawSide3d(dc,ptSta,ptEnd,data);
			DrawSteep3d(dc,ptSta,ptEnd,data);
			DrawGuardBar3d(dc,ptSta,ptEnd,data);
		}
	}
	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineStair::DrawSide3d(AcGiDraw &dc,const AcGePoint3d& ptSta,const AcGePoint3d& ptEnd,const LineStair& data) const
{
	assertReadEnabled();

	AcGePoint3d ptGe[5];

	AcGeVector3d vtL = ptEnd - ptSta;
	double dAngle = asin(fabs(vtL.z) /vtL.length());

	vtL.z = 0.0;
	vtL.normalize();

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

	ptGe[0] = ptSta;
	ptGe[0] -= vtW * 0.5 * data.dW;

	ptGe[1] = ptGe[0];
	ptGe[1] += AcGeVector3d::kZAxis * data.dSideW / cos(dAngle);

	ptGe[3] = ptEnd;
	ptGe[3] -= vtW * 0.5 * data.dW;

	ptGe[2] = ptGe[3];
	ptGe[2] += AcGeVector3d::kZAxis * data.dSideW / cos(dAngle);

	ptGe[4] = ptGe[0];

	AcDbLine ln;
	ln.setStartPoint(ptGe[0]);
	ln.setEndPoint(ptGe[0] + vtW * data.dSidet);

	AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,5);
	if (pReg != NULL)
	{
		AcDbX3dSolid xSolid;
		if ( xSolid.CreateExtrude(pReg,ln) )
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (pSolid != NULL)
			{
				pSolid->setTransparency(transparency());
				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);

				AcGeMatrix3d xform;
				vtW *= (data.dW - data.dSidet);
				xform.setTranslation(vtW);

				AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
				if (pOtherSide != NULL)
				{
					pOtherSide->setTransparency(transparency());
					pOtherSide->transformBy(xform);
					dc.DrawEntity(pOtherSide);
					Add3DBuffer(pOtherSide);
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineStair::DrawSteep3d(AcGiDraw &dc,const AcGePoint3d& ptSta,const AcGePoint3d& ptEnd,const LineStair& data) const
{
	assertReadEnabled();

	AcGeVector3d vtL = ptEnd - ptSta;
	double dAngle = asin(fabs(vtL.z) /vtL.length());
	double dL = vtL.length();

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = (int)( (data.dTopEl - data.dBomEl) / data.dSteepH);

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步斜边步长 
	double dLSteep = data.dSteepH / sin(dAngle);

	//踏步左右总长
	double dSteepL = (data.dW - 2.0 * data.dSidet);

	AcGePoint3d ptGe[5];

	AcGePoint3d ptFr = ptSta;

	ptGe[0] = ptFr;

	ptGe[0].z -= data.dSteept;//以板顶部为基准
	ptGe[0] -= vtLXY * data.dSteept / tan(dAngle);

	ptGe[0] -= vtLXY * data.dSteepW;
	ptGe[0] -= vtW * 0.5 * dSteepL;

	ptGe[1] = ptGe[0];
	ptGe[1] += vtLXY * data.dSteepW;

	ptGe[2] = ptGe[1];
	ptGe[2] += vtW * dSteepL;

	ptGe[3] = ptGe[0];;
	ptGe[3] += vtW * dSteepL;
	ptGe[4] = ptGe[0];	

	AcDbLine ln;
	for(int i = 0;i < nCount;i++)
	{
		for(int j = 0;j < 5;j++)
		{
			ptGe[j] += vtL * dLSteep;
		}

		ln.setStartPoint(ptGe[0]);
		ln.setEndPoint(ptGe[0] + AcGeVector3d::kZAxis * data.dSteept);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,5);
		if (pReg != NULL)
		{
			AcDbX3dSolid xSolid;
			if ( xSolid.CreateExtrude(pReg,ln) )
			{
				AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
				if (pSolid != NULL)
				{
					pSolid->setTransparency(transparency());
					dc.DrawEntity(pSolid);
					Add3DBuffer(pSolid);
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineStair::DrawGuardBar3d(AcGiDraw &dc,const AcGePoint3d& ptSta,const AcGePoint3d& ptEnd,const LineStair& data) const
{
	assertReadEnabled();
	AcCmTransparency tr = transparency();
	AcCmTransparency oldTr = dc.SetTransparency(tr);

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

	AcGeVector3d vtLN(0,0,0);
	AcGeVector3d vtL = ptEnd - ptSta;
	double dAngle = asin(fabs(vtL.z) /vtL.length());
	double dL = vtL.length();
	vtL.normalize();

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	double dH = data.bar.dH;
	double dH1 = data.bar.dH1;
	int nCols = (int)( dL / data.bar.dP + 0.5);

	AcGePoint3d ptGe[3];
	ptGe[0] = ptSta;
	ptGe[0] -= vtW * 0.5 * (data.dW - data.dSidet);
	ptGe[1] = ptGe[0] + AcGeVector3d::kZAxis * dH1;
	ptGe[2] = ptGe[0] + AcGeVector3d::kZAxis * dH;

	AcGePoint3d ptGeFrL[3],ptGeFrR[3],ptGeR[3];
	memcpy(ptGeFrL,ptGe,sizeof(AcGePoint3d) * 3);

	memcpy(ptGeFrR,ptGe,sizeof(AcGePoint3d) * 3);
	for (int k = 0;k < 3;k++)
	{
		ptGeFrR[k] += vtW * (data.dW - data.dSidet);
	}

	AcDbLine ln;
	AcDbEntity* pEnt3d = NULL;
	AcDbRegion* pRegCln = NULL;

	AcGePoint3d ptGe0T;
	for(int i = 0;i <= nCols;i++)
	{
		pRegCln = GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGe[0]);
			ln.setEndPoint(ptGe[2]);
			pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
			if (pEnt3d != NULL)
			{
				pEnt3d->setColorIndex(nColor);
				Add3DBuffer(pEnt3d);
			}
			delete pRegCln;
			pRegCln = NULL;
		}

		//右边
		memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
		for (int k = 0;k < 3;k++)
		{
			ptGeR[k] += vtW * (data.dW - data.dSidet);
		}

		pRegCln = GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGeR[0]);
			ln.setEndPoint(ptGeR[2]);

			pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
			if (pEnt3d != NULL)
			{
				pEnt3d->setColorIndex(nColor);
				Add3DBuffer(pEnt3d);
			}
			delete pRegCln;
			pRegCln = NULL;
		}

		ptGe[0] += vtL * data.bar.dP;
		ptGe[1] += vtL * data.bar.dP;
		ptGe[2] += vtL * data.bar.dP;

		if ( (ptGe[0].z - ptEnd.z) > 1.e-3)
		{
			ptGe[0] = ptEnd;
			ptGe[0] -= vtW * 0.5 * (data.dW - data.dSidet);
			ptGe[1] = ptGe[0] + AcGeVector3d::kZAxis * dH1;
			ptGe[2] = ptGe[0] + AcGeVector3d::kZAxis * dH;
		}
	}

	//斜边 左侧
	pRegCln = GetSection();
	if (pRegCln != NULL)
	{
		ln.setStartPoint(ptGeFrL[1]);
		ln.setEndPoint(ptGe[1]);

		pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
		if (pEnt3d != NULL)
		{
			pEnt3d->setColorIndex(nColor);
			Add3DBuffer(pEnt3d);
		}
		delete pRegCln;
		pRegCln = NULL;
	}

	pRegCln = GetSection();
	if (pRegCln != NULL)
	{
		ln.setStartPoint(ptGeFrL[2]);
		ln.setEndPoint(ptGe[2]);

		pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
		if (pEnt3d != NULL)
		{
			pEnt3d->setColorIndex(nColor);
			Add3DBuffer(pEnt3d);
		}
		delete pRegCln;
		pRegCln = NULL;
	}

	//斜边右侧
	memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
	for (int k = 0;k < 3;k++)
	{
		ptGeR[k] += vtW * (data.dW - data.dSidet);
	}

	pRegCln = GetSection();
	if (pRegCln != NULL)
	{
		ln.setStartPoint(ptGeFrR[1]);
		ln.setEndPoint(ptGeR[1]);

		pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
		if (pEnt3d != NULL)
		{
			pEnt3d->setColorIndex(nColor);
			Add3DBuffer(pEnt3d);
		}
		delete pRegCln;
		pRegCln = NULL;
	}

	pRegCln = GetSection();
	if (pRegCln != NULL)
	{
		ln.setStartPoint(ptGeFrR[2]);
		ln.setEndPoint(ptGeR[2]);

		pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
		if (pEnt3d != NULL)
		{
			pEnt3d->setColorIndex(nColor);
			Add3DBuffer(pEnt3d);
		}
		delete pRegCln;
		pRegCln = NULL;
	}
	dc.SetTransparency(oldTr);
	return Acad::eOk;
}

SHJson::WValue &AecDbLineStair::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();
	using namespace SHJson;
	WValue &v =  AecDbEwPipeBase::ToJson(bExprotGeo);

	/*
	GuardBar bar;//扶手
	
	double dSteepH;//踏步高度
	double dSteept;//踏步板厚
	double dSteepW;//踏步板宽

	double dSidet;//底侧板厚>扶手直径
	double dSideW;//底侧板宽

	double dW;	//总宽

	double dBomEl;//底部标高
	double dTopEl;//顶部标高
	BOOL   bBomSta;//对于圆弧,是否是开始位置为底标高

	TCHAR  m_sMaterial[256];
	TCHAR  m_sFactory[256];//厂家
	TCHAR  m_sNo[256];
	*/
	
	LineStair data;
	::memset(&data, 0, sizeof(LINESTAIR));
	GetLineStairData(data);

	WValue vBar;
	addMember(vBar, _T("__dD__"), data.bar.dD);
	addMember(vBar, _T("__dt__"), data.bar.dt);
	addMember(vBar, _T("__dBomEl__"), data.bar.dBomEl);
	addMember(vBar, _T("__dH1__"), data.bar.dH1);
	addMember(vBar, _T("__dH__"), data.bar.dH);
	addMember(vBar, _T("__dP__"), data.bar.dP);

	addMember(vBar, _T("__bNoBomLever__"), data.bar.bNoBomLever == FALSE ? false : true);
	addMember(vBar, _T("__bIsRectLever__"), data.bar.bIsRectLever == FALSE ? false : true);

	addMember(vBar, _T("__sMaterial__"), data.bar.m_sMaterial);
	addMember(vBar, _T("__sFactory__"), data.bar.m_sFactory);
	addMember(vBar, _T("__sNo__"), data.bar.m_sNo);

	addMember(v, _T("__bar__"), vBar);

	addMember(v, _T("__dSteepH__"), data.dSteepH);
	addMember(v, _T("__dSteept__"), data.dSteept);
	addMember(v, _T("__dSteepW__"), data.dSteepW);

	addMember(v, _T("__dSidet__"), data.dSidet);
	addMember(v, _T("__dSideW__"), data.dSideW);

	addMember(v, _T("__dW__"), data.dW);

	addMember(v, _T("__dBomEl__"), data.dBomEl);
	addMember(v, _T("__dTopEl__"), data.dTopEl);
	addMember(v, _T("__bBomSta__"), data.bBomSta);

	addMember(v, _T("__sMaterial__"), data.m_sMaterial);
	addMember(v, _T("__sFactory__"), data.m_sFactory);
	addMember(v, _T("__sNo__"), data.m_sNo);
	
	return v;
}

bool AecDbLineStair::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEwPipeBase::ByJson(v);
}

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

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

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

	LineStair data;
	GetLineStairData(data);

	if (m_pBaseCurve != NULL)//路径
	{
		AcGePoint3d ptGe[2],ptMid;

		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			ptGe[0] = pLn->startPoint();
			ptGe[1] = pLn->endPoint();

			AcGeVector3d vtDir = ptGe[1] - ptGe[0];
			vtDir.z = 0.0;
			vtDir.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtDir.normalize();

			ptGe[0].z = data.dBomEl;
			ptGe[1].z = data.dTopEl;

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

			//高度
			ptGe[0] = ptGe[1];
			ptGe[0].z = data.dBomEl;

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

			//宽度
			ptGe[0] = pLn->startPoint();
			ptGe[0] += 0.5 * data.dW * vtDir;
			ptGe[1] = ptGe[0] - data.dW * vtDir;

			vtDir = pLn->endPoint() - pLn->startPoint();
			vtDir.z = 0.0;
			vtDir.normalize();
			ptMid = MidPoint(ptGe[0],ptGe[1]);
			ptMid -= vtDir * 10.0 * 100.0;//标注文字位置
			AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
		}
	}
	return Acad::eOk;
}