// DbDuct.cpp: implementation of the TDbDuct class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DbDuct.h"
#include "PipePrototype.h"
#include "DbPipe.h"
#include "DbDoubleLinePipe.h"

#include "PipeTools.h"
#include "DbPipeLabel.h"
#include "DbPipeValve.h"
#include "HDbEquipment.h"

#include "GlobalFunction.h"
#include "TDbDuctNode.h"

ACRX_DXF_DEFINE_MEMBERS(ATSDuct, ATSPipePrototype, AcDb::kDHL_CURRENT,
                        AcDb::kMReleaseCurrent, 1, ATS_VENTPIPE,
						"ATS_VENTPIPE图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbDuct);

// sg modify 2008-1-14
// const Adesk::UInt8 TDbDuct::g_nVersion = 1; // 7.5
const Adesk::UInt8 TDbDuct::g_nVersion = 2;    // 7.6



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
TDbDuct::TDbDuct():
m_dWidth(800), m_dHeight(500), m_dOldWidth(0), m_dOldHeight(0), m_dDuctWeight(0.35),
m_dVDAngle(0), m_nMaterial(0), m_dSpeedSubMid(0), m_dSpeedLength(0), m_dFlChuTou(100),
m_dFlThick(50), m_dCalWeight(0)
{
    m_sysType = TPipeSys::kUnknownSys;
	m_nSection = 0;
	m_nSysDrawMod = 2;
	m_eDQType = kMidMid;
	m_eDQSide = TPipeSys::kStartPt;

	m_nSpare = 0;
	m_dSpare = 0.0;
}



/////////////////////////////////Get函数/////////////////////////////////////////
// 获取指定端坐标
XPoint TDbDuct::GetVertexPt(const TPipeSys::PtLoction nSide) const
{
	XPoint pt(GetStartPoint());
	if (nSide == TPipeSys::kEndPt)
	{
		pt = EndPoint();
	}
	return pt;
}

// 获取另一端坐标
XPoint TDbDuct::GetOtherPt(const TPipeSys::PtLoction nSide) const
{
	TPipeSys::PtLoction nOther = (TPipeSys::PtLoction)(1-(int)nSide);
	return GetVertexPt(nOther);
}

// 获取管线法向
XVector3D TDbDuct::GetDirection(const XPoint &pt, TPipeSys::PtLoction &nSide) const
{
	XVector3D vt;
	XCurveSegment seg = GetCurve(); // 管段
	if (seg.Is(CURVE_LINE)) // 直线管段
	{
		double dDis1 = pt.Distance(StartPoint()),
			dDis2 = pt.Distance(EndPoint());
		if (dDis1 > (dDis2+1.0E-6))
		{
			vt = StartPoint() - EndPoint(); // S——>E
			nSide = TPipeSys::kEndPt;   // pt点接近管线终点
		}
		else
		{
			vt = EndPoint() - StartPoint(); // E——>S
			nSide = TPipeSys::kStartPt; // pt点接近管线起点
		}
		return vt;
	}

	XPoint ptRet, ptStart, ptEnd; // 注：弧管起止点可能会相反
	seg.ProjectToMe(pt, ptRet);   // 保证点在管段上
	XArc arc = seg.GetArc();
	arc.GetStartPoint(ptStart);
	arc.GetEndPoint(ptEnd);

//	arc.GetPoints(ptStart, ptEnd); // 弧管上的起、止点坐标

	AcGePoint3d ptOnCurve = ptRet.AsAcGePoint3d(), ptOnHit;
	AcDbCurve *pCurve = GetBaseCurve();
	pCurve->getClosestPointTo(ptOnCurve, ptOnHit);
	ASSERT(pCurve);
	AcGeVector3d vec; // S——>E
	pCurve->getFirstDeriv(ptOnHit, vec); // 求切线向量
	delete pCurve;
	vt = XVector3D(vec);
	
	double dDis1 = pt.Distance(ptStart),
		dDis2 = pt.Distance(ptEnd);
	BOOL bChange = ptStart.Distance(StartPoint())>1.0E-5; // 标志是否发生了反向
	if (dDis1 > (dDis2+1.0E-6))
	{
		vt.Scale(-1); // E——>S
		nSide = bChange?TPipeSys::kStartPt:TPipeSys::kEndPt; // pt点接近管线终点
	}
	else
	{
		nSide = bChange?TPipeSys::kEndPt:TPipeSys::kStartPt; // pt点接近管线起点
	}
	return vt;
}



//////////////////////////有关管段上附着的设备/////////////////////////////////
void TDbDuct::AddEquipment(const AcDbObjectId &id) // 增加节点
{
    assertWriteEnabled();
	if (!FindEquipment(id))
	{
		m_lstEquipment.Append(new AcDbSoftPointerId(id));
	}
}

void TDbDuct::RemoveEquipment(const AcDbObjectId &id) // 移除节点
{
    assertWriteEnabled();
	if (m_lstEquipment.FindNode(&id, CompareObjectId))
	{
		m_lstEquipment.Remove();
	}
}

BOOL TDbDuct::FindEquipment(const AcDbObjectId &id) const // 查找节点
{
	TDbDuct *pThis = TDbDuct::cast(this);
	BOOL bFind = (pThis->m_lstEquipment.FindNode(&id, CompareObjectId)!=NULL);
	return bFind;
}

int TDbDuct::GetEquipNum() const // 获取连接的节点数量
{
	return m_lstEquipment.Length();
}

// 获取节点ID
void TDbDuct::GetEquipments(DList<AcDbObjectId> &lstEquipment) const
{
	int nCount = m_lstEquipment.Length();
	for (int i=0; i<nCount; i++)
	{
		lstEquipment.Append(new AcDbObjectId(m_lstEquipment[i]));
	}
}

// 获取节点位置
void TDbDuct::GetEquipPts(XPointList &lstPts) const
{
	int nCount = m_lstEquipment.Length();
	for (int i=0; i<nCount; i++)
	{
        AcDbObjectId idOp = m_lstEquipment[i];
        OPENOBJ_BEGIN(idOp, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode != NULL)
		{
			XPoint ptLoc = pNode->GetLocation();
			lstPts.Append(new XPoint(ptLoc));
		}
		OPENOBJ_END();
	}
}

// 判断管线与设备是否能在指定接口处，产生附着关系
BOOL TDbDuct::CanAttachEquipment(const THDbEquipment &equipment,
								 const int &nIFaceNum) const
{
 	BOOL bRet(FALSE);
	XPoint ptProject;
	const XPoint &ptLink = equipment.GetILocation(nIFaceNum);
	if (getClosestPointTo(ptLink, ptProject, Adesk::kFalse) != Acad::eOk)
	{
		return bRet;
	}
	
	int nSection = GetSectionType();
	BOOL bSys = GetModelType()==TPipeSys::kSystem ||
		GetModelType()==TPipeSys::kPrinciple;
	if (nSection == 1) // 圆管
	{
		double dDist = ptProject.Distance(ptLink);
		bRet = fabs(dDist-m_dWidth/2.0)<1.0E-6;
		if (bSys)
		{
			bRet = dDist < m_dHeight/2.0 + 1.0E-6;
		}
	}
	else if (nSection == 0) // 方管
	{
		if (bSys)
		{
			CString sBlkName, sDesName;
			GetBlkNameById(equipment.GetBlock2d(), sBlkName, sDesName);
			
			XPoint ptTmp1(ptLink), ptTmp2(ptProject);
			ptTmp1.z = ptTmp2.z = 0;
			double dDist = ptTmp1.Distance(ptTmp2);
			if (_tcsicmp(sDesName, _T("sysD")) == 0) // 下接风口
			{
				bRet = dDist < m_dHeight/2.0 + 1.0E-6;

			}
			else if (_tcsicmp(sDesName, _T("sysS")) == 0) // 侧接风口
			{
				bRet = dDist < m_dWidth/2.0 + 1.0E-6;
			}
		}
		else
		{
			XPoly2D poly1, poly2;
			XPointList lstPts1, lstPts2;
			XVector3D vtDuct1 = EndPoint() - StartPoint(),
				vtDuct2 = StartPoint() - EndPoint();
			::GetDuctSidePts(ptProject, m_dWidth, m_dHeight, vtDuct1, lstPts1);
			::GetDuctSidePts(ptProject, m_dWidth, m_dHeight, vtDuct2, lstPts2);
			int nLen = lstPts1.Length(), i(0);
			for (i=0; i<nLen; i++)
			{
				poly1.AppendNode(*lstPts1[i], 0);
			}
			
			nLen = lstPts2.Length();
			for (i=0; i<nLen; i++)
			{
				poly2.AppendNode(*lstPts2[i], 0);
			}
			
			BOOL bRet1 = (ptLink&poly1)==PR_EDGE,
				bRet2 = (ptLink&poly2)==PR_EDGE;
			bRet = bRet1 || bRet2;
 		}
	}
	return bRet;
}

// 重新验证同自身全部附着的设备之间的关系，并调整配属, 在系统结束后处理
// 注：只处理设备，不处理掏洞节点
void TDbDuct::ValidateEquipmentShip()
{
	int i(0),
		nCount = m_lstEquipment.Length();
    DList<AcDbObjectId> lstEquipment;
    for (i=0; i<nCount; i++)
	{
        lstEquipment.Append(new AcDbObjectId(*m_lstEquipment[i]));
	}

    for (i=0; i<lstEquipment.Length(); i++)
	{
        AcDbObjectId idOp = *lstEquipment[i];
		OPENOBJ_BEGIN(idOp, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode == NULL)
		{
			RemoveEquipment(idOp);
			continue;
		}

		if (pNode->isKindOf(TDbDuctNode::desc())) // 掏洞节点
		{
			continue;
		}

		if (pNode->isKindOf(THDbEquipment::desc())) // 设备
		{
			THDbEquipment *pEquipment = THDbEquipment::cast(pNode);
			int nLen = pEquipment->GetInterfaceNum();
			for (int j=0; j<nLen; j++)
			{
				AcDbObjectId ductId = pEquipment->GetIPipe(j);
				if (ductId==objectId() && !CanAttachEquipment(*pEquipment, j))
				{
					RemoveEquipment(idOp); // 不存在相互连接关系
					if (pEquipment->upgradeOpen() == Acad::eOk)
					{
						pEquipment->SetIPipe(j, AcDbObjectId::kNull);
						pEquipment->downgradeOpen();
					}
				}
			}
		}
		OPENOBJ_END();
    }
}


///////////////////////////Override TDbEntity////////////////////////////////////
void TDbDuct::CopyPropertiesFrom(AcDbEntity* pSrc, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPipePrototype::CopyPropertiesFrom(pSrc, gMatchFlag);
    TDbDuct *pDuct = TDbDuct::cast(pSrc);
    if (pDuct != NULL)
	{
		m_nSysDrawMod = pDuct->m_nSysDrawMod;
		m_nSection = pDuct->m_nSection;
        m_dWidth = pDuct->m_dWidth;
        m_dHeight = pDuct->m_dHeight;
		m_dDuctWeight = pDuct->m_dDuctWeight;
		m_dVDAngle = pDuct->m_dVDAngle;
		m_nMaterial = pDuct->m_nMaterial;
        m_sLabel = pDuct->m_sLabel;
		m_eDQType = pDuct->m_eDQType;
		m_eDQSide = pDuct->m_eDQSide;
		m_dFlChuTou = pDuct->m_dFlChuTou;
		m_dFlThick = pDuct->m_dFlThick;
		m_dCalWeight = pDuct->m_dCalWeight;
    }
}

Acad::ErrorStatus TDbDuct::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}

// 取动态属性显示数据
void TDbDuct::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    if (IsVertical())
	{
        lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("立管")));
	}
    else
	{
        lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("管段")));
	}

    TDbPipePrototype::GetTips(lstInfo);
	if (m_nSection == 0) // 矩形截面
	{
		lstInfo.Append(new TObjInfoUnit(_T("宽度"), Dist2Str(m_dWidth)));
        lstInfo.Append(new TObjInfoUnit(_T("高度"), Dist2Str(m_dHeight)));
	}
	else if ((1 == m_nSection) || (2 == m_nSection)) // 圆、软管截面
	{
		lstInfo.Append(new TObjInfoUnit(_T("直径"), Dist2Str(m_dWidth)));
	}
	// 暂时无，8.0以后添加
// 	else if (m_nSection == 3) // 椭圆截面
// 	{
// 		lstInfo.Append(new TObjInfoUnit(_T("短轴长度"), Dist2Str(m_dWidth)));
//         lstInfo.Append(new TObjInfoUnit(_T("长轴长度"), Dist2Str(m_dHeight)));
// 	}
// 	else if (m_nSection = 4) //  扁圆截面
// 	{
// 		lstInfo.Append(new TObjInfoUnit(_T("长度A"), Dist2Str(m_dWidth)));
//         lstInfo.Append(new TObjInfoUnit(_T("长度B"), Dist2Str(m_dHeight)));
// 	}

	double dVelocity = CalVelocity();
	CString csTmp;
	csTmp.Format(_T("%.2f"), dVelocity);
	lstInfo.Append(new TObjInfoUnit(_T("风量"), Dist2Str(m_dCalWeight)));
	lstInfo.Append(new TObjInfoUnit(_T("风速"), csTmp));

	XStringList lstMaterial;
	if (GetDuctMaterial(lstMaterial) && m_nMaterial>=0 &&
		m_nMaterial<lstMaterial.Length())
	{
		lstInfo.Append(new TObjInfoUnit(_T("材料"),lstMaterial[m_nMaterial]));
	}
}

// 取得夹点说明
Acad::ErrorStatus TDbDuct::GetGripText(int idx, CString &cs) const
{
    Acad::ErrorStatus es = TDbPipePrototype::GetGripText(idx, cs);
    return es;
}



///////////////////////////Override AcDbEntity///////////////////////////////////
Acad::ErrorStatus 
TDbDuct::subGetOsnapPoints(AcDb::OsnapMode	osnapMode, INT_PTR gsSelectionMark,
						const AcGePoint3d &ptPick, const AcGePoint3d &lastPoint,
						const AcGeMatrix3d &viewXform, AcGePoint3dArray &snapPoints,
                        AcDbIntArray &geomIds) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = Acad::eOk;
	if (!g_nPipeOsnap)
	{
		es = TDbCurveEntity::subGetOsnapPoints(osnapMode, gsSelectionMark,	ptPick,
			lastPoint, viewXform, snapPoints, geomIds);
	} 
	else
	{
		if (IsVertical()) // 立管
		{
			switch(osnapMode) {
			case AcDb::kOsModeCen:
			case AcDb::kOsModeNode:
				snapPoints.append(GetVerUpCenter());
				snapPoints.append(GetVerLowCenter());
				break;
			default:
				break;
			}
		}
		else // 水平管，7.6版本以上增加边线的拾取
		{
			es = TEntityBase::GetOsnapPoints(osnapMode, gsSelectionMark, ptPick,
				lastPoint, viewXform, snapPoints, geomIds);
		}
	}
    return es;
}

// 取得所有的夹点，注：有关立管夹点的问题，在此修改
Acad::ErrorStatus TDbDuct::subGetGripPoints(AcGePoint3dArray& gripPoints,
										 AcDbIntArray& osnapModes,
										 AcDbIntArray& geomIds) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbPipePrototype::subGetGripPoints(gripPoints, osnapModes,
		geomIds);
    return es;
}

Acad::ErrorStatus TDbDuct::subMoveGripPointsAt(const AcDbIntArray& indices,
											const AcGeVector3d& offset)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipePrototype::subMoveGripPointsAt(indices, offset);
	if (es != Acad::eOk)
	{
		return es;
	}

	if (objectId().isValid()) // 管线的整体拖拽、夹点拖拽操作，要提供变化给节点
	{
		ApplyChangeToNode();
	}
	return es;
}

Acad::ErrorStatus TDbDuct::subMoveStretchPointsAt(const AcDbIntArray &indices,
											   const AcGeVector3d &offset)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipePrototype::subMoveStretchPointsAt(indices, offset);
	if (es != Acad::eOk)
	{
		return es;
	}
	
	if (objectId().isValid())
	{
		ApplyChangeToNode();
	}
	return es;
}

// 提供管线的移动变化到节点，用于moveGripPointsAt、transformBy中
void TDbDuct::ApplyChangeToNode(BOOL bSXTT)
{
	int i(0);
	for (i = 0; i < 2; i++) // 首先处理管线两端的节点、设备
	{
		TPipeSys::PtLoction nSide = (TPipeSys::PtLoction)i;
		XPoint ptSide = GetVertexPt(nSide); // 新坐标

		OPENOBJ_BEGIN(GetNode(i), AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode != NULL)
		{
			if (pNode->isKindOf(TDbDuctNode::desc())) // 节点
			{
				TDbDuctNode *pDuctNode = TDbDuctNode::cast(pNode);
				TDbDuctNode::DuctNodeType nType = pDuctNode->GetNodeType(); // 节点类型
				if (nType == TDbDuctNode::kStem) // 堵头
				{
					if (pDuctNode->upgradeOpen() == Acad::eOk)
					{
						pDuctNode->SetLocation(ptSide); // 修改m_ptLocation
						pDuctNode->SetILocation(0, ptSide);
						pDuctNode->downgradeOpen();
					}
				}
				else if (nType == TDbDuctNode::kTaoDong) // 掏洞
				{
					SetNode(i, AcDbObjectId::kNull); // 管线节点设置为空
					if (pDuctNode->upgradeOpen() == Acad::eOk)
					{
						pDuctNode->erase(); // 掏洞节点直接被删除
						pDuctNode->downgradeOpen();
					}
				}
				else // 其他
				{
					int nIndex = pDuctNode->FindIdInLink(objectId());
					if (nIndex != -1) // 存在连接关系
					{
						SetNode(i, AcDbObjectId::kNull); // 管线节点设置为空
						if (pDuctNode->upgradeOpen() == Acad::eOk)
						{
							pDuctNode->SetIType(nIndex, 1); // 接口设置为空
							pDuctNode->downgradeOpen();
						}
					}
				}
			}
			else if (pNode->isKindOf(THDbEquipment::desc())) // 设备，8.0以后再做处理
			{
			}
		}
		OPENOBJ_END();
	}

	if (bSXTT) // 当前正在进行的命令是“生系统图”
	{
		return;
	}
	
	for (i = 0; i < m_lstEquipment.Length(); i++) // 再处理附着的设备及节点
	{
		AcDbObjectId id = *m_lstEquipment[i];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeNode, pNode);
		if (pNode != NULL)
		{
			if (pNode->isKindOf(TDbDuctNode::desc())) // 掏洞节点
			{
				TDbDuctNode *pDuctNode = TDbDuctNode::cast(pNode);
				if (pDuctNode->upgradeOpen() == Acad::eOk)
				{
					pDuctNode->RemoveInterface(objectId()); // 删除被掏洞接口
					pDuctNode->SetNodeType(TDbDuctNode::kStem);
					pDuctNode->downgradeOpen();
				}
				RemoveEquipment(id);
				i--;
			}
			else if (pNode->isKindOf(THDbEquipment::desc())) // 设备
			{
				THDbEquipment *pEquipment = THDbEquipment::cast(pNode);
				int nCount = pEquipment->GetInterfaceNum();
				for (int j=0; j<nCount; j++)
				{
					AcDbObjectId ductId = pEquipment->GetIPipe(j);
					if (ductId==objectId() && !CanAttachEquipment(*pEquipment, j)) // 断开
					{
						if (pEquipment->upgradeOpen() == Acad::eOk)
						{
							pEquipment->SetIPipe(j, AcDbObjectId::kNull);
							pEquipment->downgradeOpen();
						}
						break;
						RemoveEquipment(id);
						i--;
					}
				}
			}
		}
		OPENOBJ_END();
	}
}

Acad::ErrorStatus TDbDuct::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPipePrototype::subTransformBy(xform);

	BOOL bApplyToNode(TRUE),
		bSXTT(FALSE); // 是否提供变化给节点
    if (!!objectId())
	{
        XString &sCmd = GetCurDocData()->m_sCurCommand;
		if (_tcsicmp(sCmd, _T("MIRROR"))==0 || _tcsicmp(sCmd, _T("COPY"))==0 ||
			_tcsicmp(sCmd, _T("COPYCLIP"))==0 || _tcsicmp(sCmd, _T("PASTECLIP"))==0)
		{
			bApplyToNode = FALSE; // 管线的复制、镜像操作，不提供变化给节点
		}

		bSXTT = _tcsicmp(sCmd, _T("sxtt"))==0;
    }

	if (objectId().isValid() && bApplyToNode)
	{
		ApplyChangeToNode(bSXTT); // 管线的移动、旋转操作，提供变化给节点
	}
	return es;
}



///////////////////////////////存储数据///////////////////////////////////////////
Acad::ErrorStatus TDbDuct::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es = TDbPipePrototype::dwgInFields(pFiler);
    if (es != Acad::eOk)
	{
		return es;
	}
	
    Adesk::UInt8  nVer;
    pFiler->readItem(&nVer);
    if (nVer > g_nVersion) // Version is too new
	{
        return Acad::eMakeMeProxy;
	}
    
	pFiler->readItem(&m_nSysDrawMod);
    pFiler->readItem(&m_dWidth);
    pFiler->readItem(&m_dHeight);
    pFiler->readItem(&m_dDuctWeight);
	pFiler->readItem(&m_dVDAngle);
	
	pFiler->readItem(&m_nMaterial);
	ReadString(pFiler, m_sLabel);
	pFiler->readItem(&m_dSpeedSubMid);
	pFiler->readItem(&m_dSpeedLength);

	m_lstEquipment.Reset();
	Adesk::UInt8 nCount = 0;
	pFiler->readItem(&nCount);
	for (Adesk::UInt8 i=0; i<nCount; i++)
	{
		AcDbSoftPointerId id;
		pFiler->readItem(&id);
		m_lstEquipment.Append(new AcDbSoftPointerId(id));
	}

    pFiler->readItem(&m_idDoteLayer);

	if (nVer > 1) // 7.6
	{
		pFiler->readItem(&m_nSection);
		pFiler->readItem(&m_dFlChuTou);
		pFiler->readItem(&m_dFlThick);

		Adesk::UInt8 nTmpNum = 0;
		pFiler->readItem(&nTmpNum);
		m_eDQType = (TDbDuct::DuiQiType)nTmpNum;
		pFiler->readItem(&nTmpNum);
		m_eDQSide = (TPipeSys::PtLoction)nTmpNum;

		pFiler->readItem(&m_dCalWeight);
		pFiler->readItem(&m_nSpare);
		pFiler->readItem(&m_dSpare);
		ReadString(pFiler, m_csSpare);
		m_dVer = 7.6;
	}
	else // 7.5
	{
		m_nSection = IsCircleDuct()?1:0;
		m_dFlChuTou = 100.0;
		m_dFlThick = 50.0;

		m_eDQType = (TDbDuct::DuiQiType)0;
		m_eDQSide = (TPipeSys::PtLoction)0;

		m_dCalWeight = 0;
		m_nSpare = 0;
		m_dSpare = 0.0;
		m_csSpare = _T("");
		m_dVer = 7.5;
	}
    return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuct::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
    Acad::ErrorStatus es = TDbPipePrototype::dwgOutFields(pFiler);
    if (es != Acad::eOk)
	{
		return es;
	}

// 	if (g_nSaveTArchVer == 7) // 8.0使用
// 	{
// 		pFiler->writeItem((Adesk::UInt8)2);
// 	}
// 	else
// 	{
// 		pFiler->writeItem(g_nVersion);
// 	}
    pFiler->writeItem(g_nVersion);

	pFiler->writeItem(m_nSysDrawMod);
    pFiler->writeItem(m_dWidth);
    pFiler->writeItem(m_dHeight);
    pFiler->writeItem(m_dDuctWeight);
	pFiler->writeItem(m_dVDAngle);
	
	pFiler->writeItem(m_nMaterial);
	pFiler->writeItem((const TCHAR *)m_sLabel);
	pFiler->writeItem(m_dSpeedSubMid);
	pFiler->writeItem(m_dSpeedLength);

	Adesk::UInt8 nCount = (Adesk::UInt8)m_lstEquipment.Length();
	pFiler->writeItem(nCount);
	for (Adesk::UInt8 i = 0; i < nCount; i++)
	{
		pFiler->writeItem(m_lstEquipment[i]);
	}

	pFiler->writeItem(m_idDoteLayer);

	if (g_nSaveTArchVer > 6)
	{
		pFiler->writeItem(m_nSection);
		pFiler->writeItem(m_dFlChuTou);
		pFiler->writeItem(m_dFlThick);
		pFiler->writeItem((Adesk::UInt8)m_eDQType);
		pFiler->writeItem((Adesk::UInt8)m_eDQSide);
		
		pFiler->writeItem(m_dCalWeight);
		pFiler->writeItem(m_nSpare);
		pFiler->writeItem(m_dSpare);
		pFiler->writeItem((const TCHAR *)m_csSpare);
    }
    return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuct::dxfInFields(AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es = TDbPipePrototype::dxfInFields(pFiler);
    if (es != Acad::eOk)
		return es;
    
    if (!pFiler->atSubclassData(_T("TDbDuct")))
        return Acad::eBadDxfSequence;
    
    resbuf rb;
    while ((es==Acad::eOk) && ((es=pFiler->readResBuf(&rb))==Acad::eOk))
	{
		switch (rb.restype) {
		case AcDb::kDxfXTextString+1:
			m_sLabel = rb.resval.rstring;
			break;
        case AcDb::kDxfXReal:
            m_dWidth = rb.resval.rreal;
            break;
        case AcDb::kDxfXReal+1:
            m_dHeight = rb.resval.rreal;
            break;
		case AcDb::kDxfXReal+2:
			m_dTextHeight = rb.resval.rreal;
			break;
		case AcDb::kDxfXCoord:
			m_ptLabel = rb.resval.rpoint;
			break;
		default:
			pFiler->pushBackItem();
			es = Acad::eEndOfFile;
			break;
		}
    }
	
    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;
    return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDuct::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    Acad::ErrorStatus es = TDbPipePrototype::dxfOutFields(pFiler);
    assert(es == Acad::eOk);
    es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbDuct"));
    assert(es == Acad::eOk);
    
	pFiler->writeString(AcDb::kDxfXTextString+1, (const TCHAR*)m_sLabel);
    pFiler->writeDouble(AcDb::kDxfXReal, m_dWidth);
    pFiler->writeDouble(AcDb::kDxfXReal+1, m_dHeight);
	pFiler->writeDouble(AcDb::kDxfXReal+2, m_dTextHeight);
	pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptLabel);
	pFiler->writeUInt8(AcDb::kDxfInt8, IsVertical());
    return es;
}



////////////////////////////////////处理实体/////////////////////////////////
// 处理管线打开
Acad::ErrorStatus TDbDuct::subOpen(AcDb::OpenMode mode)
{
	Acad::ErrorStatus es = TDbPipePrototype::subOpen(mode);
	if (es==Acad::eOk && g_nCmdReactor!=CMD_UPDATE)
	{
		if (mode==AcDb::kForWrite && database()==acdbCurDwg())
		{
			m_dOldHeight = m_dHeight;
			m_dOldWidth = m_dWidth;
		}
	}
	return es;
}

// 处理管线实体，注：在此处解决阀门比例问题
Acad::ErrorStatus TDbDuct::subClose()
{
    Acad::ErrorStatus es = TDbPipePrototype::subClose();
    if (es==Acad::eOk && isModified() && database()==acdbCurDwg())
	{
        for (int i=0; i<m_lstAttachment.Length(); i++) // 修改管径时同时修改阀门比例
		{
            OPENOBJ_BEGIN(*m_lstAttachment[i], AcDb::kForRead, TDbPipeValve, pAttach);
            if (pAttach != NULL)
			{
				BOOL bCanAttach = CanAttach(*pAttach);
				if (bCanAttach)
				{
					double dScale = pAttach->GetYScale(),
						dNewScale = m_dWidth/1000;
					if (fabs(dScale - dNewScale) > 0.001)
					{
						if (pAttach->upgradeOpen() == Acad::eOk)
						{
							pAttach->assertWriteEnabled();
							pAttach->SetYScale(dNewScale);
							pAttach->downgradeOpen();
						}
					}
				}
            }
            OPENOBJ_END();
        }
    }
    return es;
}

// 处理管线删除
Acad::ErrorStatus TDbDuct::subErase(Adesk::Boolean bErasing)
{
    Acad::ErrorStatus es = TDbPipePrototype::subErase(bErasing); // 删除附件
    if (es==Acad::eOk && bErasing==Adesk::kTrue && database()==acdbCurDwg())
	{
		int i(0);
		for (i=0; i<2; i++)
		{
			AcDbObjectId id = GetNode(i);
			OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbDuctNode, pDuctNode);
			if (pDuctNode != NULL) // 将风管节点中的本接口的接口类型设置为1(空)
			{
				int nIndex = pDuctNode->FindIdInLink(objectId());
				if (nIndex != -1) // 存在连接关系
				{
					pDuctNode->SetIType(nIndex, 1);
				}

				if (pDuctNode->Is("TaoDong"))
				{
					int nMain = pDuctNode->GetMainDuctNum();
					if (nMain != nIndex)
					{
						pDuctNode->erase(); // 当支管被删时，掏洞节点应同时被删
						continue;
					}
				}
			}
			OPENOBJ_END();
		}

		for (i=0; i<m_lstEquipment.Length(); i++) // 解除与附着设备、接口的连接
		{
			AcDbObjectId &id = *m_lstEquipment[i];
			OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbPipeNode, pNode);
			if (pNode != NULL)
			{
				if (pNode->isKindOf(TDbDuctNode::desc())) // 节点
				{
					TDbDuctNode *pDuctNode = TDbDuctNode::cast(pNode);
					pDuctNode->RemoveInterface(objectId());
					pDuctNode->SetNodeType(TDbDuctNode::kStem);
					continue;
				}
				else if (pNode->isKindOf(THDbEquipment::desc())) // 设备
				{
					THDbEquipment *pEquipment = THDbEquipment::cast(pNode);
					int nCount = pEquipment->GetInterfaceNum();
					for (int j=0; j<nCount; j++)
					{
						const AcDbObjectId &ductId = pEquipment->GetIPipe(j);
						if (ductId == objectId())
						{
							pEquipment->SetIPipe(j, AcDbObjectId::kNull);
							break;
						}
					}
				}
			}
			OPENOBJ_END();
		}
    }
    return es;
}



////////////////////////////////////绘图部分/////////////////////////////////
Acad::ErrorStatus TDbDuct::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
    Acad::ErrorStatus es = Acad::eOk;
	if (!IsVisibleEntity(this)) // 查询管线系统的显示属性
	{
		return es;
	}
	
	BOOL bIsWeight = g_bPipeWeight; // 是否管线加粗(针对非垂直管线)
	if (dc.IsFullExplode())
	{
		AcDbDatabase* pDb = database();
		if (pDb != NULL)
		{
			AcDbDictionary* pRootDict = NULL;
			es = pDb->getNamedObjectsDictionary(pRootDict, AcDb::kForRead);
			assert(es == Acad::eOk);

			AcDbObject* pObj = NULL;
			es = pRootDict->getAt(g_sDbPsConfig, pObj, AcDb::kForRead);
			if (es == Acad::eOk)
			{
				bIsWeight = ((TDbPsConfig *)pObj)->IsLineWeight();
				pObj->close();
			}
			pRootDict->close();
		}
	}

	if (IsVertical())
	{
		es = DrawVerDuct2d(dc); // 立管
	}
	else
	{
		es = DrawHorDuct2d(dc); // 非立管
	}
	
	if (es == Acad::eOk && IsShowPropertyText() && IsModel())
	{
		es = DrawPropertyText(dc); // 在管线中点位置显示管线的属性(针对非立管)
	}
    
    if (IsDrawLabel()) // 绘制非立管管径标注
	{
		DrawLabelText(dc);
	}
    return es;
}

Acad::ErrorStatus TDbDuct::DrawVerDuct2d(XExplodeDraw &dc) const // 立管
{
	XPoint ptCenter(GetStartPoint().x, GetEndPoint().y);
	if ((1 == m_nSysDrawMod) || (2 == m_nSection)) // 单线图或软管
	{
		dc << ptCenter;
		return Acad::eOk;
	}

	XCurveSegment seg1, seg2;    // 圆线
	XPoly2D rectPoly, vDuctPoly; // 方线

	// 1、判断截面形状，并获取绘制线
	if (m_nSection == 1) // 圆截面
	{
		XCircle cirIn(ptCenter, m_dWidth/2);
		seg1 = cirIn; // 圆外线

		XVector3D vtTmp1(1, 1, 0), vtTmp2(-1, 1, 0);
		vtTmp1.Normalize();
		vtTmp2.Normalize();
		vtTmp1.Scale(m_dWidth/2);
		vtTmp2.Scale(m_dWidth/4);
		XPoint pt1 = ptCenter + vtTmp1,
			pt2 = ptCenter + vtTmp2,
			pt3 = ptCenter - vtTmp1,
			pt4 = pt2 + vtTmp2;
		XArc arc(pt1, pt2, pt3);
		seg2 = arc; // 圆内线		
	}
	else if (m_nSection == 0) // 方截面
	{
		::GetSquare(ptCenter, GetVDAngle(), m_dWidth, m_dHeight, &rectPoly, &vDuctPoly);
	}
// 	else if (m_nSection == 3) // 椭圆截面
// 	{
// 	}
// 	else if (m_nSection == 4) // 扁圆截面
// 	{
// 	}
	
	// 2、判断绘制情况：（1）虚线、实线，（2）是否绘制方内线
	int nDrawMod(0); // 实线，有内线
	AcDbObjectId upNodeId = GetVerUpNode();
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbPipeNode, pNode);
	if (pNode != NULL)
	{
		if (pNode->isKindOf(THDbEquipment::desc()))
		{
			nDrawMod = 1; // 虚线，无内线
		}
		else if (pNode->isKindOf(TDbDuctNode::desc()))
		{
			TDbDuctNode *pDuctNode = TDbDuctNode::cast(pNode);
			if (!pDuctNode->Is(_T("Stem")))
			{
				nDrawMod = 1;
			}
		}
	}
	OPENOBJ_END();

	AcDbObjectId idLineTypeOld;
	if (nDrawMod == 1) // 注：立管被遮挡
	{
		idLineTypeOld = dc.GetLineTypeId();
		AcDbObjectId idDashType = InitLineType(_T("DASH"), database());
		if (idDashType.isValid())
		{
			dc.SetLineType(idDashType);
		}
	}

	double dWeight = GetPScale()*m_dDuctWeight;
	if (m_nSection == 1) // 圆管
	{
		if (g_bPipeWeight && (nDrawMod==0))
		{
			DrawWeight(dc, dWeight, seg1, colorIndex(), linetypeScale());
		}
		else
		{
			dc << seg1;
		}

		if (nDrawMod == 0)
		{
			dc << seg2;
		}
	}
	else if (m_nSection == 0) // 方管
	{
		if (g_bPipeWeight && (nDrawMod==0))
		{
			DrawWeight(dc, dWeight, rectPoly, colorIndex(), linetypeScale());
		}
		else
		{
			dc << rectPoly;
		}

		if (nDrawMod == 0)
		{
			dc << vDuctPoly;
		}
	}
	
	if (nDrawMod == 1)
	{
		dc.SetLineType(idLineTypeOld);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuct::DrawHorDuct2d(XExplodeDraw &dc) const // 水平管
{
	XCurveSegment cvHide;
	GetHideCurve(cvHide); // 考虑遮挡的当前曲线
	
	DList<XCurveSegment> lstCurve; // 存储打断后的曲线（中心线）
	if (g_bBreakPipe) // 打断
	{
		GetBrokenCurves(cvHide, lstCurve); // 获取打断后的曲线
	}
	else
	{
		lstCurve.Append(new XCurveSegment(cvHide));
	}

	int i(0),
		nCount = lstCurve.Length();
	double dWeight = GetPScale()*m_dDuctWeight;
	TPipeSys::ModelType nModelType = GetModelType();
	if (m_nSysDrawMod==1 || nModelType==TPipeSys::kSystem ||
		nModelType==TPipeSys::kPrinciple) // 1、绘制中线的情况
	{
		for (i=0; i<nCount; i++) // 单线，系统图，在边线层画中心线
		{
			XCurveSegment &seg = *lstCurve[i];
			BOOL bWeight = nModelType==TPipeSys::kSystem ||
				nModelType==TPipeSys::kPrinciple;
			if (g_bPipeWeight && bWeight) // 单线图不加粗
			{
				DrawWeight(dc, dWeight, seg, colorIndex(), linetypeScale());
			}
			else
			{
				dc << seg;
			}
		}
		return Acad::eOk;
	}

	if (m_nSysDrawMod == 2) // 三线图，在中心线层绘制中心线
	{
		AcDbObjectId idLayerOld = dc.GetLayerId(), // 保留原来的值
			idLineTypeOld = dc.GetLineTypeId();
		AcDbObjectId idDoteLayer = m_idDoteLayer;
		if (idDoteLayer.isValid())
		{
			dc.SetLayer(idDoteLayer);
		}
		dc.SetColorLayer(colorIndex(), idDoteLayer);

		AcDbObjectId idDashType;
		OPENOBJ_BEGIN(idDoteLayer, AcDb::kForRead, AcDbLayerTableRecord, pRec);
		if (pRec != NULL)
		{
			idDashType = pRec->linetypeObjectId();
			dc.SetLineType(idDashType);
		}
		OPENOBJ_END();
		
		for (i = 0; i < nCount; i++)
		{
			XCurveSegment &seg = *lstCurve[i];
			dc << seg; // 绘制中心线
		}
		dc.SetLayer(idLayerOld);
		dc.SetColorLayer(colorIndex(), idLayerOld);
		dc.SetLineType(idLineTypeOld);
	}


	XCurveSegment segUp, segDown;
	XDirectionCurve segDir(cvHide.StartPoint(), cvHide.EndPoint(), cvHide.GetBulge());
	segUp = segDir.Offset(m_dWidth/2, LS_FINITE);
	segDown = segDir.Offset(-m_dWidth/2, LS_FINITE);
	
    DList<XCurveSegment> lstCurve1;
	if (g_bBreakPipe) // 2、绘制风管上线
	{
		GetBrokenCurves(segUp, lstCurve1);
	}
	else
	{
		lstCurve1.Append(new XCurveSegment(segUp));
	}

	nCount = lstCurve1.Length();
    for (i=0; i<nCount; i++)
	{
        XCurveSegment &seg1 = *lstCurve1[i];
		if (g_bPipeWeight)
		{
			DrawWeight(dc, dWeight, seg1, colorIndex(), linetypeScale());
		}
        else
		{
            dc << seg1;
		}
	}	

    DList<XCurveSegment> lstCurve2;
	if (g_bBreakPipe) // 3、绘制风管下线
	{
		GetBrokenCurves(segDown, lstCurve2);
	}
	else
	{
		lstCurve2.Append(new XCurveSegment(segDown));
	}

	nCount = lstCurve2.Length();
    for (i=0; i<lstCurve2.Length(); i++)
	{
        XCurveSegment &seg2 = *lstCurve2[i];
		if (g_bPipeWeight)
		{
            DrawWeight(dc, dWeight, seg2, colorIndex(), linetypeScale());
		}
        else
		{
            dc << seg2;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbDuct::DrawLabelText(XExplodeDraw &dc) const // 标注
{
	XPoint ptOnThis;
	if (ProjectToMe(m_ptLabel, ptOnThis))
	{
		double dRotation(0);
		if (!IsVertical()) // 不是立管
		{
            if (Is(CURVE_LINE))
			{
				dRotation = Direction(ptOnThis);
			}
			else if (Is(CURVE_ARC))
			{
				XPoint ptCenter;
				GetArc().Center(ptCenter);
				dRotation = ads_angle(ptCenter, m_ptLabel) + PI/2;
			}
            
			dRotation = CT_std_angle(dRotation);
            if (fabs(dRotation) < 1.0E-6)
			{
                dRotation = 0;
			}
            if (fabs(dRotation-PI/2) < 1.0E-6)
			{
                dRotation = PI/2;
			}
            if (fabs(dRotation-PI/2*3) < 1.0E-5)
			{
                dRotation = PI/2*3;
			}
			if ((dRotation>(PI/2+1.0E-6) && dRotation<(PI*3/2+1.0E-6)))
			{
				dRotation = CT_std_angle(dRotation + PI);
			}
		}
		
		AcDbObjectId idLayerOld = dc.GetLayerId(),
			idLayer = m_idLabelLayer;
// 		if (m_idLabelLayer.isValid())
// 		{
// 			dc.SetLayer(m_idLabelLayer);
// 		}
		OPENOBJ_BEGIN(m_idLabelLayer, AcDb::kForRead, AcDbLayerTableRecord, pRec);
		if (pRec != NULL)
		{
			dc.SetLayer(m_idLabelLayer);
		}
		OPENOBJ_END();
		dc.SetColorLayer(colorIndex(), idLayer);
		
		TDbText text;
		text.setPropertiesFrom(this);
		text.setLayer(m_idLabelLayer);
		text.SetStyleId(m_idTextStyle);
		text.SetText(GetLabelText());
		text.SetRotation(dRotation);
		text.SetLocation(XPoint(m_ptLabel.x, m_ptLabel.y, 0));
		text.SetHeight(m_dTextHeight);
		text.SetAlignment(XExplodeDraw::kMiddleCenter);
		
        TPushProperty vProp(&text, dc);
        if (dc.IsFullExplode())
		{
            text.ExplodeOrDraw2d(dc);
		}
        else
		{
            dc.DrawEntity(text);
		}
		dc.SetColorLayer(colorIndex(), idLayerOld);
		dc.SetLayer(idLayerOld);
	}
	return Acad::eOk;
}


Acad::ErrorStatus TDbDuct::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	// sg delete，防止三维下炸开会崩溃
// 	if (!dc.IsFullExplode()) // 如果是动态预演，则简单绘制
// 	{
//         AcGiCommonDraw* dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
//         if (dcCommon->isDragging())
// 		{
// 			XCurveSegment segTmp = (*this);
//             dc << segTmp;
// 			return Acad::eOk;
//         }
//     }
	
    if (GetModelType()==TPipeSys::kSystem || GetModelType()==TPipeSys::kPrinciple)
	{
		XCurveSegment segTmp = (*this);
		dc << segTmp;
		return Acad::eOk; // 系统和原理图
    }
    
    ////////////////模型图////////////////
	double dFThick = m_dFlThick * 0.5; // 获取管线两端法兰遮挡管线的宽度
	if (fabs(dFThick) < 1.0E-5)
	{
		dFThick = 2; // 通常钢板厚度为4
	}
	
	XPoint ptS(GetStartPoint()), ptE(GetEndPoint());
	TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
	XVector3D vtS = GetDirection(ptS, nSide), // 切线方向
		vtE = GetDirection(ptE, nSide);
	vtS.Normalize();
	vtE.Normalize();
	vtS.Scale(dFThick);
	vtE.Scale(dFThick);
	ptS = ptS + vtS; // 绘制时的起、止点，扣除了法兰遮挡
	ptE = ptE + vtE;

	BOOL bIsOk(TRUE);
	DList<X3DFace> faces;
	if (IsVertical()) // 立管
	{
		if (m_nSection == 1) // 圆管
		{
			if (!DrawColumn3d(ptS, vtS, ptE, vtS, faces))
			{
				return Acad::eInvalidInput;
			}
		}
		else // 矩形
		{
			XPoly2D pts1, pts2;
			::GetSquare(ptS, m_dVDAngle, m_dWidth, m_dHeight, &pts1, NULL); // 截面
			::GetSquare(ptE, m_dVDAngle, m_dWidth, m_dHeight, &pts2, NULL);
			if (pts1.Length()!=4 || pts2.Length()!=4)
			{
				return Acad::eInvalidInput;
			}

			X3DFace face = ::GetFace1(*pts1[0], *pts1[1], *pts1[2], *pts1[3]);
			faces.Append(new X3DFace(face));
			face = ::GetFace1(*pts2[0], *pts2[1], *pts2[2], *pts2[3]);
			faces.Append(new X3DFace(face));
			face = ::GetFace1(*pts1[0], *pts1[1], *pts2[1], *pts2[0]);
			faces.Append(new X3DFace(face));
			face = ::GetFace1(*pts1[3], *pts1[2], *pts2[2], *pts2[3]);
			faces.Append(new X3DFace(face));
			face = ::GetFace1(*pts1[0], *pts1[3], *pts2[3], *pts2[0]);
			faces.Append(new X3DFace(face));
			face = ::GetFace1(*pts1[1], *pts1[2], *pts2[2], *pts2[1]);
			faces.Append(new X3DFace(face));
		}
	}
	else if (Is(CURVE_ARC)) // 弧管
	{
		XPoint ptArc; // 弧中点，但在3D状态下不直接用，防止标高出错
		XCurveSegment seg = GetCurve(); // 管段
		XArc arcSeg = seg.GetArc();
		arcSeg.MidPoint(ptArc);

		XVector3D vecS(-vtS.x, -vtS.y, -vtS.z),
			vecE(-vtE.x, -vtE.y, -vtE.z);
		XPointList pts;
		::GetTHSplitPts(ptS, ptE, vecS, vecE, g_nSplitNum, pts, 2, ptArc);
		int nLen = pts.Length(); // 切割成若干小圆柱或立方体
		if (nLen != g_nSplitNum+2)
		{
			return Acad::eInvalidInput;
		}

		AcGeCircArc3d arc(*pts[0], *pts[g_nSplitNum/2], *pts[g_nSplitNum+1]);
		for (int i=0; i<g_nSplitNum+1; i++) // 循环处理弧段
		{
			AcGeLine3d tangentL1, tangentL2;
			if (arc.tangent(pts[i]->AsAcGePoint3d(), tangentL1)==Adesk::kFalse ||
				arc.tangent(pts[i+1]->AsAcGePoint3d(), tangentL2)==Adesk::kFalse)
			{
				return Acad::eInvalidInput;
			}

			BOOL bSHow1 = i==0,
				bSHow2 = i==g_nSplitNum;			
			AcGeVector3d vt1 = tangentL1.direction(),
				vt2 = tangentL2.direction();
			if (m_nSection == 1) // 圆管
			{
				XVector3D __vt2(vt2);
				bIsOk = DrawColumn3d(*pts[i], XVector3D(vt1), *pts[i+1],
					__vt2, faces, bSHow1, bSHow2);
			}
			else // 矩形
			{
				XVector3D __vt2(vt2);
				bIsOk = DrawCube3d(*pts[i], XVector3D(vt1), *pts[i+1],
					__vt2,	faces, bSHow1, bSHow2);
			}
			
			if (!bIsOk)
			{
				return Acad::eInvalidInput;
			}
		}
	}
	else // 直管
	{
		if (m_nSection == 1) // 圆管
		{
			bIsOk = DrawColumn3d(ptS, vtS, ptE, vtS, faces);
		}
		else // 矩形
		{
			bIsOk = DrawCube3d(ptS, vtS, ptE, vtS, faces);
		}

		if (!bIsOk)
		{
			return Acad::eInvalidInput;
		}
	}

	int nCount = faces.Length();
	for (int k=0; k<nCount; k++)
	{
		X3DFace face = *faces[k];
		dc << face;
	}
	return Acad::eOk;
}

BOOL TDbDuct::DrawCube3d(XPoint pt1, XVector3D vt1, XPoint pt2, XVector3D &vt2,
						 DList<X3DFace> &faces, BOOL bShow1, BOOL bShow2) const
{
	XPointList pts1, pts2;
	::GetDuctSidePts(pt1, m_dWidth, m_dHeight, vt1, pts1);
	::GetDuctSidePts(pt2, m_dWidth, m_dHeight, vt2, pts2);
	if (pts1.Length()!=4 || pts2.Length()!=4)
	{
		return FALSE;
	}
	
	X3DFace	face;
	face = ::GetFace1(*pts1[0], *pts1[1], *pts2[1], *pts2[0], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[0], *pts1[3], *pts2[3], *pts2[0], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[3], *pts1[2], *pts2[2], *pts2[3], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));
	face = ::GetFace1(*pts1[1], *pts1[2], *pts2[2], *pts2[1], bShow1, TRUE, bShow2);
	faces.Append(new X3DFace(face));

	if (bShow1) // 起点面
	{
		face = ::GetFace1(*pts1[0], *pts1[1], *pts1[2], *pts1[3]);
		faces.Append(new X3DFace(face));
	}
	if (bShow2) // 终点面
	{
		face = ::GetFace1(*pts2[0], *pts2[1], *pts2[2], *pts2[3]);
		faces.Append(new X3DFace(face));
	}
	return TRUE;
}

BOOL TDbDuct::DrawColumn3d(XPoint pt1, XVector3D vt1, XPoint pt2, XVector3D &vt2,
						   DList<X3DFace> &faces, BOOL bShow1, BOOL bShow2) const
{
	BOOL bIsOk = ::GetColumn3DFaces(pt1, m_dWidth/2.0, vt1, pt2, m_dWidth/2.0,
		vt2, faces, g_nSplitNum, 4, bShow1, bShow2, bShow1, bShow2);
	return bIsOk;
}



///////////////////////////Override TDbPipePrototype//////////////////////////
XExtent TDbDuct::GetExtent() const
{
	if (IsVertical())
	{
		if (m_nSection == 1) // 圆
		{
			return XExtent(m_dWidth, m_dWidth);
		}
		if (m_nSection == 0) // 方
		{
			return XExtent(m_dWidth, m_dHeight);
		}
	}
	return TDbPipePrototype::GetExtent();
}

XExtent TDbDuct::GetOldExtent() const
{
	if (IsVertical()) // 立管
	{
		if (m_nSection == 1) // 圆
		{
			return XExtent(m_dOldWidth, m_dOldWidth);
		}
		if (m_nSection == 0) // 方
		{
			return XExtent(m_dOldWidth, m_dOldHeight);
		}
	}

	return TDbPipePrototype::GetOldExtent(); // 非立管
}

int TDbDuct::GetExtend(XPoint &low, XPoint &up) const
{
	if (!IsVertical()) // 非立管
	{
		return TDbPipePrototype::GetExtend(low, up);
	}

	low = up = StartPoint(); // 立管
	XExtent ex = GetExtent();
	ex /= 2;
	low -= ex;
	up += ex;
	return RTNORM;
}


XString TDbDuct::GetLabelText() const
{
	XString sLabel = m_sLabel;
	return sLabel;
}

void TDbDuct::ApplyDnDiameterChangeToLabel()
{
	for (int i=0; i<m_lstAttachment.Length(); i++)
	{
		OPENOBJ_BEGIN(*m_lstAttachment[i], AcDb::kForRead, TDbPipeLabel, pLabel);
		if (pLabel != NULL)
		{
			double dWide = GetWidth(),
				dHigh = GetHeight();
			if (pLabel->GetPipeType()!=TDbPipeLabel::kDuct ||
				dWide!=pLabel->GetPipeWidth() || dHigh!= pLabel->GetPipeHeight())
			{
				if (pLabel->upgradeOpen() == Acad::eOk)
				{
					pLabel->assertWriteEnabled();
					pLabel->SetPipeType(TDbPipeLabel::kDuct);
					pLabel->SetPipeWidth(dWide);
					pLabel->SetPipeHeight(dHigh);
					pLabel->downgradeOpen();
				}
			}
		}
		OPENOBJ_END();
	}
}

void TDbDuct::ResetDrawSpeed()
{ 
    assertWriteEnabled();
    double dSpeedLength(0), // 初始化
		dSpeedSubMid(0);
	OPENOBJ_BEGIN(GetNode(1), AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		if (pNode->IsHidePipe())
		{
			double dWidth = m_dFlThick*0.5; // 是否节点遮挡管线
			if (dWidth > 1.0E-3)
			{
				dSpeedLength -= dWidth;
				dSpeedSubMid -= dWidth/2;
			}
		} 
	}
	OPENOBJ_END();
	
	OPENOBJ_BEGIN(GetNode(0), AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		if (pNode->IsHidePipe())
		{
			double dWidth = m_dFlThick*0.5; // 是否节点遮挡管线
			if (dWidth > 1.0E-3)
			{
				dSpeedLength -= dWidth;
				dSpeedSubMid += dWidth/2;
			}
		}
	}
	OPENOBJ_END();
	
	if (fabs(dSpeedLength)>1.0E-3 || fabs(dSpeedSubMid)>1.0E-3)
	{
		XCurveSegment cv = GetCurve();
		cv.SetElevation(0); // 设置为二维，z＝0
		if (cv.Is(CURVE_ARC)) // 注：本版本弧管不支持加速
		{
			m_dSpeedLength = 0;
			m_dSpeedSubMid = 0;
		}
		else
		{
			double dLength = cv.GetLength();
			m_dSpeedLength = dLength + dSpeedLength;
			m_dSpeedSubMid = dLength/2 + dSpeedSubMid;
		}
	}
	else
	{
		m_dSpeedLength = 0;
		m_dSpeedSubMid = 0;
	}
}



//////////////////////////Renew TDbPipePrototype///////////////////////////////
// 判断立管的上节点是否连接了非立管
BOOL TDbDuct::IsUpPipesOk() const
{
	if (!IsVertical())
	{
		return FALSE;
	}

	AcDbObjectId upNodeId = GetVerUpNode(); // 上节点
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		int nLen = pNode->GetInterfaceNum();
		if (nLen > 1) // 至少连接了一个立管
		{
			for (int i=0; i<nLen; i++)
			{
				if (pNode->GetIPipe(i) != objectId())
				{
					OPENOBJ_BEGIN(pNode->GetIPipe(i), AcDb::kForRead, TDbDuct, pDuct);
					if (pDuct!=NULL && !pDuct->IsVertical())
					{
						return TRUE;
					}
					OPENOBJ_END();
				}
			}
		}
	}
	OPENOBJ_END();
	return FALSE;
}

// 立管上节点连接的管线中，非立管的连接点
void TDbDuct::GetUpPipesPt(XPointList &pts) const
{
	pts.Reset();
	if (!IsUpPipesOk())
	{
		return;
	}
	
	AcDbObjectId upNodeId = GetVerUpNode();
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		int nLen = pNode->GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			XVector3D vt = pNode->GetIDirection(i);
			vt.Normalize();
			if (fabs(vt.x)>1.0E-6 || fabs(vt.y)>1.0E-6)
			{
				XPoint ptTmp = pNode->GetILocation(i);
				pts.Append(new XPoint(ptTmp));
			}
		}
	}
	OPENOBJ_END();
}

// 立管上节点连接的管线中，非立管的管径
AcGeDoubleArray TDbDuct::GetUpPipesWidth() const
{
	AcGeDoubleArray widths;
	if (!IsUpPipesOk())
	{
		return widths;
	}
	
	AcDbObjectId upNodeId = GetVerUpNode();
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		int nLen = pNode->GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			XVector3D vt = pNode->GetIDirection(i);
			vt.Normalize();
			if (fabs(vt.x)>1.0E-6 || fabs(vt.y)>1.0E-6)
			{
				widths.append(pNode->GetIWidth(i));
			}
		}
	}
	OPENOBJ_END();
	return widths;
}

// 非立管的向量
void TDbDuct::GetUpPipesVec(DList<XVector3D> &vts) const
{
	if (!IsUpPipesOk())
	{
		return;
	}
	
	AcDbObjectId upNodeId = GetVerUpNode();
	OPENOBJ_BEGIN(upNodeId, AcDb::kForRead, TDbDuctNode, pNode);
	if (pNode != NULL)
	{
		int nLen = pNode->GetInterfaceNum();
		for (int i=0; i<nLen; i++)
		{
			XVector3D vt = pNode->GetIDirection(i);
			if (fabs(vt.x)>1.0E-6 || fabs(vt.y)>1.0E-6)
			{
				vts.Append(new XVector3D(vt));
			}
		}
	}
	OPENOBJ_END();
}


//////////////////////////增加连接件到当前数据库///////////////////////////////
// 增加节点到当前数据库，ids－该节点自动连接的管线
AcDbObjectId TDbDuct::AddNodeToDb(const XPoint &ptAt, const DList<AcDbObjectId> &ids,
								  const AcDbIntArray &types, const int &nMainDuct)
{
    int	nLen = ids.Length();
	if (nLen < 1)
	{
		return AcDbObjectId::kNull;
	}

	Adesk::UInt8 nMode = 0; // 传给实体
	double dParam1(1.0), dParam2(0.0);
	TDbDuctNode::DuctNodeType nType =
		::GetNodeType(AcDbObjectId::kNull, ptAt, types, ids); // 节点类型
	int nLink = ::GetDNodeConfig(nType, nMode, dParam1, dParam2); // 获取绘制参数
	if (nType==TDbDuctNode::kTaoDong && nLink!=13)
	{
		BOOL bVDuct1 = ::IsVerDuct(AcDbObjectId::kNull, ids[0], types[0]),
			bVDuct2 = ::IsVerDuct(AcDbObjectId::kNull, ids[1], types[1]);
		if (bVDuct1 || bVDuct2)
		{
			nMode = 13; // 立管一律用样式13
		}
	}
	
	TDbDuctNode* pNode = new TDbDuctNode;
	pNode->SetNodeType(nType);

	Adesk::UInt8 nDrawMod = GetSysDrawMod();
	if (nDrawMod==1 && (GetModelType()==TPipeSys::kSystem ||
		GetModelType()==TPipeSys::kPrinciple))
	{
		nDrawMod = 4; // 系统图
	}
	pNode->SetSysDrawMod(nDrawMod);
	pNode->SetDrawMod(nMode); // 注：主要考虑到打断新生成的三、四通
	pNode->SetDrawParam(dParam1);
	pNode->SetDrawParam2(dParam2);
	pNode->SetXMWNum((Adesk::UInt8)dParam2);
	pNode->SetMainDuctNum(nMainDuct);
    pNode->SetLocation(ptAt); // 死机处
	pNode->SetLinkType((Adesk::UInt8)nLink);
    pNode->UpdateInterface(GetSysType(), ptAt, ids, types);

	TCHAR *layer;
	layer = this->layer();
	TCHAR szLayer[256]; // 图层
	_tcscpy(szLayer, layer);
	pNode->setLayer(szLayer);
	pNode->setColor(AcCmColor());
	pNode->setLinetype(this->linetype()); // 线型
	pNode->SetDoteLayer(m_idDoteLayer);
	pNode->SetFlangeLayer(::InitLayer(GetDuctFLLayerName(this->GetSysType()),	database()));
	AcDbObjectId id = AddToCurrentSpace(pNode, Adesk::kTrue);
	delete []layer;
 	return id;
}

// 获取风管法兰图层名
CString GetDuctFLLayerName(const TPipeSys::SysType st)
{
	int nIndex = (int)st - 50;
	if (nIndex<0 || nIndex>5)
	{
		return CString();
	}

	CString csLayer[] = {LAYER_DUCT_SUPPLYFL, LAYER_DUCT_RETURNFL, LAYER_DUCT_FRESHFL,
		LAYER_DUCT_VENTFL, LAYER_DUCT_SMOKEPREVENTIONFL, LAYER_DUCT_PRESSURESUPPLYFL};
	return csLayer[nIndex];
}



/////////////////////打断、遮挡、连接、自动生成节点////////////////////////////
// 判断是否可以连接
// 注：风管中，要找的是起止节点是否连接的是同一个节点
BOOL TDbDuct::CanMergeWith(const TDbDuct &other, int* iPosThis, int* iPosOther) const
{
	if (GetSysType() != other.GetSysType())	// 1、系统类型相同
	{
		return FALSE;
	}
	
    int bLine1 = Is(CURVE_LINE),
		bLine2 = other.Is(CURVE_LINE);
    if (bLine1 != bLine2) // 2. 几何特征判断
	{
		return FALSE;
	}
	if (m_nSection!=other.m_nSection || fabs(m_dWidth-other.GetWidth())>_distSnap
		|| fabs(m_dHeight-other.GetHeight())>_distSnap) // 3、截面相同，宽、高相同
	{
		return FALSE;
	}

	const AcDbObjectId thisStartId = GetNode(0),
		thisEndId = GetNode(1),
		otherStartId = other.GetNode(0),
		otherEndId = other.GetNode(1);

	double nSweepAng(0.0);
	AcDbObjectId mergeNodeId;
	int nPosFlag(0), nThis(-1), nOther(-1); // 0－起点；1－终点
    if (thisStartId == otherStartId)
	{
		nThis = nOther = 0;
		mergeNodeId = thisStartId;
		nPosFlag = 1; // Merge at both StartPoint
        nSweepAng = GetBulge() - other.GetBulge();
    }
	else if (thisStartId == otherEndId)
	{
		nThis = 0;
		nOther = 1;
		mergeNodeId = thisStartId;
		nPosFlag = 2; // Merge at this StartPoint() and that EndPoint()
		nSweepAng = GetBulge() + other.GetBulge();
    }
	else if (thisEndId == otherStartId)
	{
		nThis = 1;
		nOther = 0;
		mergeNodeId = thisEndId;
		nPosFlag = 4; // Merge at this EndPoint() and that StartPoint()
		nSweepAng = GetBulge() + other.GetBulge();
	}
	else if (thisEndId == otherEndId)
	{
		nThis = nOther = 1;
		mergeNodeId = thisEndId;
		nPosFlag = 3; // Merge at both EndPoint()
        nSweepAng = GetBulge() - other.GetBulge();
    }
	if (mergeNodeId.isNull())
	{
		return TDbPipePrototype::CanMergeWith(other, iPosThis, iPosOther);
	}

	TDbPipeNode *pNode = NULL;
	if (acdbOpenObject(pNode, mergeNodeId, AcDb::kForRead) == Acad::eOk)
	{
		if (pNode->isKindOf(TDbDuctNode::desc())) // 节点
		{
			int nLen = pNode->GetInterfaceNum();
			if (nLen > 2)
			{
				pNode->Close();
				return FALSE;
			}

			TDbDuctNode *pDuctNode = TDbDuctNode::cast(pNode);
			TDbDuctNode::DuctNodeType nType = pDuctNode->GetNodeType();
			if ((nType == TDbDuctNode::kYiZiElbow) || (nType ==
				TDbDuctNode::kFlange) || (nType == TDbDuctNode::kTaoDong))
			{
				pDuctNode->Close();
				return FALSE;
			}
			pDuctNode->Close();
		}
		else // 设备
		{
			pNode->Close();
			return TDbPipePrototype::CanMergeWith(other, iPosThis, iPosOther);
		}
	}

	// 注：以下部分只对TDbDuctNode有效
    if (!nPosFlag || GreatEqual(fabs(nSweepAng), 2*PI, _angSnap))
	{
        return FALSE;
	}
	
	AcGeVector3d vtDuctThis, vtDuctOther;
	if (getFirstDeriv((nThis?EndPoint():StartPoint()), vtDuctThis)!=Acad::eOk ||
		other.getFirstDeriv((nOther?other.EndPoint():other.StartPoint()),
		vtDuctOther)!=Acad::eOk)
	{
		return FALSE;
	}
	if (::IsParallel(vtDuctOther, vtDuctThis) == 0)
	{
		return FALSE;
	}
	
	if (iPosThis)
	{
		*iPosThis = nThis;
	}
	if (iPosOther)
	{
		*iPosOther = nOther;
	}
	return TRUE;
}

BOOL TDbDuct::MergeWith(TDbDuct &other)
{
	assertWriteEnabled();
	int nThis(-1), nOther(-1);
	BOOL bMerge = CanMergeWith(other, &nThis, &nOther); // 判断是否可以合并
	if (!bMerge)
	{
		return bMerge;
	}
	
	BOOL bLabel = m_ptLabel!=XPoint(); // 管线标注
    if (!m_bDrawLabel)
	{
        m_bDrawLabel = other.m_bDrawLabel;
	}
	
	double dDist2Pipe = 200,
		dScale2Start = 0.5;
	if (bLabel)
	{
		GetLabelLocation(dDist2Pipe, dScale2Start);
	}

	// 注：由于考虑对齐方式，需要对第二根管线进行处理，偏移其中心线
	XCurveSegment seg(StartPoint(), EndPoint(), GetBulge());
	XPoint ptNewStart, ptNewEnd;
	seg.ProjectToMe(other.StartPoint(), ptNewStart);
	seg.ProjectToMe(other.EndPoint(), ptNewEnd);

	if (nThis==0 && nOther==0) // 合并
	{
		StartPoint() = ptNewEnd;
		m_nodeStart = other.m_nodeEnd;
		SetBulge(GetBulge() - other.GetBulge());
	}
	else if (nThis==0 && nOther==1)
	{
		StartPoint() = ptNewStart;
		m_nodeStart = other.m_nodeStart;
		SetBulge(GetBulge() + other.GetBulge());
	}
	else if (nThis==1 && nOther==0)
	{
		EndPoint() = ptNewEnd;
		m_nodeEnd = other.m_nodeEnd;
		SetBulge(GetBulge() + other.GetBulge());
	}
	else if (nThis==1 && nOther==1)
	{
        EndPoint() = ptNewStart;
		m_nodeEnd = other.m_nodeStart;
		SetBulge(GetBulge() - other.GetBulge());
	}
	
	int i(0);
    for (i=0; i<other.m_lstAttachment.Length(); i++)
	{
		AddAttachment(*other.m_lstAttachment[i]);
	}
	for (i=0; i<other.m_lstHidePipe.Length(); i++)
	{
		AddHidePipe(*other.m_lstHidePipe[i]);
	}
	for (i=0; i<other.m_lstEquipment.Length(); i++)
	{
		AddEquipment(*other.m_lstEquipment[i]);
	}
	
	if (bLabel) // 管线标注
	{
 		ResetLabelLocation(dDist2Pipe, dScale2Start);
	}
	
	other.assertWriteEnabled();
	other.ResetAllShip();
	for (i=0; i<other.m_lstEquipment.Length(); i++)
	{
		other.RemoveEquipment(*other.m_lstEquipment[i]);
	}
	return bMerge;
}

// 考虑遮挡的当前曲线，二维，z＝0
void TDbDuct::GetHideCurve(XCurveSegment& cvHide) const
{
	XCurveSegment cvHideTemp = GetCurve();
	cvHideTemp.SetElevation(0); // 设置为二维，z＝0
	
	// 改为将数据写入数据库加速二维显示速度
	if (fabs(m_dSpeedLength)>1.0E-3 && fabs(m_dSpeedSubMid)>1.0E-3)
	{
 		double dChordLength = cvHideTemp.GetChordLength(m_dSpeedLength);
		XPointDir2d ptSubMid;
		cvHideTemp.Polar(m_dSpeedSubMid, ptSubMid);
		cvHideTemp.GetSubSegment(ptSubMid, dChordLength, cvHide);
		return;
	}
	cvHide = cvHideTemp;
}

// 打断部分的宽度
double TDbDuct::GetBreakWidth() const
{
	double dWidth(2);
	TDbPsConfig* pConfig = GetDwgPsGlobal(AcDb::kForRead);
    if (pConfig != NULL)
	{
		dWidth = pConfig->GetBreakWidth();
		if (pConfig->IsLineWeight())
		{
			dWidth += m_dDuctWeight;
		}
		pConfig->close();
	}
	dWidth *= GetPScale();
	return dWidth;
}

// 通过管件附件打断的曲线，二维，z＝0
void TDbDuct::GetBrokenCurves(const XCurveSegment &cv,
							  DList<XCurveSegment> &lstCurve) const
{
	int nAttach = m_lstAttachment.Length(),
		nHide = m_lstHidePipe.Length();
	if (nAttach<=0 && nHide<=0) // 没有管件附件，也没有遮挡关系
	{
		lstCurve.Append(new XCurveSegment(cv));
		return;
	}
	
	XVector3D vtDir(cv.EndPoint() - cv.StartPoint()); // 以直线段初始化方向
	AcGeVector3d vtAttachment(vtDir);             // 管线附件在基线上的方向
	vtAttachment.z = 0;
	vtAttachment.normalize();
	
	AcGePoint3dArray arPoint(20);       // 剪裁点
	DList<XPoint> lstLocation;          // 交点或者附件所在点
    DList<XCurveSegment> lstBreakCurve; // 被剪裁的线段
	double dDisThis = cv.GetLength();      // 管线长
	
	int i(0);
	for (i=0; i<nAttach; i++) // 取得临时管线附件和管件附件的在管线上的端点
	{
		const AcDbObjectId &id = m_lstAttachment[i];
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeAttachment, pAttachment);
		if (pAttachment != NULL)
		{
			if (pAttachment->IsCheckSysType() && pAttachment->GetSysType()!=GetSysType())
			{
				continue;
			}

			double dWidth = pAttachment->GetWidth()/2,
				dScale = pAttachment->GetScale();
			dWidth *= dScale;

            TDbPipeValve* pValve = NULL;
            if (pValve = TDbPipeValve::cast(pAttachment))
			{
                if(pValve->HasFlange()) // 如果是带法兰的阀门，宽度要增加法兰厚度
                    dWidth += pValve->GetFlangeWidth()*pValve->GetScale()
					*GetPScale()/100/2;
            }

			if (dWidth > 1.0E-3)
			{
				XPoint ptLocation(pAttachment->GetLocation());
				cv.ProjectToMe(ptLocation, ptLocation);
				ptLocation.z = 0;
				lstLocation.Append(new XPoint(ptLocation));
				DisposeBreak(cv, arPoint, ptLocation, dWidth, dDisThis, vtAttachment,
					lstBreakCurve); // 获得被打断部分的曲线，和打断点
			}
		}
		OPENOBJ_END();
	}
	
	int j(0);
	for(j=0; j<nHide; j++) // 管线的遮挡关系
	{
		OPENOBJ_BEGIN(m_lstHidePipe[j], AcDb::kForRead, TDbPipePrototype, pPipe);
		if (pPipe!=NULL && IsVisibleEntity(pPipe))
		{
			AcGeVector3d vt1 = pPipe->Direction3d().AsAcGeVector3d(),
				vt2 = this->Direction3d().AsAcGeVector3d();
			double dAngle = vt1.angleTo(vt2);
			double dBreakWidth = pPipe->GetBreakWidth(),
				dWidth(0);
			
			if (pPipe->isKindOf(TDbDuct::desc())) // 方风管
			{
				TDbDuct *pDuct = (TDbDuct*)pPipe;
				dWidth = pDuct->GetWidth();
				if ((1 == m_nSysDrawMod) || (2 == m_nSection) ||
					pDuct->GetModelType()==TPipeSys::kSystem ||
					pDuct->GetModelType()==TPipeSys::kPrinciple)
				{
					dWidth = 0;
				}
			}
			else if (pPipe->isKindOf(TDbDoubleLinePipe::desc())) // TWT双线管
			{
				TDbDoubleLinePipe *pDLine = (TDbDoubleLinePipe*)pPipe;
				dWidth = pDLine->GetDnDiameter();
			}

			// 注：打断宽度，不同于水管
			dBreakWidth = (dBreakWidth + dWidth/sin(dAngle))/2.0;

			if (dBreakWidth > 1.0E-3)
			{
				XCurveSegment cvPipe = *pPipe;
				cvPipe.SetElevation(0); // 设置标高为0
				
				XPoint ptIntersect, ptTemp;
				if (cv.Intersection(cvPipe, ptIntersect, ptTemp))
				{
                    ptIntersect.z = 0;
					lstLocation.Append(new XPoint(ptIntersect));
					
					DisposeBreak(cv, arPoint, ptIntersect, dBreakWidth, dDisThis,
						vtAttachment, lstBreakCurve); // 获得被打断部分的曲线，和打断点
				}
			}
		}
		OPENOBJ_END();
	}
	
	// 按定位点到起点的距离快速排序（由小到大）
	int nCount = arPoint.length();
	if (nCount > 1)
	{
		DList<double> lstDist; // 打断点在曲线段上的距离
		for (i=0; i<nCount; i++) // 为提高效率先计算出距离
        {
			XPoint ptTmp = arPoint[i];
			double dDist = cv.PathDistance(arPoint[i]);
			lstDist.Append(new double(dDist));
		}

		for (i=0; i<nCount-1; i++)
		{
			for (j=0; j<nCount-1-i; j++)
			{
				if (*lstDist[j]>*lstDist[j+1]) //Swap
				{
					lstDist.Swap(j, j+1);
					arPoint.swap(j, j+1);
				}
			}
		}
	}
    nCount = arPoint.length();
    
	// 得到管线基线，并用管线附件打断管线成AcDbCurve
	AcDbVoidPtrArray arSeg; // 裁剪后的曲线段，包括显示和不显示的管线
	TDbPipePrototype pipeCv;
	(XCurveSegment&)pipeCv = cv;
	
	AcDbCurve* pCurve = pipeCv.GetBaseCurve();
    Acad::ErrorStatus es2 = pCurve->getSplitCurves(arPoint, arSeg); // 裁剪
    if (pCurve && es2==Acad::eInvalidInput) // 要裁剪的部分不在管线上，或不存在
	{
        AcGeMatrix3d mat;
        mat.setToScaling(0.1);
        pCurve->transformBy(mat);

        // 可能由于坐标过大导致返回eInvalidInput，管线无法打断
        AcGePoint3dArray arPoint2(20);
		int k(0);
        for (k=0; k<nCount; k++)
		{
            AcGePoint3d ptCur = arPoint[k];
            ptCur.transformBy(mat);
            pCurve->getClosestPointTo(ptCur, ptCur);
            arPoint2.append(ptCur);
        }

        es2 = pCurve->getSplitCurves(arPoint2, arSeg);
        if (es2 != Acad::eOk) // 不能打断
		{
            lstCurve.Append(new XCurveSegment(cv));
            if (pCurve != NULL)
			{
                delete pCurve;
			}
            return;
        }
		
        mat.invert();
        nCount = arSeg.length();
        for (k=0; k<nCount; k++)
		{
            AcDbCurve *pCurve0 = (AcDbCurve *)arSeg[k];
            pCurve0->transformBy(mat);
        }
    }
	else if (pCurve == NULL || es2 != Acad::eOk) // 基线不存在，导致无法打断
	{
		lstCurve.Append(new XCurveSegment(cv));
        if (pCurve != NULL)
		{
            delete pCurve;
		}
		return;
	}
	delete pCurve;
	
	nCount = arSeg.length(); // 打断后，总段数
	int nLocation = lstLocation.Length(); // 打断点个数
    if (nCount == nLocation*2 + 1) // 正常情况，奇偶性
	{
		for (int k=0; k<nCount; k=k+2)
		{
			AcDbCurve *pCurve0 = (AcDbCurve *)arSeg[k];
			TDbPipePrototype pipe;
			pipe.SetBaseCurve(pCurve0); // 设置基线
			delete pCurve0;
			
            // 判断有没有反方向绘制的线段
			XCurveSegment *pSeg = new XCurveSegment(pipe.GetCurve()); // 显示的管线
            XPoint ptCurveS = pSeg->StartPoint(),
				ptCurveE = pSeg->EndPoint();
            BOOL bStartInside = FALSE,
				bEndInside = FALSE;

            for (int m=0; m<lstBreakCurve.Length(); m++)
			{
                XCurveSegment segTmp = *lstBreakCurve[m]; // 不显示的管线
                if (segTmp.Is(CURVE_LINE))
				{
                    XLine lineTmp = segTmp;
                    int nRet1 = ptCurveS&lineTmp,
						nRet2 = ptCurveE&lineTmp;
                    if (nRet1 == PR_INSIDE)
					{
                        bStartInside = TRUE;
					}
                    if (nRet2 == PR_INSIDE)
					{
                        bEndInside = TRUE;
					}
                }
            }
			
            if (!bStartInside || !bEndInside)
			{
				lstCurve.Append(pSeg);
			}
		}
	}
	else // 非正常情况，比如附件的遮挡范围超出基线
	{
		for (int k=0; k<nCount; k++)
		{
			AcDbCurve *pCurve0 = (AcDbCurve *)arSeg[k]; // 转换成AcDbCurve
			TDbPipePrototype pipe;
			pipe.SetBaseCurve(pCurve0);
			delete pCurve0;
			
			// 转换成XCurveSegment，并判断是否是附件的基线
			XCurveSegment *pSeg = new XCurveSegment(pipe.GetCurve());
            XPoint ptS = pSeg->StartPoint(),
				ptE = pSeg->EndPoint();
			BOOL bAppend = TRUE;
			for (int j=0; j<nLocation; j++)
			{
				XPoint &pt = *lstLocation[j];
                pt.z = 0;
				int nResult = pt&(*pSeg);
				if (nResult==PR_EDGE || nResult==PR_INSIDE)
				{
					bAppend = FALSE;
					delete pSeg;
					break;
				}
			}
			
			if (bAppend) // 添加显示的曲线段
			{
				lstCurve.Append(pSeg);
			}
		}
	}
	
	if (lstCurve.Length() <= 0)
	{
		lstCurve.Append(new XCurveSegment(cv));
	}
	return;
}

// 处理打断，得到打断点数组arPoint，和不显示的管段的链表lstBreakCurve
void TDbDuct::DisposeBreak(const XCurveSegment &cv, AcGePoint3dArray &arPoint,
						   const XPoint ptLoc, double dWidth,
						   double dDistance, const AcGeVector3d &vtDir,
						   DList<XCurveSegment> &lstBreakCurve) const
{
	if (Is(CURVE_ARC))
	{
        XArc arc2 = cv.GetArc();
        XPoint pt3, pt4, ptMid;
        arc2.GetStartPoint(pt3);
        arc2.GetEndPoint(pt4);

      //  arc2.GetPoints(pt3, pt4);
        arc2.MidPoint(ptMid);
        pt3.z = 0;
        pt4.z = 0;
        ptMid.z = 0;

        XArc arc(pt3, ptMid, pt4); // 先把arc标高设为0

        AcDbArc *pArc = new AcDbArc;
        pArc->setCenter(arc.GetCenterPt());
        pArc->setRadius(arc.GetRadius());
        pArc->setStartAngle(arc.GetStarAngle());
        pArc->setEndAngle(arc.GetEndAngle());

        XPoint pt1, pt2;
        double dParam(0);
        pArc->getParamAtPoint(ptLoc, dParam);
        pArc->getPointAtParam(dParam+dWidth/arc.GetRadius(), pt1);
        pArc->getPointAtParam(dParam-dWidth/arc.GetRadius(), pt2);
        delete pArc;

		cv.ProjectToMe(pt1, pt1);
		cv.ProjectToMe(pt2, pt2);
        pt1.z = 0;
        pt2.z = 0;
        arPoint.append((AcGePoint3d)pt1);
        arPoint.append((AcGePoint3d)pt2);
	}
	else
	{
		XVector3D vtAdd = vtDir * dWidth;
		XPoint ptStart = ptLoc - vtAdd,
			ptEnd = ptLoc + vtAdd;
		double dStart = cv.PathDistance(ptStart),
			dEnd = cv.PathDistance(ptEnd);
		
		if (fabs(StartPoint().z-EndPoint().z) < 0.01)
		{
			getClosestPointTo(ptStart, ptStart);
			getClosestPointTo(ptEnd, ptEnd);
		}
		ptStart.z = 0;
		ptEnd.z = 0;
		
		if (dStart>1.0E-5 && dStart<dDistance-1.0E-5)
		{
			arPoint.append((AcGePoint3d)ptStart);
		}
		if (dEnd>1.0E-5 && dEnd<dDistance-1.0E-5)
		{
			arPoint.append((AcGePoint3d)ptEnd);
		}
		
		XLine line(ptStart, ptEnd, LS_FINITE);
		XCurveSegment seg;
		seg = line;
		lstBreakCurve.Append(new XCurveSegment(seg));
	}
}



//////////////////////////////////其他/////////////////////////////////////////
// 交换风管的起止点和连接的接点ID
void TDbDuct::SwitchVane()
{
	TchPrivate::Exchange(StartPoint(), EndPoint());
	TchPrivate::Exchange(m_nodeStart, m_nodeEnd);
}

double TDbDuct::CalVelocity() const // 计算风速
{
	double dVelocity(0.0);
	if (m_nSection == 0) // 矩形
	{
		if ((m_dWidth > 1.0E-6) && (m_dHeight > 1.0E-6))
		{
			dVelocity = m_dCalWeight/(3.6E-3 * m_dWidth * m_dHeight);
		}
	}
	else if (m_nSection == 1) // 圆形
	{
		if (m_dWidth > 1.0E-6)
		{
			dVelocity = m_dCalWeight/(9.0E-4 * PI * pow(m_dWidth, 2));
		}
	}

	CString csTmp;
	csTmp.Format(_T("%.2f"), dVelocity);
	dVelocity = _tstof(csTmp);
	return dVelocity;
}




//////////////////////////////////////////////////////////////////////////
void InitDbDuct(BOOL bTrue)
{
    if (bTrue)
	{
        TDbDuct::rxInit();
        TDbDuct::InitMatchProtocol(TRUE);
    } 
	else
	{
        TDbDuct::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbDuct::desc());
    }
}





/////////////////////////////////////////////////////////////////////////////////
//                           所需要的全局函数
/////////////////////////////////////////////////////////////////////////////////
/*============================================================================*
* 函 数 名：    GetSquare
* 功能描述：    获取矩形风管的截面
    ——>dAngle  
    pt4------dWide-----pt1    |
     |                  |     |
	 |                  |     |
   ptTmp2----ptCen----ptTmp1  dHigh
     |                  |     |
	 |                  |     |
    pt3----------------pt2    |
==============================================================================*/
void GetSquare(const XPoint &ptCen, const double &dAngle, const double &dWide,
			   const double &dHigh, XPoly2D* poly, XPoly2D* vDuctPoly)
{
	XPoint ptTmp1, ptTmp2, pt1, pt2, pt3, pt4, pt5;
	ads_polar(ptCen, dAngle, 0.5*dWide, ptTmp1);
	ads_polar(ptCen, dAngle, -0.5*dWide, ptTmp2);
	
	ads_polar(ptTmp1, dAngle+PI/2, 0.5*dHigh, pt1);
	ads_polar(ptTmp1, dAngle-PI/2, 0.5*dHigh, pt2);
	ads_polar(ptTmp2, dAngle-PI/2, 0.5*dHigh, pt3);
	ads_polar(ptTmp2, dAngle+PI/2, 0.5*dHigh, pt4);
	
	poly->Reset();
	poly->SetFlag(1);
	poly->AppendNode(pt1);
	poly->AppendNode(pt2);
	poly->AppendNode(pt3);
	poly->AppendNode(pt4);
	
	if (vDuctPoly != NULL) { // 注：立管用
		double dAng = ads_angle(ptCen, pt4),
			dDist = pt4.Distance(ptCen);
		ads_polar(ptCen, dAng, 0.5*dDist, pt5);

		vDuctPoly->Reset();
		vDuctPoly->SetFlag(0);
		vDuctPoly->AppendNode(pt1);
		vDuctPoly->AppendNode(pt5);
		vDuctPoly->AppendNode(pt3);
	}
}





/*============================================================================*
* 函 数 名：    GetWidths
* 功能描述：    获取一组风管的管径
==============================================================================*/
AcGeDoubleArray GetWidths(AcDbObjectId id, const DList<AcDbObjectId> &ids,
						  const AcDbIntArray &aryTypes)
{
	AcGeDoubleArray widthArray;
	int nLen = ids.Length();
	for (int i=0; i<nLen; i++)
	{
		double dWidth(0);
		int nType = aryTypes[i];
		if ((nType == 1) || (nType == 2)) // 此时的id一定不为空
		{
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuctNode, pNode);
			if (pNode == NULL)
			{
				return widthArray;
			}
			
			int nIndex = pNode->FindIdInLink(ids[i]);
			if (nIndex != -1) // 存在连接关系
			{
				dWidth = pNode->GetIWidth(nIndex);
			}
			OPENOBJ_END();
		}
		else
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, TDbDuct, pDuct);
			if (pDuct != NULL)
			{
				dWidth = pDuct->GetWidth();
			}
			OPENOBJ_END();
		}
		widthArray.append(dWidth);
	}
	return widthArray;
}

/*============================================================================*
* 函 数 名：    GetHeights
* 功能描述：    获取一组风管的高度
==============================================================================*/
AcGeDoubleArray GetHeights(AcDbObjectId id, const DList<AcDbObjectId> &ids,
						   const AcDbIntArray &aryTypes)
{
	AcGeDoubleArray heightArray;
	int nLen = ids.Length();
	for (int i=0; i<nLen; i++)
	{
		double dHeight(0);
		int nType = aryTypes[i];
		if ((nType == 1) || (nType == 2)) // 此时的id一定不为空
		{
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuctNode, pNode);
			if (pNode == NULL)
			{
				return heightArray;
			}
			
			int nIndex = pNode->FindIdInLink(ids[i]);
			if (nIndex != -1) // 存在连接关系
			{
				dHeight = pNode->GetIHeight(nIndex);
			}
			OPENOBJ_END();
		}
		else
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, TDbDuct, pDuct);
			if (pDuct != NULL)
			{
				dHeight = pDuct->GetHeight();
			}
			OPENOBJ_END();
		}
		heightArray.append(dHeight);
	}
	return heightArray;
}

/*============================================================================*
* 函 数 名：    GetSegs
* 功能描述：    获取一组风管的中心线
==============================================================================*/
void GetSegs(AcDbObjectId id, XPoint ptLoc, const DList<AcDbObjectId> &ids,
			 const AcDbIntArray &aryTypes, DList<XCurveSegment> &lstSeg)
{
	int nLen = ids.Length();
	for (int i=0; i<nLen; i++)
	{
		XPoint pt1;
		XVector3D vt;
		int nType = aryTypes[i];
		if ((nType == 1) || (nType == 2)) // 此时的id一定不为空
		{
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuctNode, pNode);
			if (pNode == NULL)
			{
				return;
			}

			int nIndex = pNode->FindIdInLink(ids[i]);
			if (nIndex != -1) // 存在连接关系
			{
				pt1 = pNode->GetILocation(nIndex);
				vt = pNode->GetIDirection(nIndex);
			}
			OPENOBJ_END();
		}
		else
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, TDbDuct, pDuct);
			if (pDuct != NULL)
			{
				TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
				vt = pDuct->GetDirection(ptLoc, nSide);
				pt1 = pDuct->GetVertexPt(nSide);
			}
			OPENOBJ_END();
		}

		vt.Normalize();
		vt.Scale(100);
		XPoint pt2 = pt1 + vt;
		lstSeg.Append(new XCurveSegment(pt1, pt2, 0, LS_FINITE));
	}
}

/*============================================================================*
* 函 数 名：    GetVectors
* 功能描述：    获取一组风管的法向
* 备    注：    离指定点较近的端点——>较远的端点
==============================================================================*/
void GetVectors(AcDbObjectId id, XPoint ptLoc, const DList<AcDbObjectId> &ids,
				const AcDbIntArray &aryTypes, DList<XVector3D> &lstVt)
{
	int nLen = ids.Length();
	for (int i=0; i<nLen; i++)
	{
		XVector3D vt;
		int nType = aryTypes[i];
		if ((nType == 1) || (nType == 2)) // 此时的id一定不为空
		{
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuctNode, pNode);
			if (pNode == NULL)
			{
				return;
			}

			int nIndex = pNode->FindIdInLink(ids[i]);
			if (nIndex != -1) // 存在连接关系
			{
				vt = pNode->GetIDirection(nIndex);
			}
			OPENOBJ_END();
		}
		else
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, TDbDuct, pDuct);
			if (pDuct != NULL)
			{
				TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
				vt = pDuct->GetDirection(ptLoc, nSide);
			}
			OPENOBJ_END();
		}
		lstVt.Append(new XVector3D(vt));
	}
}

/*============================================================================*
* 函 数 名：    GetAngles
* 功能描述：    获取一组风管的法向
* 备    注：    与GetVectors一致
==============================================================================*/
AcGeDoubleArray GetAngles(AcDbObjectId id, XPoint ptLoc, const DList<AcDbObjectId> &ids,
						  const AcDbIntArray &aryTypes)
{
	DList<XVector3D> lstVts;
	::GetVectors(id, ptLoc, ids, aryTypes, lstVts);

	AcGeDoubleArray angleArray;
	int nLen = lstVts.Length();
	for (int i=0; i<nLen; i++)
	{
		double dAng = ads_angle(XPoint(), *lstVts[i]);
		angleArray.append(dAng);
	}
	return angleArray;
}

/*============================================================================*
* 函 数 名：    GetPtLocations
* 功能描述：    获取一组风管中，离指定点较近的端点的位置（是起点，还是终点）
==============================================================================*/
void GetPtLocations(AcDbObjectId id, XPoint ptLoc, const DList<AcDbObjectId> &ids,
					const AcDbIntArray &aryTypes, DList<TPipeSys::PtLoction> &lstLoc)
{
	int nLen = ids.Length();
	for (int i=0; i<nLen; i++)
	{
		int nType = aryTypes[i];
		TPipeSys::PtLoction nSide = TPipeSys::kStartPt;
		if ((nType == 1) || (nType == 2))
		{
			OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuctNode, pNode);
			if (pNode == NULL)
			{
				return;
			}
			
			int nIndex = pNode->FindIdInLink(ids[i]);
			if (nIndex != -1) // 存在连接关系
			{
				TPipeSys::FlowLet nLet = pNode->GetIFlowDir(nIndex);
				if (nLet == TPipeSys::kInlet)
				{
					nSide = TPipeSys::kEndPt;
				}
			}
			OPENOBJ_END();
		}
		else
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, TDbDuct, pDuct);
			if (pDuct != NULL)
			{
				pDuct->GetDirection(ptLoc, nSide);
			}
			OPENOBJ_END();
		}
		lstLoc.Append(new TPipeSys::PtLoction(nSide));
	}
}

/*============================================================================*
* 函 数 名：    IsCircleDuct
* 功能描述：    获取某风管是否是圆风管
==============================================================================*/
BOOL IsCircleDuct(AcDbObjectId idNode, AcDbObjectId id, int nType)
{
	int nSection(0);
	if ((nType == 1) || (nType == 2))
	{
		OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbDuctNode, pNode);
		if (pNode != NULL)
		{
			int nIndex = pNode->FindIdInLink(id);
			if (nIndex != -1) // 存在连接关系
			{
				nSection = pNode->GetISection(nIndex);
			}
		}
		OPENOBJ_END();
		return (nSection==1);
	}

	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct != NULL)
	{
		nSection = pDuct->GetSectionType();
	}
	OPENOBJ_END();
	return (nSection == 1);
}

/*============================================================================*
* 函 数 名：    IsVerDuct
* 功能描述：    获取某风管是否是立管
==============================================================================*/
BOOL IsVerDuct(AcDbObjectId idNode, AcDbObjectId id, int nType)
{
	BOOL bIsVDuct(FALSE);
	if ((nType == 1) || (nType == 2))
	{
		OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbDuctNode, pNode);
		if (pNode != NULL)
		{
			int nIndex = pNode->FindIdInLink(id);
			if (nIndex != -1) // 存在连接关系
			{
				XVector3D vt = pNode->GetIDirection(nIndex);
				vt.Normalize();
				bIsVDuct = fabs(vt.x)<1.0E-6 && fabs(vt.y)<1.0E-6;
			}
		}
		OPENOBJ_END();
		return bIsVDuct;
	}

	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDuct, pDuct);
	if (pDuct != NULL)
	{
		TPipeSys::ModelType nMode =	pDuct->GetModelType();
		if (nMode == TPipeSys::kModel) // 模型图
		{
			bIsVDuct = pDuct->IsVertical();
		}
		else if (nMode == TPipeSys::kSystem) // 系统图
		{
			XVector3D vt = pDuct->EndPoint() - pDuct->StartPoint();
			vt.Normalize();
			bIsVDuct = fabs(vt.z)>0.001;
		}
	}
	OPENOBJ_END();
	return bIsVDuct;
}