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

extern double PixelToWcs(int nPixel);
extern BOOL Is2DView();
extern AcGeVector3d GetUcsZvt();
extern void PushGripMessage(GripMessage&);

extern void transfromRegion(AcDbRegion *pRegion, const AcGePoint3d &ptOnRegion, const AcGeVector3d &vtNormal, const AcGePoint3d &ptOnPlan);
extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
extern int GetOrthoProjectedCurve(AcDbRegion* pReg,AcGePlane& plan,AcDbVoidPtrArray& arCurPtrs,bool bMerge);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
extern DLLIMPEXP AcDbCurve* GetOffsetCurve(AcDbCurve* pCurve,double dOffset,bool bGetInSide);

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;

#ifndef GRIPPT_RESP_FROM_EWFIT
#define GRIPPT_RESP_FROM_EWFIT 1394
#endif

static AcGePoint3d Mid(AcGePoint3d& ptGe1,AcGePoint3d& ptGe2)
{
	return AcGePoint3d( (ptGe1.x + ptGe2.x) / 2.0,
		(ptGe1.y + ptGe2.y) / 2.0,
		(ptGe1.z + ptGe2.z) / 2.0);
}

static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
{
	AcDbEntity* pEnt = NULL;
	while(arEntPtrs.length() > n )
	{
		pEnt = (AcDbEntity*)arEntPtrs.last();
		if (pEnt != NULL)
		{
			pEnt->erase();
			pEnt->close();
			arEntPtrs.removeLast();
			DELETE_PTR(pEnt);
		}
	}
}

Adesk::UInt32 AecDbHvacDuct::kCurrentVersionNumber = 1;

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


AecDbHvacDuct::AecDbHvacDuct(void)
{
	m_mapSpecXData.SetAt(KEY_NAME,_T("风管"));
}

AecDbHvacDuct::~AecDbHvacDuct(void)
{
}

Acad::ErrorStatus AecDbHvacDuct::SetStartPoint(const AcGePoint3d& ptSta)
{
	AssertWriteEnabled();

	if (m_pBaseCurve == NULL)
		m_pBaseCurve = new AcDbLine;

	AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
	if (pLine != NULL)
	{
		pLine->setStartPoint(ptSta);
		return Acad::eOk;
	}
	return Acad::eInvalidInput;
}

AcGePoint3d AecDbHvacDuct::StartPoint() const
{
	assertReadEnabled();

	AcGePoint3d ptSta;
	getStartPoint(ptSta);

	return ptSta;
}

// 设置端点 如果是LINE管子
Acad::ErrorStatus AecDbHvacDuct::SetEndPoint(const AcGePoint3d& ptEnd)
{
	AssertWriteEnabled();

	if (m_pBaseCurve == NULL)
		m_pBaseCurve = new AcDbLine;

	AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
	if (pLine != NULL)
	{
		pLine->setEndPoint(ptEnd);
		return Acad::eOk;
	}
	return Acad::eInvalidInput;
}

AcGePoint3d AecDbHvacDuct::EndPoint() const
{
	assertReadEnabled();

	AcGePoint3d ptSta;
	getEndPoint(ptSta);

	return ptSta;
}

bool AecDbHvacDuct::SetDuctParam(const AecHvac::DuctParam* pData)
{
	AssertWriteEnabled();

	double dL = 0.0,dW = 0.0,dt = 0.0;
	double dD = 0.0;
	m_mapSpecXData.SetAt(HVAC_SectType,pData->eType);
	m_mapSpecXData.SetAt(KEY_MATERIAL,pData->szMat);
	m_mapSpecXData.SetAt(KEY_FACTORY,pData->szFat);
	m_mapSpecXData.SetAt(KEY_RRATIO,pData->m_dRatio);
	m_mapSpecXData.SetAt(KEY_FULLPER,pData->m_dFullPer);
	m_mapSpecXData.SetAt(KEY_SN,pData->szNo);
	m_mapSpecXData.SetAt(KEY_TYPE,pData->szType);
	m_mapSpecXData.SetAt(KEY_EXT,pData->szExt);
	m_mapSpecXData.SetAt(PIPE_SYS,pData->szSys);
	m_mapSpecXData.SetAt(KEY_COVER,pData->m_bCover);
	m_mapSpecXData.SetAt(KEY_SPART,pData->m_bSpart);
	
	m_mapSpecXData.SetAt(KEY_AirLoadUnit,pData->iALUnit);
	m_mapSpecXData.SetAt(KEY_AirLoad,pData->dAirload);

	m_mapSpecXData.SetAt(DV_AIRVOL,pData->m_dR);
	m_mapSpecXData.SetAt(DV_WAYRESIS,pData->m_dPy);
	m_mapSpecXData.SetAt(DV_VELOCITY,pData->m_dV);

	m_mapSpecXData.SetAt(KEY_CENNODRAW,!pData->m_bCenDraw);//中心线
	m_mapSpecXData.SetAt(KEY_REM,pData->szRem);
	m_mapSpecXData.SetAt(HVAC_FlowDirect,pData->m_nFlowDir);
	m_mapSpecXData.SetAt(HVAC_PlusEdge,pData->m_dPlusEdge);//咬口法兰翻边余量
	m_mapSpecXData.SetAt(KEY_NORMAL,pData->m_vtNrom);

	//设置标高
	//如果是水平管子
	AcGePoint3d ptS = StartPoint();
	AcGePoint3d ptE = EndPoint();
	AcGeVector3d vt = ptE - ptS;
	AcGeLine3d ln(ptS,vt);
	if (ln.isParallelTo(AcGePlane::kXYPlane))
	{
		SetElevation(pData->m_dEl);
	}

	switch(pData->eType)
	{
	case eRect:
		{
			dL = pData->dSize[0];
			dW = pData->dSize[1];
			dt = pData->dSize[2];

			if (dL > 1.e-6 && dW > 1.e-6 )
			{
				SetSection(dL,dW,dt);
				return true;
			}
			break;
		}
	case eCircle:
		{
			dD = pData->dSize[0];
			dt = pData->dSize[2];

			if (dD > 1.e-6 )
			{
				SetSection(dD,dt);
				return true;
			}
			break;
		}
	case eOblate:
		{
			break;
		}
	default:
		break;
	}
	return false;
}


void AecDbHvacDuct::SetElevation(double dEl)
{
	AssertWriteEnabled();

	AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
	if (pLine != NULL)
	{
		AcGePoint3d ptSta = pLine->startPoint();
		AcGePoint3d ptEnd = pLine->endPoint();

		if (fabs(ptSta.z - ptEnd.z) < 1.e-3)
		{
			ptSta.z = dEl;ptEnd.z = dEl;
			pLine->setStartPoint(ptSta);
			pLine->setEndPoint(ptEnd);
		}
	}
}

bool AecDbHvacDuct::IsArcDuct() const
{
	AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);
	if (pArc != NULL)
		return true;
	return false;
}

bool AecDbHvacDuct::IsVertical() const
{
	AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
	if (pLine != NULL)
	{
		AcGePoint3d ptSta = pLine->startPoint();
		AcGePoint3d ptEnd = pLine->endPoint();
		AcGeVector3d vt = ptEnd - ptSta;
		if (vt.isParallelTo(AcGeVector3d::kZAxis))
			return true;
	}
	return false;
}

void AecDbHvacDuct::UpdatePipeSystem(const int &outClr
	, const AcDbObjectId &outLt
	, const double &outWd
	, const AcDbObjectId &outLy
	, const int &innClr
	, const AcDbObjectId &innLt
	, const double &innWd
	, const AcDbObjectId &innLy)
{
	AssertWriteEnabled();
	// color
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_COLOR, innClr);//取反
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_COLOR_OUT, outClr);

	// line type
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINETYPE, innLt);
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINETYPE_OUT, outLt);

	// line width
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINEWIDTH, innWd);
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINEWIDTH_OUT, outWd);

	// line layer
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER, innLy);
	GetSpecialtyData(AcDb::kForWrite)->SetAt(PIPE_LINELAYER_OUT, outLy);

}

void AecDbHvacDuct::GetDuctParam(AecHvac::DuctParam& data) const
{
	assertReadEnabled();

	memset(&data,0,sizeof(AecHvac::DuctParam));

	int nType = 0;
	m_mapSpecXData.GetAt(KEY_SECSHAPE,nType);
	data.eType = (ESection)nType;

	ESection eType = (ESection)nType;
	switch(eType)
	{
	case eRect:
		{
			m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //L
			m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //w
			m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
			break;
		}
	case eCircle:
		{
			m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //D
			data.dSize[1] = 0.0;
			m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
			break;
		}
	case eOblate:
		{
			break;
		}
	default:
		break;
	}

	//假设是平行XY
	data.m_dEl = StartPoint().z;

	m_mapSpecXData.GetAt(KEY_NORMAL,data.m_vtNrom);

	data.m_dRatio = 1.0;
	m_mapSpecXData.GetAt(KEY_RRATIO,data.m_dRatio);
	if (data.m_dRatio < 1.e-2)
		data.m_dRatio = 1.0;

	m_mapSpecXData.GetAt(KEY_FULLPER,data.m_dFullPer);
	m_mapSpecXData.GetAt(HVAC_PlusEdge,data.m_dPlusEdge);//咬口法兰翻边余量
	m_mapSpecXData.GetAt(KEY_NORMAL,data.m_vtNrom);

	m_mapSpecXData.GetAt(KEY_AirLoadUnit,data.iALUnit);
	m_mapSpecXData.GetAt(KEY_AirLoad,data.dAirload);

	m_mapSpecXData.GetAt(DV_AIRVOL,data.m_dR);
	m_mapSpecXData.GetAt(DV_WAYRESIS,data.m_dPy);
	m_mapSpecXData.GetAt(DV_VELOCITY,data.m_dV);

	int nNDraw = 0;
	m_mapSpecXData.GetAt(KEY_CENNODRAW,nNDraw);//中心线
	data.m_bCenDraw = !nNDraw;

	data.m_nAlign = 1;//居中

	CString sTemp;
	m_mapSpecXData.GetAt(KEY_SN,sTemp);
	_tcscpy(data.szNo,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_TYPE,sTemp);
	_tcscpy(data.szType,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_EXT,sTemp);
	_tcscpy(data.szExt,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(HVAC_System,sTemp);
	_tcscpy(data.szSys,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(PIPE_SYS,sTemp);
	_tcscpy(data.szSys,(LPCTSTR)sTemp);

	m_mapSpecXData.GetAt(KEY_COVER,data.m_bCover);
	m_mapSpecXData.GetAt(KEY_SPART,data.m_bSpart);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
	_tcscpy(data.szMat,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_FACTORY,sTemp);
	_tcscpy(data.szFat,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(KEY_REM,sTemp);
	_tcscpy(data.szRem,(LPCTSTR)sTemp);

	sTemp = _T("");
	m_mapSpecXData.GetAt(PIPE_LEVEL,sTemp);
	_tcscpy(data.szLevel,(LPCTSTR)sTemp);
}

AcGeVector3d AecDbHvacDuct::GetNormal() const
{
	assertReadEnabled();

	AcGeVector3d vtNorm(0,0,1);
	m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
	if (vtNorm.isZeroLength())
	{
		AcGeVector3d vt = EndPoint() - StartPoint();
		AcGeLine3d ln(AcGePoint3d::kOrigin, vt);
		if (ln.isParallelTo(AcGePlane::kXYPlane))
			vtNorm.set(0, 0, 1);
		else
		{
			if (vt.isParallelTo(AcGeVector3d::kZAxis))
			{
				vtNorm = vt;
				vtNorm.rotateBy(GetSectionRotation(), AcGeVector3d::kZAxis);
			}
			else
			{
				vtNorm = vt.perpVector();
			}
		}
	}
	else
	{
		AcGeVector3d vt = EndPoint() - StartPoint();
		if (vtNorm.isParallelTo(vt))
		{
			//error 
			AcGeLine3d ln(AcGePoint3d::kOrigin, vt);
			if (ln.isParallelTo(AcGePlane::kXYPlane))
				vtNorm.set(0, 0, 1);
			else
			{
				if (vt.isParallelTo(AcGeVector3d::kZAxis))
				{
					vtNorm = vt;
					vtNorm.rotateBy(GetSectionRotation(), AcGeVector3d::kZAxis);
				}
				else
				{
					vtNorm = vt.perpVector();
				}
			}
		}
	}
	return vtNorm;
}

void AecDbHvacDuct::setNormal(const AcGeVector3d& vtNorm)
{
	assertWriteEnabled();
	m_mapSpecXData.SetAt(KEY_NORMAL,vtNorm);
}

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

	return pFiler->filerStatus();
}

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

	return pFiler->filerStatus();
}

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

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

#if ARX>16	

void AecDbHvacDuct::subList() const
{
	assertReadEnabled();
	AecDbEwPipeBase::subList();
}

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

	AecHvac::DuctParam data;
	memset(&data,0,sizeof(AecHvac::DuctParam));

	GetDuctParam(data);

	CString sField,sFmt;
	sField = _T("风管:\n");
	sInfoTip += sField;

	LPCTSTR pszAirload[] = {_T("kg/h"),_T("kg/s"),_T("m^3/h"),_T("m^3/s"),_T("L/h"),_T("L/s"),0};

	switch(data.eType)
	{
	case eRect:
		{
			MAKEFIELD(_T("矩形截面长"),_T("%.1f"),data.dSize[0],sInfoTip);
			MAKEFIELD(_T("矩形截面宽"),_T("%.1f"),data.dSize[1],sInfoTip);
			
			MAKEFIELD(_T("风管壁厚"),_T("%.1f"),data.dSize[2],sInfoTip);
			MAKEFIELD(_T("弯头曲率"),_T("%.1f"),data.m_dRatio,sInfoTip);
			MAKEFIELD(_T("卷边长度"),_T("%.1f"),data.m_dPlusEdge,sInfoTip);

			MAKEFIELD(_T("风量"),_T("%.1f"),data.dAirload,sInfoTip);
			MAKEFIELD(_T("单位"),_T("%s"),pszAirload[data.iALUnit],sInfoTip);

			MAKEFIELD(_T("管顶标高"),_T("%.1f"),data.m_dEl + 0.5 * data.dSize[1],sInfoTip);

			MAKEFIELD(_T("风速"),_T("%.2f"),data.m_dV,sInfoTip);
			MAKEFIELD(_T("比摩阻"),_T("%.2f"),data.m_dR,sInfoTip);
			MAKEFIELD(_T("沿层阻力"),_T("%.2f"),data.m_dPy,sInfoTip);

			MAKEFIELD(_T("类型"),_T("%s"),data.szType,sInfoTip);
			MAKEFIELD(_T("材料"),_T("%s"),data.szMat,sInfoTip);

			MAKEFIELD(_T("编号"),_T("%s"),data.szNo,sInfoTip);
			MAKEFIELD(_T("厂家"),_T("%s"),data.szFat,sInfoTip);

			break;
		}
	case eCircle:
		{
			MAKEFIELD(_T("截面直径"),_T("%.1f"),data.dSize[0],sInfoTip);

			MAKEFIELD(_T("风管壁厚"),_T("%.1f"),data.dSize[2],sInfoTip);
			MAKEFIELD(_T("弯头曲率"),_T("%.1f"),data.m_dRatio,sInfoTip);
			MAKEFIELD(_T("卷边长度"),_T("%.1f"),data.m_dPlusEdge,sInfoTip);

			MAKEFIELD(_T("风量"),_T("%.1f"),data.dAirload,sInfoTip);
			MAKEFIELD(_T("单位"),_T("%s"),pszAirload[data.iALUnit],sInfoTip);

			MAKEFIELD(_T("管顶标高"),_T("%.1f"),data.m_dEl + 0.5 * data.dSize[1],sInfoTip);

			MAKEFIELD(_T("风速"),_T("%.2f"),data.m_dV,sInfoTip);
			MAKEFIELD(_T("比摩阻"),_T("%.2f"),data.m_dR,sInfoTip);
			MAKEFIELD(_T("沿层阻力"),_T("%.2f"),data.m_dPy,sInfoTip);

			MAKEFIELD(_T("类型"),_T("%s"),data.szType,sInfoTip);
			MAKEFIELD(_T("材料"),_T("%s"),data.szMat,sInfoTip);

			MAKEFIELD(_T("编号"),_T("%s"),data.szNo,sInfoTip);
			MAKEFIELD(_T("厂家"),_T("%s"),data.szFat,sInfoTip);

			break;
		}
	default:
		break;
	}
	return true;
}

EPosition AecDbHvacDuct::ExplainGripIndex(int nIndex) const
{
	EPosition ePos = eStart;
	switch(nIndex)
	{
	case 0:
		{
			ePos = eStart;
			break;
		}
	case 1:
		{
			ePos = eMid;
			break;
		}
	case 2:
		{
			ePos = eEnd;
			break;
		}
	case 3:
		{
			ePos = eCommand0;
			break;
		}
	case 4:
		{
			ePos = eCommand1;
			break;
		}
	case 5:
		{
			ePos = eCommand2;
			break;
		}
	default:
		break;
	}
	return ePos;
}

Acad::ErrorStatus AecDbHvacDuct::ImpGetGripPonts(AcGePoint3dArray& gripPoints,const int bitflags) const
{
	assertReadEnabled();

	const int nStbitflags = GRIPPT_RESP_FROM_EWFIT;
	if (m_pBaseCurve != NULL)
	{
		AcGePoint3d ptSta,ptEnd;
		m_pBaseCurve->getStartPoint(ptSta);
		m_pBaseCurve->getEndPoint(ptEnd);

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

		AcGeVector3d vtDir = ptEnd - ptSta;
		vtDir.normalize();

		AcGePoint3d ptMid;
		m_pBaseCurve->getPointAtParam((dSta + dEnd) / 2.0,ptMid);

		gripPoints.append(ptSta);
		gripPoints.append(ptMid);
		gripPoints.append(ptEnd);

		if (bitflags == nStbitflags)
			return Acad::eOk;

		AcGeVector3d vtPerv = vtDir.perpVector();
		AcGeVector3d vtNorm = vtDir.crossProduct(vtPerv);
		vtNorm.normalize();

		AcGePoint3d ptGe[4];
		AcGeVector3d vtLine = ptEnd - ptSta;
		vtLine.normalize();

		AcGeVector3d vtVer = vtLine;
		vtVer.normalize();
		vtVer.rotateBy(PI / 2.0,vtNorm);

		//增加三个命令夹点
		AcGePoint3d ptCmd[3]; //Cmd 0,1
		vtLine.normalize();

		//按 15 个像素点
		double dCmd = PixelToWcs(15);

		if (vtLine.isParallelTo(AcGeVector3d::kZAxis))//立管
		{
			vtLine = AcGeVector3d::kXAxis;

			ptCmd[0] = ptSta - dCmd * vtLine;
			ptCmd[1] = ptEnd + dCmd * vtLine;
			ptCmd[2] = ptMid + dCmd * AcGeVector3d::kYAxis;
		}
		else
		{
			ptCmd[0] = ptSta - dCmd * vtLine;
			ptCmd[1] = ptEnd + dCmd * vtLine;
			ptCmd[2] = ptMid + dCmd * vtVer; 
		}

		gripPoints.append(ptCmd[0]);
		gripPoints.append(ptCmd[1]);
		gripPoints.append(ptCmd[2]);

		//后面的是断管符号
		//断管符号
		AcGePoint3d ptGeBK,ptGeT;
		CString sIndex;
		for(int i = 0;i < PIPE_BROKENNUM;i++)
		{
			sIndex.Format(_T("BKOP%d"),i);
			if (m_mapSpecXData.GetAt(sIndex,ptGeBK))
			{
				//开始
				ptGeT = ptSta + vtDir * ptGeBK.x;
				gripPoints.append(ptGeT);

				//中间
				ptGeT += vtDir * ptGeBK.y * 0.5;
				gripPoints.append(ptGeT);

				//结束
				ptGeT += vtDir * ptGeBK.y * 0.5;
				gripPoints.append(ptGeT);
			}
		}
	}
	return Acad::eOk;
}

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

	if (m_pBaseCurve != NULL)
	{
		AcGePoint3dArray gripPoints;
		ImpGetGripPonts(gripPoints,bitflags);

		int nColor = kWhite;
		AcDbGripData* pGripData = NULL;
		if ( bitflags >= 1394)
		{
			memset(&m_pGripAppData[0],0,sizeof(AecGripData));
			m_pGripAppData[0].nIndex = 0;
			m_pGripAppData[0].ePos = eFlag;
			m_pGripAppData[0].nColor = nColor;
			m_pGripAppData[0].ptGrip = gripPoints.at(0);
			m_pGripAppData[0].pOwner = (AcDbEntity*)this;

			pGripData = new AcDbGripData;
			pGripData->setGripPoint(gripPoints.at(0));
			pGripData->setAppData((void*)&m_pGripAppData[0]);
			pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
			pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
			_tcscpy(m_pGripAppData[0].szTip,_T("点击定位造族<风管>记录"));
			_tcscpy(m_pGripAppData[0].szID,m_sGUID);
			grips.append(pGripData);
			return Acad::eOk;
		}

		CString sCmd = _T("EW_HZFG");//绘制管道		
		EPosition ePos;
		for (int i = 0;i < GRIP_MAXNUM && i < gripPoints.length();i++)
		{
			ePos = ExplainGripIndex(i);
			if (ePos >= eCommand0 && ePos <= eCommand19)
			{
				memset(&m_pGripAppData[i],0,sizeof(AecGripData));
				m_pGripAppData[i].nIndex = i;
				m_pGripAppData[i].ePos = ePos;
				m_pGripAppData[i].nColor = nColor;
				m_pGripAppData[i].ptGrip = gripPoints.at(i);
				_tcscpy(m_pGripAppData[i].szTip,sCmd);
				_tcscpy(m_pGripAppData[i].szID,m_sGUID);
				m_pGripAppData[i].pOwner = (AcDbEntity*)this;
				m_pGripAppData[i].idHost = this->objectId();

				pGripData = new AcDbGripData;
				pGripData->setGripPoint(gripPoints.at(i));
				pGripData->setAppData((void*)&m_pGripAppData[i]);
				pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
				pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
			}
			else
			{
				memset(&m_pGripAppData[i],0,sizeof(AecGripData));
				m_pGripAppData[i].nIndex = i;
				m_pGripAppData[i].ePos = ePos;
				m_pGripAppData[i].nColor = nColor;
				m_pGripAppData[i].ptGrip = gripPoints.at(i);
				_tcscpy(m_pGripAppData[i].szTip,_T("风管拉伸夹点"));
				_tcscpy(m_pGripAppData[i].szID,m_sGUID);
				m_pGripAppData[i].pOwner = (AcDbEntity*)this;
				m_pGripAppData[i].idHost = this->objectId();

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

		//调用基类加入单击修改
		SubAddHitEditGrip(grips);
	}
	return Acad::eOk;
}

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

	AecGripData* pAppData = NULL;
	AcDbIntArray arIndex;

	if (HitOnGripEdit(gripAppData))
	{
		return Acad::eOk;
	}

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

	int nGripIndex = arIndex.first();
	EPosition ePos = ExplainGripIndex(nGripIndex);

	bool bMsgSendToAllInfs = false;
	AcGeVector3d vtOffset = offset;
	if(Is2DView())//如果是2D视图
	{
		//投影到XY
		vtOffset = offset.orthoProject(GetUcsZvt());

		AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
		if (pLn != NULL)
		{
			//小于10度的按照投影处理
			//在夹角小于10度，认为是橡皮筋拉伸
			AcGeVector3d vtLn = pLn->endPoint() - pLn->startPoint();
			if (ePos == eStart || ePos == eEnd)
			{
				double dAngle = vtOffset.angleTo(vtLn);
				dAngle *= 180.0 / PI;
				//acutPrintf(_T("\nAngle = %g"),dAngle);
				if ( ( (dAngle - 10.0 ) < 1.e-6 ) || 
					( (180.0 - dAngle - 10.0 ) < 1.e-6) )
				{
					//认为是橡皮筋拉伸
					AcGeVector3d vtNorm = vtLn;
					vtNorm.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

					AcGeVector3d vtOffsetOnLn = vtOffset.orthoProject(vtNorm);
					vtOffsetOnLn.normalize();
					vtOffsetOnLn *= vtOffset.length();
					vtOffset = vtOffsetOnLn;

					//仅仅本端口
					bMsgSendToAllInfs = false;
				}
				else
				{
					bMsgSendToAllInfs = true;					
				}
			}
			else if (ePos == eMid)
			{
				AcGeVector3d vtNorm = vtLn;
				vtLn.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

				double dAngle = vtOffset.angleTo(vtLn);
				dAngle *= 180.0 / PI;

				//acutPrintf(_T("\nAngle = %g"),dAngle);
				if ( ( (dAngle - 10.0 ) < 1.e-6 ) || 
					( (180.0 - dAngle - 10.0 ) < 1.e-6) )
				{
					//认为是橡皮筋拉伸
					AcGeVector3d vtOffsetOnLn = vtOffset.orthoProject(vtNorm);
					vtOffsetOnLn.normalize();
					vtOffsetOnLn *= vtOffset.length();
					vtOffset = vtOffsetOnLn;
				}
			}
		}
	}

	AcGeMatrix3d xformM;
	xformM.setToTranslation(vtOffset);

	if (nGripIndex > 5) //断管符号移动
	{
		nGripIndex -= 6;
		return moveGripBrokenOpen(nGripIndex,offset);
	}

	GripMessage msg;
	memset(&msg,0,sizeof(GripMessage));
	//reset
	msg.nSegindex = -1;
	msg.nType = -1;
	msg.idHost.setNull();
	msg.pParam = 0;
	msg.nData = -1;
	_tcscpy(msg.szLockId, _T("0"));//锁定id,如果有
	msg.fData = 0;
	msg.nSegindex = 0;
	msg.nSubSegIndex = 0;
	msg.vtOffset.set(0,0,0);
	msg.ptGrip.set(0,0,0);

	AecInterface inf;
	switch (ePos)
	{
	case eStart:
		{
			TransformAssocInf(0,xformM);

			msg.nType = ePos;
			msg.nData = bMsgSendToAllInfs ? -1 : 0;//控制消息源
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			break;
		}
	case eEnd:
		{
			TransformAssocInf(1,xformM);

			msg.nType = ePos;
			msg.nData = bMsgSendToAllInfs ? -1 : 1;//控制消息源
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			break;
		}
	case eMid:
		{
			TransformBy(xformM);

			msg.nType = ePos;
			msg.nData = -1;
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			break;
		}
	case eCommand0:
		{
			msg.nType = eCommand0;
			msg.nData = 0;
			GetInterface(msg.nData,inf);
			msg.ptGrip = inf.ptPos;
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			CString sCmd = GetGripCmd();
			if (!sCmd.IsEmpty())
			{
				acedPostCommand(_T("\x03"));
				sCmd += _T("\n");
				acedPostCommand(sCmd);
			}
			break;
		}
	case eCommand1:
		{
			msg.nType = eCommand1;
			msg.nData = 1;
			GetInterface(msg.nData,inf);
			msg.ptGrip = inf.ptPos;
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			CString sCmd = GetGripCmd();
			if (!sCmd.IsEmpty())
			{
				acedPostCommand(_T("\x03"));
				sCmd += _T("\n");
				acedPostCommand(sCmd);
			}
			break;
		}
	case eCommand2:
		{
			msg.nType = eCommand0;
			msg.nData = 0;//按0接口
			msg.ptGrip = pAppData->ptGrip;
			msg.idHost = pAppData->idHost;
			msg.vtOffset = vtOffset;

			PushGripMessage(msg);

			CString sCmd = GetGripCmd();
			if (!sCmd.IsEmpty())
			{
				acedPostCommand(_T("\x03"));
				sCmd += _T("\n");
				acedPostCommand(sCmd);
			}
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbHvacDuct::moveGripBrokenOpen(int nBrokenGrip,const AcGeVector3d& offset)
{
	AssertWriteEnabled();
	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();
	AcDbLine ln(ptSta,ptEnd);

	AcGeVector3d vtDir = ptEnd - ptSta;
	vtDir.normalize();

	int nBrokenindex = nBrokenGrip / 3;
	int nBrokenHit = nBrokenGrip % 3;

	//断管符号
	double dLen;
	AcGePoint3d ptGeT,ptGeBK,ptGe1,ptGe2,ptGe3;
	AcGePoint3dArray arPoints;
	CString sIndex;

	for(int i = 0;i < PIPE_BROKENNUM;i++)
	{
		sIndex.Format(_T("BKOP%d"),i);
		if (m_mapSpecXData.GetAt(sIndex,ptGeBK))
		{
			if (nBrokenindex == i)
			{
				//开始
				ptGe1 = ptSta + vtDir * ptGeBK.x;

				//中间
				ptGe2 = ptGe1 + vtDir * ptGeBK.y * 0.5;

				//结束
				ptGe3 = ptGe2 + vtDir * ptGeBK.y * 0.5;

				switch(nBrokenHit)
				{
				case 0: //改长度和断开长度
					{
						ptGe1 += offset;
						ln.getClosestPointTo(ptGe1,ptGe1);

						ptGeBK.x = ptGe1.distanceTo(ptSta);
						if (ptGeBK.x - ptSta.distanceTo(ptEnd) > 1.e-10)
						{
							//超出算删除
							m_mapSpecXData.RemoveAt(sIndex);
							return Acad::eOk;
						}

						ptGeBK.y = ptGe3.distanceTo(ptGe1);
						m_mapSpecXData.SetAt(sIndex,ptGeBK);

						break;
					}
				case 1: // 改长度
					{
						ptGe1 += offset;
						ln.getClosestPointTo(ptGe1,ptGe1);

						dLen = ptGe3.distanceTo(ptSta);
						if (dLen - ptSta.distanceTo(ptEnd) > 1.e-10)
						{
							//超出算删除
							m_mapSpecXData.RemoveAt(sIndex);
							return Acad::eOk;
						}

						ptGeBK.x = ptGe1.distanceTo(ptSta);
						m_mapSpecXData.SetAt(sIndex,ptGeBK);
						break;
					}
				case 2://改断开长度
					{
						ptGe3 += offset;
						ln.getClosestPointTo(ptGe3,ptGe3);

						dLen = ptGe3.distanceTo(ptSta);
						if (dLen - ptSta.distanceTo(ptEnd) > 1.e-10)
						{
							//超出算删除
							m_mapSpecXData.RemoveAt(sIndex);
							return Acad::eOk;
						}

						dLen = ptGe3.distanceTo(ptGe1);
						ptGeBK.y = dLen;
						m_mapSpecXData.SetAt(sIndex,ptGeBK);

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

void AecDbHvacDuct::GetGripText(int nPos, CString& sText)
{
	sText = _T("夹点");
}

#endif

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

	Acad::ErrorStatus es = AecDbEwPipeBase::Draw2d(dc);

	return es;
}

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

	Acad::ErrorStatus es = AecDbEwPipeBase::Draw3d(dc);

	FreeBuffer(0,m_arDrawBuffer3d2);

	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();

	AcGeVector3d vtDir = EndPoint() - StartPoint();
	vtDir.normalize();

	Adesk::Int16 nCr = dc.GetColor();

	if (IsActive())
	{
		AcDbEntity* p3dEnt = NULL;
		double dOD = 0.0;
		if (m_mapSpecXData.GetAt(KEY_SIZE1,dOD))
		{
			dc.SetColor(kMagenta);
			p3dEnt = dc.DrawPipe(ptSta,ptEnd,0.5 * dOD,0.0);
			if (p3dEnt != NULL)
			{
				DrawSubAxis(dc,p3dEnt);
				m_arDrawBuffer3d2.append(p3dEnt);
			}
		}
	}

	AcGePoint3d ptGeFr,ptGeTo;
	if (m_bShowFlowDir)//流向
	{
		dc.SetColor(kMagenta);//kMagenta

		vtDir.normalize();
		vtDir *= PixelToWcs(30);

		//clinder
		ptGeFr = Mid(ptSta,ptEnd);
		ptGeTo = ptGeFr + vtDir;

		double dDn = 0.0;
		m_mapSpecXData.GetAt(KEY_SIZE1,dDn);

		ptGeFr.z += 1.1 * dDn;
		ptGeTo.z += 1.1 * dDn;
		AcDbEntity* p3d = dc.DrawCone(ptGeFr,PixelToWcs(1),ptGeTo,PixelToWcs(1));
		if (p3d != NULL)
		{
			m_arDrawBuffer3d2.append(p3d);
		}

		//arrow
		ptGeFr = ptGeTo;
		vtDir.normalize();
		ptGeTo += vtDir * PixelToWcs(15);
		p3d = dc.DrawCone(ptGeFr,PixelToWcs(5),ptGeTo,1.e-3);
		if (p3d != NULL)
		{
			m_arDrawBuffer3d2.append(p3d);
		}
	}
	dc.SetColor(nCr);

	return Acad::eOk;
}

bool AecDbHvacDuct::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	AcArray<AecInterface> arInf;
	GetInterface(arInf);

	if (nInf > -1 && nInf < arInf.length() )
	{
		AecInterface& inf = arInf.at(nInf);

		AcGePoint3d ptGe = inf.ptPos;
		ptGe.transformBy(xform);

		AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
		if (pLine != NULL)//直管
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLine->startPoint();
			ptEnd = pLine->endPoint();
			AcGeVector3d vtL = ptEnd - ptSta;

			if (inf.ptPos.distanceTo(ptSta) < 1.e-3)
			{
				pLine->setStartPoint(ptGe);//新位置z

				AcGeVector3d vtL2 = ptEnd - ptGe;
				if (!vtL2.isParallelTo(vtL))
				{
					ptEnd.transformBy(xform);
					pLine->setEndPoint(ptEnd);
					return true;//继续发消息
				}
				return false;//不再继续发消息
			}

			if (inf.ptPos.distanceTo(ptEnd) < 1.e-3)
			{
				pLine->setEndPoint(ptGe);//新位置

				AcGeVector3d vtL2 = ptGe - ptSta;
				if (!vtL.isParallelTo(vtL2))
				{
					ptSta.transformBy(xform);
					pLine->setStartPoint(ptSta);
					return true;//继续发消息
				}
				return false;//不再继续发消息
			}
		}

		AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);//弧管
		if (pArc != NULL)
		{
			AcGePoint3d ptSta,ptEnd,ptMid;
			pArc->getStartPoint(ptSta);
			pArc->getEndPoint(ptEnd);

			double dSta = 0.0,dEnd = 0.0;
			pArc->getStartParam(dSta);
			pArc->getEndParam(dEnd);
			double dMid = (dSta + dEnd) / 2.0;
			pArc->getPointAtParam(dMid,ptMid);

			if (inf.ptPos.distanceTo(ptSta) < 1.e-3)
			{
				AcDbArc* pArc2 = KTCADUtilityEx::FormatArc(ptGe,ptMid,ptEnd);
				if (pArc2 != NULL)
				{
					pArc->setStartAngle(pArc2->startAngle());
					pArc->setEndAngle(pArc2->endAngle());
					pArc->setCenter(pArc2->center());
					pArc->setRadius(pArc2->radius());
					DELETE_PTR(pArc2);
				}
				return false;//不在继续发消息
			}

			if (inf.ptPos.distanceTo(ptEnd) < 1.e-3)
			{
				AcDbArc* pArc2 = KTCADUtilityEx::FormatArc(ptSta,ptMid,ptGe);
				if (pArc2 != NULL)
				{
					pArc->setStartAngle(pArc2->startAngle());
					pArc->setEndAngle(pArc2->endAngle());
					pArc->setCenter(pArc2->center());
					pArc->setRadius(pArc2->radius());
					DELETE_PTR(pArc2);
				}
				return false;//不在继续发消息
			}
		}
	}
	return false;
}

LPCTSTR	AecDbHvacDuct::GetGripCmd() const
{
	assertReadEnabled();
	return _T("HA_ductadd");
}

bool AecDbHvacDuct::GetSectionDraw(AcGePlane& plan,const AcGeVector3d& vtTo,AcDbVoidPtrArray&  arRegionPtrs) const
{
	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	AcDbVoidPtrArray arSubPtrs;
	AecDbHvacDuct* pFit = (AecDbHvacDuct *)clone();
	if (pFit != NULL)
	{
		pFit->transformBy(xform);

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

		pFit->GetDraw2dables(0,arSubPtrs);

		arRegionPtrs.append(arSubPtrs);
		delete pFit;
	}
	return true;
}

SHJson::WValue &AecDbHvacDuct::ToJson(bool bExprotGeo) const
{
	assertReadEnabled();
	return AecDbEwPipeBase::ToJson(bExprotGeo);
}

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

Acad::ErrorStatus AecDbHvacDuct::DrawFlangInf3d(AcGiDraw &dc) const
{
	assertReadEnabled();

	int nSection = 0;
	m_mapSpecXData.GetAt(KEY_SECSHAPE,nSection);

	double dAng = GetSectionRotation();

	//临时绘制一个板
	//方板或圆板
	double dPlusEdge = 0.0;
	GetSpecialtyData()->GetAt(HVAC_PlusEdge, dPlusEdge);

	if (dPlusEdge < 1.e-3)
		return Acad::eOk;

	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();

	AcGeVector3d vt = ptEnd - ptSta;
	vt.normalize();
	AcGeLine3d ln3d(AcGePoint3d::kOrigin,vt);

	AecHvac::DuctParam data;
	memset(&data,0,sizeof(AecHvac::DuctParam));
	GetDuctParam(data);

	double dL = data.dSize[2];
	data.dSize[2] += dPlusEdge;

	AecDbHvacDuct ductTmp;
	if (nSection == eRect)
	{
		data.m_dPlusEdge = 0.0;
		data.dSize[0] += 2.0 * dPlusEdge;
		data.dSize[1] += 2.0 * dPlusEdge;
	}
	else if (nSection == eCircle)
	{
		data.m_dPlusEdge = 0.0;
		data.dSize[0] += 2.0 * dPlusEdge;
		data.dSize[1] += 2.0 * dPlusEdge;
	}
	 
	AcGePoint3d ptS,ptE;
	ptE = ptEnd;
	ptS = ptE - vt * dL;//厚度

	ductTmp.SetStartPoint(ptS);
	ductTmp.SetEndPoint(ptE);
	
	ductTmp.SetDoubleLayer((AcDbObjectId&)m_idDoubleLayer);
	ductTmp.SetCenterLayer((AcDbObjectId&)m_idCenterLayer);
	ductTmp.setLayer(layerId());
	ductTmp.SetDuctParam(&data);
	ductTmp.SetSectionRotation(dAng);
	ductTmp.Draw3d(dc);

	Add3DBuffer(ductTmp.Get3DBuffer());
	ductTmp.Clean3DBufferNoDel();

	ptS = ptSta;
	ptE = ptS + vt * dL;//厚度

	ductTmp.SetStartPoint(ptS);
	ductTmp.SetEndPoint(ptE);
	
	ductTmp.SetDuctParam(&data);
	ductTmp.Draw3d(dc);

	Add3DBuffer(ductTmp.Get3DBuffer());
	ductTmp.Clean3DBufferNoDel();

	return Acad::eOk;
}

Acad::ErrorStatus AecDbHvacDuct::DrawFlangInf2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	//绘制两头竖线
	double dPlusEdge = 0.0;
	GetSpecialtyData()->GetAt(HVAC_PlusEdge, dPlusEdge);

	if (dPlusEdge < 1.e-3)
		return Acad::eOk;

	AcGePoint3d ptSta = StartPoint();
	AcGePoint3d ptEnd = EndPoint();

	AcGeVector3d vt = ptEnd - ptSta;
	AcGeLine3d ln3d(AcGePoint3d::kOrigin,vt);

	AecHvac::DuctParam param;
	memset(&param,0,sizeof(AecHvac::DuctParam));
	GetDuctParam(param);

	if (ln3d.isParallelTo(AcGePlane::kXYPlane))//水平
	{
		AcGeVector3d vtV = vt;
		vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		vtV.normalize();

		AcGePoint3d ptGe[2];
		ptGe[0] = ptSta + vtV * ( 0.5 * param.dSize[0] + dPlusEdge);
		ptGe[1] = ptSta - vtV * ( 0.5 * param.dSize[0] + dPlusEdge);

		AcDbLine* pLn = new AcDbLine(ptGe[0],ptGe[1]);
		pLn->setLayer(layerId());
		dc.DrawEntity(pLn);
		Add2DBuffer(pLn);

		ptGe[0] = ptEnd + vtV * ( 0.5 * param.dSize[0] + dPlusEdge);
		ptGe[1] = ptEnd - vtV * ( 0.5 * param.dSize[0] + dPlusEdge);
		pLn = new AcDbLine(ptGe[0],ptGe[1]);
		pLn->setLayer(layerId());
		dc.DrawEntity(pLn);
		Add2DBuffer(pLn);
	}
	else
	{
		//垂直,只绘制截面
		int nSection = 0;
		m_mapSpecXData.GetAt(KEY_SECSHAPE,nSection);

		AcGeVector3d vtNorm;
		m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
		vtNorm.normalize();

		double dAngle = GetSectionRotation();

		AcGeLine3d ln3d2(AcGePoint3d::kOrigin,vtNorm);
		if (ln3d2.isParallelTo(AcGePlane::kXYPlane))
		{
			//old code 2022-2-24
			AcGeVector3d vtV = vtNorm;
			vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

			AcGePoint3d ptGe[5];
			if (nSection == eRect)
			{
				AcGePoint3d ptSta;
				AcGeMatrix3d xformMove;
				m_pBaseCurve->getStartPoint(ptSta);
				ptSta.z = 0.0;

				AcGePoint3d ptCen;
				m_mapSpecXData.GetAt(KEY_SECCEN,ptCen);

				//移到sta位置
				AcGeVector3d vtM = ptSta - ptCen;
				xformMove.setToTranslation(vtM);

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

				AcDbVoidPtrArray arCurPtrs,arRes;

				AcGeMatrix3d xformR;
				xformR.setToRotation(dAngle,AcGeVector3d::kZAxis);

				pRegCln->transformBy(xformR);
				pRegCln->transformBy(xformMove);
				pRegCln->explode(arCurPtrs);

				delete pRegCln;

				AcDbCurve* pCur = KTCADUtilityEx::ConvertBoundCurve(arCurPtrs,arRes);
				if (pCur != NULL)
				{
					AcDbPolyline* pPl = AcDbPolyline::cast(pCur);
					if (pPl != NULL)
					{
						pPl->setClosed(Adesk::kTrue);
						AcDbCurve* pPlNew = GetOffsetCurve(pPl,dPlusEdge,false);
						if (pPlNew != NULL)
						{
							pPlNew->setLayer(m_idDoubleLayer);
							dc.DrawEntity(*pPlNew);
							Add2DBuffer(pPlNew);
						}
					}
					delete pCur;
				}

				/*ptGe[0] = ptSta;
				ptGe[0] += (0.5 * param.dSize[1] + dPlusEdge) * vtNorm; //H方向
				ptGe[0] += (0.5 * param.dSize[0] + dPlusEdge) * vtV;

				ptGe[1] = ptGe[0] - vtV * (param.dSize[0] + 2.0 * dPlusEdge);
				ptGe[2] = ptGe[1] - vtNorm * (param.dSize[1] + 2.0 * dPlusEdge);
				ptGe[3] = ptGe[0] - vtNorm * (param.dSize[1] + 2.0 * dPlusEdge);

				ptGe[4] = ptGe[0];
				
				AcGeMatrix3d xforR;
				xforR.setToRotation(dAng,AcGeVector3d::kZAxis,ptSta);
				for (int ii = 0;ii < 5;ii++)
				{
					ptGe[ii].transformBy(xforR);
				}

				AcDbPolyline* pPl = FormatPolyline(ptGe,5);
				if (pPl != NULL)
				{
					pPl->setLayer(m_idDoubleLayer);
					dc.DrawEntity(*pPl);
					Add2DBuffer(pPl);
				}*/
			}
			else if (nSection == eCircle)
			{
				AcDbCircle* pCir = new AcDbCircle;
				pCir->setCenter(ptSta);
				pCir->setRadius(0.5 * param.dSize[0] + dPlusEdge);
				pCir->setNormal(AcGeVector3d::kZAxis);
				pCir->setLayer(m_idDoubleLayer);

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

Acad::ErrorStatus AecDbHvacDuct::CheckBrokenOpen()
{
	return Acad::eOk;
}

int AecDbHvacDuct::ComparedTo(AecDbCurveBase* pCurOther) const
{
	assertReadEnabled();

	AecDbHvacDuct* pPipeOther = AecDbHvacDuct::cast(pCurOther);
	if (pPipeOther != NULL)
	{
		AecHvac::DuctParam dpThis;
		GetDuctParam(dpThis);

		AecHvac::DuctParam dpThat;
		pPipeOther->GetDuctParam(dpThat);

		if (dpThis.eType != dpThat.eType)
			return 1;

		if ( fabs(dpThis.dSize[0] - dpThat.dSize[0]) > 0.1)
			return 1;

		if ( fabs(dpThis.dSize[1] - dpThat.dSize[1]) > 0.1)
			return 1;

		if ( fabs(dpThis.dSize[2] - dpThat.dSize[2]) > 0.1)
			return 1;

		if ( fabs(dpThis.m_dEl - dpThat.m_dEl) > 0.1)
			return 1;

		AcGePoint3d ptSta,ptEnd;
		getStartPoint(ptSta);
		getEndPoint(ptEnd);

		AcGePoint3d ptSta2,ptEnd2;
		pPipeOther->getStartPoint(ptSta2);
		pPipeOther->getEndPoint(ptEnd2);

		if (ptSta.distanceTo(ptSta2) > 2.0)//误差2毫米
			return 1;

		if (ptEnd.distanceTo(ptEnd2) > 2.0)//误差2毫米
			return 1;
	}
	return 0;
}

#include "HlrCutOption.h"
void AecDbHvacDuct::ProcessHlrResult(const AcArray<AcDbEntity *> &ar, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr, AcArray<AcDbEntity *> &output) const
{
	double dW;
	HlrCutOption::ProcessHlrResult(this
		, HlrCutOption::getHlrLW_HvacSys(dW)
		, dW
		, FALSE
		, ar
		, preAr
		, output);
}