#include "stdafx.h"
#include "AecDbGuardBar.h"
#include "KTSetting.h"
#include "KTCADUtilityEx.h"
#include "dbgrip.h"
#include "AecGripCback.h"
#include "AcGiViewDraw.h"

extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2);
extern BOOL DLLIMPEXP GetDimGripOff();
extern void SortPoints(std::vector<AcGePoint3d>& arPts,AcGeVector3d& vtDir);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);

static const Adesk::UInt16 kColorByLayer   = 256;

Adesk::UInt32 AecDbGuardBar::kCurrentVersionNumber = 1;

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


AecDbGuardBar::AecDbGuardBar(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("护栏"));
}

AecDbGuardBar::~AecDbGuardBar(void)
{
}

void AecDbGuardBar::SetGuardBarData(const GuardBar& bar)
{
	AssertWriteEnabled();
	//set section; 底层设置section,用于绘制管子
	//路径单独设置
	//bar数据key方式保存
	if (bar.bIsRectLever)
	{
		SetSection(bar.dD,bar.dD,bar.dt);
	}
	else
	{
		SetSection(bar.dD,bar.dt);
	}

	/*
	typedef struct GuardBar
	{
	double dD;
	double dt;
	double dBomEl;
	int nRow;
	double dH;
	TCHAR m_sMaterial[256];

	}GUARDBAR;
	*/

	m_mapSpecXData.SetAt(PIPE_D,bar.dD);
	m_mapSpecXData.SetAt(PIPE_THICK,bar.dt);
	m_mapSpecXData.SetAt(PIPE_EL,bar.dBomEl);
	m_mapSpecXData.SetAt(KEY_HEIGHT1,bar.dH1);
	m_mapSpecXData.SetAt(KEY_HEIGHT,bar.dH);
	m_mapSpecXData.SetAt(KEY_SP,bar.dP);

	m_mapSpecXData.SetAt(KEY_NOBOMLEVER,bar.bNoBomLever);
	m_mapSpecXData.SetAt(KEY_ISRECTLEVER,bar.bIsRectLever);
	m_mapSpecXData.SetAt(KEY_VERDRAW,bar.bVerDraw);

	m_mapSpecXData.SetAt(KEY_MATERIAL,bar.m_sMaterial);
	m_mapSpecXData.SetAt(KEY_MATERIAL,bar.m_sNo);
}

bool AecDbGuardBar::GetGuardBarData(GuardBar& bar) const
{
	assertReadEnabled();

	m_mapSpecXData.GetAt(PIPE_D,bar.dD);
	m_mapSpecXData.GetAt(PIPE_THICK,bar.dt);
	m_mapSpecXData.GetAt(PIPE_EL,bar.dBomEl);
	m_mapSpecXData.GetAt(KEY_HEIGHT1,bar.dH1);
	m_mapSpecXData.GetAt(KEY_HEIGHT,bar.dH);
	m_mapSpecXData.GetAt(KEY_SP,bar.dP);

	m_mapSpecXData.GetAt(KEY_NOBOMLEVER,bar.bNoBomLever);
	m_mapSpecXData.GetAt(KEY_ISRECTLEVER,bar.bIsRectLever);
	m_mapSpecXData.GetAt(KEY_VERDRAW,bar.bVerDraw);

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(bar.m_sMaterial,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(bar.m_sNo,(LPCTSTR)sTemp);

	return true;
}

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

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

	return pFiler->filerStatus();
}

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

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

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

	return pFiler->filerStatus();
}

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

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

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

	//调用基类加入单击修改
	SubAddHitEditGrip(grips);

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbGuardBar::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
{
	if (HitOnGripEdit(appData))
	{
		return Acad::eOk;
	}
	Acad::ErrorStatus es = AecDbEwPipeBase::subMoveGripPointsAt(appData, offset, bitflags);
	return es;
}

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

	AcGeVector3d vtDirX;
	AcGePoint3d ptGe[4],ptMid;

	GuardBar bar;
	GetGuardBarData(bar);

	AcDbPolyline* pPl = AcDbPolyline::cast( m_pBaseCurve );
	if (pPl != NULL)
	{
		for (int ii = 0;ii < pPl->numVerts() - 1;ii++)
		{
			pPl->getPointAt(ii,ptGe[0]);
			pPl->getPointAt(ii+1,ptGe[1]);

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

			AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
		}

		//段长
		pPl->getPointAt(0,ptGe[0]);
		pPl->getFirstDeriv(ptGe[0],vtDirX);
		vtDirX.normalize();
		ptGe[1] = ptGe[0] + bar.dP * vtDirX;
		ptGe[0].z += bar.dH;
		ptGe[1].z += bar.dH;
		vtDirX.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		vtDirX.normalize();
		ptMid = MidPoint(ptGe[0],ptGe[1]);
		ptMid += vtDirX * 10.0 * 100.0;//标注文字位置
		AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
		
		//标注高度
		pPl->getPointAt(0,ptGe[0]);
		ptGe[0].z = bar.dBomEl;
		ptGe[1] = ptGe[0];
		ptGe[1].z += bar.dH;

		pPl->getFirstDeriv(ptGe[0],vtDirX);
		vtDirX.negate();
		vtDirX.normalize();
		vtDirX *= 10.0;

		ptGe[0] += vtDirX;
		ptGe[1] += vtDirX;

		ptMid = MidPoint(ptGe[0],ptGe[1]);
		ptMid += vtDirX * 100.0;//标注文字位置
		AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
	}
	return Acad::eOk;
}

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

	AecDbEwPipeBase::subList();

	//
#ifndef ZWCAD
	if (m_pBaseCurve != NULL)
		m_pBaseCurve->list();
#endif

	GuardBar bar;
	GetGuardBarData(bar);

	/*
	typedef struct GuardBar
	{
	double dD;//管材直径
	double dt;//管材厚度
	double dBomEl;//底标高
	double dH1;//底部格高
	double dH;//扶手顶到底部高度
	double dP;//格间距
	TCHAR  m_sMaterial[256];
	//...
	}GUARDBAR;
	*/
	acutPrintf(_T("\n护栏"));
	acutPrintf(_T("\n护栏管材直径:%.f"),bar.dD);
	acutPrintf(_T("\n护栏底标高:%.f"),bar.dBomEl);
	acutPrintf(_T("\n护栏高度H1:%.f"),bar.dH1);
	acutPrintf(_T("\n护栏高度H:%.f"),bar.dH);
	acutPrintf(_T("\n护栏栅格长:%.f"),bar.dP);
	acutPrintf(_T("\n护栏材料:%s"),bar.m_sMaterial);
}

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

	GuardBar bar;
	GetGuardBarData(bar);

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

	//标高 
	AcGePoint3d pt1, pt2;
	AcDbLine *pLn = AcDbLine::cast(m_pBaseCurve);
	if (pLn != NULL)
	{
		AcGeVector3d vtNorm = pLn->normal();
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
		{
			pt1 = pLn->startPoint();
			pt1.z = dBomEl;

			pt2 = pLn->endPoint();
			pt2.z = dBomEl;

			pLn->setStartPoint(pt1);
			pLn->setEndPoint(pt2);
		}
	}

	AcDbPolyline *pPl = AcDbPolyline::cast(m_pBaseCurve);
	if (pPl != NULL)
	{
		AcGeVector3d vtNorm = pPl->normal();
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
		{
			pPl->setElevation(dBomEl);
		}
	}

	return Acad::eOk;
}

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

	GuardBar bar;
	memset(&bar,0,sizeof(GuardBar));
	GetGuardBarData(bar);

	CString sField,sFmt;
	sField = _T("护栏:\n");
	sInfoTip += sField;

	MAKEFIELD(_T("管材直径"),_T("%d"),(int)(bar.dD+0.5),sInfoTip);
	MAKEFIELD(_T("底标高"),_T("%.f"),bar.dBomEl,sInfoTip);

	MAKEFIELD(_T("护栏高度高度H1"),_T("%.f"),bar.dH1,sInfoTip);
	MAKEFIELD(_T("护栏高度H"),_T("%.f"),bar.dH,sInfoTip);

	MAKEFIELD(_T("护栏栅格长"),_T("%.f"),bar.dP,sInfoTip);
	MAKEFIELD(_T("护栏材料"),_T("%s"),bar.m_sMaterial,sInfoTip);
	MAKEFIELD(_T("编号"),_T("%s"),bar.m_sNo,sInfoTip);

	return true;
}

AcDbCurve* GetPlOrthoProjectedCurve(AcDbPolyline* pPl)
{
	AcGeVector3d vtNorm = pPl->normal();
	AcGeLine3d ln3d(AcGePoint3d::kOrigin,vtNorm);
	if (AcGePlane::kXYPlane.isParallelTo(ln3d))
	{
		AcDbCurve* pProj = NULL;
		
		AcDbVoidPtrArray arPtrs;
		pPl->explode(arPtrs);

		AcGePoint3d ptS,ptE;
		AcGeVector3d vtLine(0,0,0),vtT;
		std::vector<AcGePoint3d> arPts;

		for (int i = 0;i < arPtrs.length();i++)
		{
			AcDbCurve* pCr = (AcDbCurve*)arPtrs.at(i);
			if (pCr != NULL)
			{
				//acutPrintf(_T("\nclass = %s"),pCr->isA()->name());
				pCr->getStartPoint(ptS);
				pCr->getEndPoint(ptE);
				ptS.z = 0.0;ptE.z = 0.0;//到XY面

				AcDbLine* pLn = AcDbLine::cast(pCr);
				if (pLn != NULL)
				{
					vtT = pLn->endPoint() - pLn->startPoint();

					AcGeLine3d ln3d2(AcGePoint3d::kOrigin,vtT);
					if (AcGePlane::kXYPlane.isParallelTo(ln3d2))
					{
						vtLine = vtT;
					}
				}
				else
				{
					pCr->getOrthoProjectedCurve(AcGePlane::kXYPlane,pProj);
					if (pProj != NULL)
					{
						pProj->getStartPoint(ptS);
						pProj->getEndPoint(ptE);
						ptS.z = 0.0;ptE.z = 0.0;//到XY面

						vtT = ptE - ptS;
						AcGeLine3d ln3d2(AcGePoint3d::kOrigin,vtT);
						if (AcGePlane::kXYPlane.isParallelTo(ln3d2))
						{
							vtLine = vtT;
						}
						delete pProj;
					}
				}

				if (ptS.distanceTo(ptE) > 1.e-2)
				{
					arPts.push_back(ptS);
					arPts.push_back(ptE);
				}
				delete pCr;
			}
		}

		if (!vtLine.isZeroLength() && arPts.size() > 0)
		{
			SortPoints(arPts,vtLine);

			AcDbLine* pLn = new AcDbLine(arPts.at(0),arPts.at(arPts.size() - 1));
			return pLn;
		}
		else
		{
			if (arPts.size() >= 2)
			{
				AcDbLine* pLn = new AcDbLine(arPts.at(0),arPts.at(arPts.size() - 1));
				return pLn;
			}
		}
	}
	return NULL;
}

Acad::ErrorStatus AecDbGuardBar::VerDraw2d(AcGiDraw &dc,const GuardBar& bar) const
{
	AcGePoint3d ptS,ptE;
	AcDbExtents ext;
	m_pBaseCurve->getGeomExtents(ext);

	AcDbCurve* pBaseCurve = NULL;

	AcGePoint3d ptTmp;
	m_pBaseCurve->getStartPoint(ptTmp);

	AcDbCurve* pLnBase = (AcDbCurve*)m_pBaseCurve->isA()->create();
	AecDbCurveBase::CopyObject(*m_pBaseCurve,*pLnBase);

	ptS = ext.minPoint();
	ptE = ext.maxPoint();ptE.z = ptS.z;

	pBaseCurve = pLnBase;
	if (pBaseCurve != NULL)
	{
		AcDbCurve* pBaseCln0 = NULL;
		AcDbCurve* pBaseCln1 = NULL;
		AcDbCurve* pBaseCln2 = NULL;

		pBaseCln0 = (AcDbCurve*)pBaseCurve->isA()->create();
		AecDbCurveBase::CopyObject(*pBaseCurve,*pBaseCln0);

		pBaseCln1 = (AcDbCurve*)pBaseCurve->isA()->create();
		AecDbCurveBase::CopyObject(*pBaseCurve,*pBaseCln1);

		pBaseCln2 = (AcDbCurve*)pBaseCurve->isA()->create();
		AecDbCurveBase::CopyObject(*pBaseCurve,*pBaseCln2);
		
		AcDbPolyline* pPl = AcDbPolyline::cast(pBaseCurve);
		if (pPl != NULL)
		{
			AcGeVector3d vtNorm = pPl->normal();
			AcGeLine3d ln3d(AcGePoint3d::kOrigin,vtNorm);
			if (AcGePlane::kXYPlane.isParallelTo(ln3d))
			{
				delete pBaseCln0;pBaseCln0 = NULL;
				delete pBaseCln1;pBaseCln1 = NULL;
				delete pBaseCln2;pBaseCln2 = NULL;

				pBaseCln0 = GetPlOrthoProjectedCurve(pPl);
				if (pBaseCln0 != NULL)
				{
					pBaseCln1 = (AcDbCurve*)pBaseCln0->isA()->create();
					AecDbCurveBase::CopyObject(*pBaseCln0,*pBaseCln1);

					pBaseCln2 = (AcDbCurve*)pBaseCln0->isA()->create();
					AecDbCurveBase::CopyObject(*pBaseCln0,*pBaseCln2);
				}
			}
		}

		if (pBaseCln0 == NULL || pBaseCln1 == NULL || pBaseCln2 == NULL)
			return Acad::eOk;

		AcGeVector3d vtM;
		vtM.set(0,0,0);
		AcGeMatrix3d xform;
		xform.setToTranslation(vtM);

		pBaseCln0->transformBy(xform);
		pBaseCln1->transformBy(xform);
		pBaseCln2->transformBy(xform);

		vtM.set(0,bar.dH1,0);
		xform.setToTranslation(vtM);
		pBaseCln1->transformBy(xform);

		vtM.set(0,bar.dH,0);
		xform.setToTranslation(vtM);
		pBaseCln2->transformBy(xform);

		double dSta = 0.0,dEnd = 0.0;
		pBaseCln0->getStartParam(dSta);
		pBaseCln0->getEndParam(dEnd);

		double dL = 0.0;
		pBaseCln0->getDistAtParam(dEnd,dL);

		int nCol = (int)(dL / bar.dP + 0.5);
		double dSpa = (dEnd - dSta) / nCol;

		AcDbLine* pLn = NULL;
		AcGePoint3d ptPos,ptTop;
		for (int i = 0;i <= nCol;i++)
		{
			pBaseCln0->getPointAtDist(0.0 + i * bar.dP,ptPos);
			if (i == nCol)
			{
				pBaseCln0->getEndPoint(ptPos);
			}

			ptTop = ptPos;
			ptTop.y += bar.dH;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptPos);
			pLn->setEndPoint(ptTop);

			pLn->setColorIndex(kColorByLayer);
			dc.DrawEntity(pLn);
			Add2DBuffer(pLn);
		}

		pBaseCln0->setColorIndex(kColorByLayer);
		dc.DrawEntity(pBaseCln0);
		Add2DBuffer(pBaseCln0);

		pBaseCln1->setColorIndex(kColorByLayer);
		dc.DrawEntity(pBaseCln1);
		Add2DBuffer(pBaseCln1);

		pBaseCln2->setColorIndex(kColorByLayer);
		dc.DrawEntity(pBaseCln2);
		Add2DBuffer(pBaseCln2);

		delete pBaseCurve;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbGuardBar::HorDraw2d(AcGiDraw &dc,const GuardBar& bar) const
{
	AcDbCurve* pProj = NULL;
	AcDbVoidPtrArray arSegPtrs,arCurPtrs,arResult;
	AcDbObjectId idLnSt = KTSetting::InitLineStyle(_T("FENCELINE1"));
	Acad::ErrorStatus es;

	AcDbPolyline* pPl = AcDbPolyline::cast(m_pBaseCurve);
	if (pPl != NULL)
	{
		AcDbCurve* pPlCln = (AcDbCurve*)pPl->clone();
		if (pPlCln != NULL)
		{
			pPlCln->setLayer(layerId());
			pPlCln->setLinetype(idLnSt);
			es = pPlCln->setLinetypeScale(20.0);

			dc.DrawEntity(pPlCln);
			Add2DBuffer(pPlCln);

			return Acad::eOk;
		}
	}
	
	m_pBaseCurve->explode(arSegPtrs);
	AcDbCurve* pCurT = NULL;
	for (int ii = 0;ii < arSegPtrs.length();ii++)
	{
		pCurT = (AcDbCurve*)arSegPtrs.at(ii);
		if (pCurT != NULL)
		{
			AcDbArc* pArc = AcDbArc::cast(pCurT);
			if (pArc != NULL)
			{
				arCurPtrs.append(pCurT);
				continue;
			}
			AcDbLine* pLn = AcDbLine::cast(pCurT);
			if (pLn != NULL)
			{
				arCurPtrs.append(pCurT);
				continue;
			}

			pCurT->getOrthoProjectedCurve(AcGePlane::kXYPlane,pProj);
			if (pProj != NULL)
			{
				arCurPtrs.append(pProj);
			}
			delete pCurT;
		}
	}

	//-------()-------()-------()--------
	//FENCELINE1

	AcDbCurve* pCurve = KTCADUtilityEx::ConvertBoundCurve(arCurPtrs,arResult);
	if (pCurve != NULL)
	{
		AcDbPolyline* pPl = AcDbPolyline::cast(pCurve);
		if (pPl != NULL)
		{
			pPl->setNormal(AcGeVector3d::kZAxis);
		}
		pCurve->setLayer(layerId());
		pCurve->setLinetype(idLnSt);
		es = pCurve->setLinetypeScale(20.0);

		dc.DrawEntity(pCurve);
		Add2DBuffer(pCurve);
	}
	return Acad::eOk;
}

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

	if (m_pBaseCurve != NULL)//路径
	{
		int nStyle = 0,nCol = 0;
		m_mapSpecXData.GetAt(KEY_2DSTYLE,nStyle);

		double dSta = 0.0,dEnd = 0.0,dL1 = 0.0;
		double dL2 = 0.0,dP = 0.0,dH = 0.0,dH1 = 0.0;

		BOOL bVerDraw = 0;
		m_mapSpecXData.GetAt(KEY_SP,dP);
		m_mapSpecXData.GetAt(KEY_HEIGHT,dH);
		m_mapSpecXData.GetAt(KEY_HEIGHT1,dH1);
		m_mapSpecXData.GetAt(KEY_VERDRAW,bVerDraw);

		AcDbObjectId idLnSt;
		AcDbVoidPtrArray arCurPtrs,arResult;

		AcGeVector3d vtDrawPlanNorm = AcGeVector3d::kZAxis;
		AcGePlane planXY;
		dc.GetDraw2DPlan(planXY);
		vtDrawPlanNorm = planXY.normal();

		//取法向量
		AcGeVector3d vtDir;
		AcDbPolyline* pPlBase = AcDbPolyline::cast(m_pBaseCurve);
		if (pPlBase != NULL)
		{
			vtDir = pPlBase->normal();
		}

		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			vtDir = pLn->normal();
		}
		vtDir.normalize();

		AcGePoint3d ptS,ptE;
		AcGeLine3d ln3d(AcGePoint3d::kOrigin,10.0 * vtDir);

		GuardBar bar;
		GetGuardBarData(bar);

		switch(nStyle)
		{
		case 0:
			{
				//曲线法向量平行XY面，绘制栅格
				if ( ln3d.isParallelTo(planXY)  )//二维 或 立面护栏
				{
					//栅格
					//------------------------------------
					//| |  |  |  |  |  |  |  |  |  |  |  | 
					//------------------------------------

					if ( bVerDraw )//二维,栅格表达
					{
						VerDraw2d(dc,bar);
					}
					else //立面起伏护栏
					{
						HorDraw2d(dc,bar);
					}
				}
				else //放样线在 XY 平行平面内
				{
					if (ln3d.isPerpendicularTo(planXY)) //单线
					{
						if ( bVerDraw )
						{
							VerDraw2d(dc,bar);
						}
						else
						{
							HorDraw2d(dc,bar);
						}
					}
				}
				break;
			}
		default:
			break;
		}

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

//解决poly带来的3D消失为题

AcDbEntity* AecDbGuardBar::DrawPipe(AcGiDraw &dc,AcDbCurve* pBaseCln1,AcDbRegion* pRegnCln,const AcGePoint3d& ptOrigin,int nColor) const
{
	AcDbPolyline* pPl = AcDbPolyline::cast(pBaseCln1);
	if (pPl != NULL)
	{
		AcDbVoidPtrArray arCurPtrs;
		pPl->explode(arCurPtrs);

		AcDbEntity* p3dEnt = NULL;
		AcDbCurve* pCurT = NULL;
		for (int i = 0;i < arCurPtrs.length();i++)
		{
			pCurT = (AcDbCurve*)arCurPtrs.at(i);
			
			AcDbRegion* pRegnClnCln = (AcDbRegion*)pRegnCln->clone();
			p3dEnt = dc.DrawPipe(pCurT,pRegnClnCln,ptOrigin);

			if (p3dEnt != NULL)
			{
				p3dEnt->setColorIndex(nColor);
				Add3DBuffer(p3dEnt);
			}
			delete pCurT;
		}
	}
	else
	{
		return dc.DrawPipe(pBaseCln1,pRegnCln,ptOrigin);
	}
	return NULL;
}

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

	AcCmTransparency tr = transparency();
	AcCmTransparency oldTr = dc.SetTransparency(tr);

	BOOL bVerDraw = FALSE;
	m_mapSpecXData.GetAt(KEY_VERDRAW,bVerDraw);
	if (bVerDraw)
	{
		//仅仅是立面二维符号表达,不创建三维
		return Acad::eOk;
	}

	////管线系统屏蔽掉
	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;
	}

	GuardBar bar;
	GetGuardBarData(bar);

	AcDbCurve* pBaseCln0 = (AcDbCurve*)m_pBaseCurve->clone();
	AcDbCurve* pBaseCln1 = (AcDbCurve*)m_pBaseCurve->clone();
	AcDbCurve* pBaseCln2 = (AcDbCurve*)m_pBaseCurve->clone();

	//有标高的线
	AcDbLine* pLnBase = AcDbLine::cast(pBaseCln0);
	if (pLnBase != NULL)
	{
		AcGeVector3d vtNorm = pLnBase->normal();

		AcGePoint3d ptSta,ptEnd;
		pLnBase->getStartPoint(ptSta);
		pLnBase->getEndPoint(ptEnd);

		//底
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
		{
			ptSta.z = bar.dBomEl;
			ptEnd.z = bar.dBomEl;

			pLnBase->setStartPoint(ptSta);
			pLnBase->setEndPoint(ptEnd);
		}

		//中
		ptSta.z += bar.dH1;
		ptEnd.z += bar.dH1;

		pLnBase = AcDbLine::cast(pBaseCln1);
		pLnBase->setStartPoint(ptSta);
		pLnBase->setEndPoint(ptEnd);

		//顶
		ptSta.z += (bar.dH - bar.dH1);
		ptEnd.z += (bar.dH - bar.dH1);

		pLnBase = AcDbLine::cast(pBaseCln2);
		pLnBase->setStartPoint(ptSta);
		pLnBase->setEndPoint(ptEnd);
	}

	AcDbPolyline* pPlBase = AcDbPolyline::cast(pBaseCln0);
	if (pPlBase != NULL)
	{
		AcGeVector3d vtNorm = pPlBase->normal();

		//底
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
		{
			pPlBase->setElevation(bar.dBomEl);

			AcDbPolyline* pPlBase1 = AcDbPolyline::cast(pBaseCln1);
			pPlBase1->setElevation(bar.dBomEl + bar.dH1);

			AcDbPolyline* pPlBase2 = AcDbPolyline::cast(pBaseCln2);
			pPlBase2->setElevation(bar.dBomEl + bar.dH);
		}
	}

	//底部管子段
	if (m_pRegion != NULL)
	{
		AcDbEntity* p3dEnt = NULL;
		AcDbRegion* pRegnCln = NULL;

		//底
		if ( !bar.bNoBomLever )
		{
			pRegnCln = (AcDbRegion*)m_pRegion->clone();
			if (pRegnCln != NULL)
			{
				p3dEnt = dc.DrawPipe(pBaseCln0,pRegnCln,AcGePoint3d::kOrigin);
				if (p3dEnt != NULL)
				{
					p3dEnt->setColorIndex(nColor);
					Add3DBuffer(p3dEnt);
				}
				delete pRegnCln;
				pRegnCln = NULL;
			}
		}

		//中
		pRegnCln = (AcDbRegion*)m_pRegion->clone();
		if (pRegnCln != NULL)
		{
			p3dEnt = dc.DrawPipe(pBaseCln1,pRegnCln,AcGePoint3d::kOrigin);
			if (p3dEnt != NULL)
			{
				p3dEnt->setColorIndex(nColor);
				Add3DBuffer(p3dEnt);
			}
			delete pRegnCln;
			pRegnCln = NULL;
		}

		//顶
		pRegnCln = (AcDbRegion*)m_pRegion->clone();
		if (pRegnCln != NULL)
		{
			p3dEnt = dc.DrawPipe(pBaseCln2,pRegnCln,AcGePoint3d::kOrigin);
			if (p3dEnt != NULL)
			{
				p3dEnt->setColorIndex(nColor);
				Add3DBuffer(p3dEnt);
			}
			delete pRegnCln;
			pRegnCln = NULL;
		}

		double dSta = 0.0,dEnd = 0.0;
		pBaseCln0->getStartParam(dSta);
		pBaseCln0->getEndParam(dEnd);

		double dL = 0.0;
		pBaseCln0->getDistAtParam(dEnd,dL);

		int nCol = (int)(dL / bar.dP + 0.5);
		double dSpa = (dEnd - dSta) / nCol;

		AcDbLine ln;
		AcGePoint3d ptPos,ptTop;
		for (int i = 0;i <= nCol;i++)
		{
			pBaseCln0->getPointAtDist(0.0 + i * bar.dP,ptPos);
			if (i == nCol)
			{
				pBaseCln0->getEndPoint(ptPos);
			}

			ptTop = ptPos;
			ptTop.z += bar.dH;

			ln.setStartPoint(ptPos);
			ln.setEndPoint(ptTop);

			pRegnCln = (AcDbRegion*)m_pRegion->clone();

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

			//然后绘制球 影响速度，暂时注掉2025711
			//底
			/*if (!bar.bNoBomLever)
			{
				p3dEnt = dc.DrawSphere(ptPos,bar.dD);//2 * r
				if (p3dEnt != NULL)
				{
					p3dEnt->setColorIndex(nColor);
					Add3DBuffer(p3dEnt);
				}
			}

			//中
			ptPos.z += bar.dH1;
			p3dEnt = dc.DrawSphere(ptPos,bar.dD);//2 * r
			if (p3dEnt != NULL)
			{
				p3dEnt->setColorIndex(nColor);
				Add3DBuffer(p3dEnt);
			}

			//顶
			p3dEnt = dc.DrawSphere(ptTop,bar.dD);//2 * r
			if (p3dEnt != NULL)
			{
				p3dEnt->setColorIndex(nColor);
				Add3DBuffer(p3dEnt);
			}*/
		}

		delete pBaseCln0;
		delete pBaseCln1;
		delete pBaseCln2;
	}
	return Acad::eOk;
	dc.SetTransparency(tr);
}

AcGePoint3d GetCurveMidPoint(AcDbCurve* pCurve)
{
	double dSta = 0.0,dEnd = 0.0;
	pCurve->getStartParam(dSta);
	pCurve->getEndParam(dEnd);

	AcGePoint3d pt;
	pCurve->getPointAtParam((dSta+dEnd) / 2.0,pt);

	return pt;
}

bool AecDbGuardBar::GetSectionDraw(AcGePlane& plan,const AcGeVector3d& vtTo,AcDbVoidPtrArray&  arRegionPtrs) const
{
	BOOL bVerDraw = FALSE;
	m_mapSpecXData.GetAt(KEY_VERDRAW,bVerDraw);

	if (bVerDraw)
	{
		acutPrintf(_T("\n二维栅格护栏不可剖切!"));
		return false;
	}

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

	AcGeVector3d vtNorm(0,0,1);
	AcDbVoidPtrArray arSubPtrs;
	AecDbGuardBar* pFit = (AecDbGuardBar *)clone();
	if (pFit != NULL)
	{
		GuardBar bar;
		GetGuardBarData(bar);

		//护栏必须是视图elevation 变量=0绘制
		AcDbPolyline* pPl = AcDbPolyline::cast(pFit->m_pBaseCurve);
		if (pPl != NULL)
		{
			vtNorm = pPl->normal();
			if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
			{
				pPl->setElevation(bar.dBomEl);
			}

			//裁剪
			AcDbXline xLn;
			AcGePoint3d ptOrg;
			AcGeVector3d vtX,vtY;
			plan.getCoordSystem(ptOrg,vtX,vtY);
			ptOrg.z = 0.0;

			AcGePoint3d pt1 = ptOrg;
			pt1.z = 0.0;
			pt1 += 1000.0 * vtX;
			pt1.z = 0.0;

			AcGeVector3d vt = pt1 - ptOrg;
			if (vt.isParallelTo(vtNorm))
			{
				pt1 = ptOrg;
				pt1 += 1000.0 * vtY;
				pt1.z = 0.0;
			}
			vt = pt1 - ptOrg;
		
			xLn.setBasePoint(ptOrg);
			xLn.setUnitDir(vt);

			AcGePoint3dArray arPts;
			pPl->intersectWith(&xLn,AcDb::kOnBothOperands,arPts);

			AcDbVoidPtrArray arCurPtrs;
			pPl->getSplitCurves(arPts,arCurPtrs);

			if (!arCurPtrs.isEmpty())
			{
				AcGeVector3d vtNm = vtTo;
				AcDbCurve* pCurv = NULL;

				AcDbRay ray;
				for (int i = 0;i < arCurPtrs.length();i++)
				{
					pCurv = (AcDbCurve*)arCurPtrs.at(i);

					pt1 = GetCurveMidPoint(pCurv);
					pt1 = pt1.orthoProject(plan);

					ray.setBasePoint(pt1);
					ray.setUnitDir(vtNm);

					arPts.removeAll();
					pCurv->intersectWith(&ray,AcDb::kOnBothOperands,arPts);

					if (!arPts.isEmpty())
					{
						AecDbGuardBar* pFitNew = (AecDbGuardBar *)clone();
						if (pFitNew != NULL)
						{
							pFitNew->SetBaseCurve(pCurv);

							pFitNew->transformBy(xform);

							pFitNew->GetSpecialtyData()->SetAt(KEY_VERDRAW,TRUE);

							AcGiViewDraw dc(NULL, NULL);
							pFitNew->Draw2d(dc);

							arSubPtrs.removeAll();
							pFitNew->GetDraw2dables(0,arSubPtrs);

							//标注DNXXX

							//去掉圆
							AcDbEntity* pSubEnt = NULL;
							for(int ii = 0;ii < arSubPtrs.length();ii++)
							{
								pSubEnt = (AcDbEntity*)arSubPtrs.at(ii);
								if (AcDbCircle::cast(pSubEnt ) == NULL)
								{
									arRegionPtrs.append(pSubEnt);
								}
							}
							delete pFitNew;

							//TEST
							//pCurv->setColorIndex(1);
							//AddToModelSpace(pCurv);
							//pCurv = NULL;
						}
					}

					if (pCurv != NULL) delete pCurv;
				}

				delete pFit;
				return true;
			}
		}

		pFit->transformBy(xform);

		AcGeVector3d vtNorm = plan.normal();
		if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
			pFit->GetSpecialtyData()->SetAt(KEY_VERDRAW,FALSE);
		else
			pFit->GetSpecialtyData()->SetAt(KEY_VERDRAW, TRUE);

		AcGiViewDraw dc(NULL, NULL);
		
		dc.SetDraw2DPlan(plan);
		pFit->Draw2d(dc);

		pFit->GetDraw2dables(0,arSubPtrs);

		//去掉圆
		AcDbEntity* pSubEnt = NULL;
		for(int i = 0;i < arSubPtrs.length();i++)
		{
			pSubEnt = (AcDbEntity*)arSubPtrs.at(i);
			if (AcDbCircle::cast(pSubEnt ) == NULL)
			{
				arRegionPtrs.append(pSubEnt);
			}
		}
		delete pFit;
	}
	return true;
}

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

	GuardBar bar;
	::memset(&bar, 0, sizeof(GuardBar));
	GetGuardBarData(bar);

	/*
	double dD;//管材直径
	double dt;//管材厚度
	double dBomEl;//底标高
	double dH1;//底部格高
	double dH;//扶手顶到底部高度
	double dP;//格间距
	BOOL   bNoBomLever;//没有底部杆件
	BOOL   bIsRectLever;//方杆件

	TCHAR  m_sMaterial[256];
	TCHAR  m_sFactory[256];//厂家
	TCHAR  m_sNo[256];
	*/
	addMember(v, _T("__dD__"), bar.dD);
	addMember(v, _T("__dt__"), bar.dt);
	addMember(v, _T("__dBomEl__"), bar.dBomEl);
	addMember(v, _T("__dH1__"), bar.dH1);
	addMember(v, _T("__dH__"), bar.dH);
	addMember(v, _T("__dP__"), bar.dP);

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

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

	return v;
}

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