#include "stdafx.h"
#include "TDbColumn.h"
#include "TDbWallPatch.h"

inline CString DoubleToString(double dValue, int nPreci)
{
	CString csRet;
	CString csFormat;
	csFormat.Format(_T("%%.%df"), nPreci);
	csRet.Format(csFormat, dValue);
	return csRet;
}

const Adesk::UInt8 TDbApron::g_nVersion = 1;

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


//////////////////////////////////////////////////////////////////////
TDbApron::TDbApron()
{
	m_dInHeight = _AS_SYS_UNIT(20);
	m_dOutHeight = _AS_SYS_UNIT(10);
	m_nFlag = 0;
}

TDbApron::~TDbApron()
{
	ReleaseEntSet(m_entSet); // sg add 090521，释放掉外边界点
}


//////////////////////////////////////////////////////////////////////
void TDbApron::SetInHeight(double dHeight)
{
	assertWriteEnabled();
	m_dInHeight = dHeight;
}

double TDbApron::GetInHeight() const
{
	assertReadEnabled();
	return m_dInHeight;
}

void TDbApron::SetOutHeight(double dHeight)
{
	assertWriteEnabled();
	m_dOutHeight = dHeight;
}

double TDbApron::GetOutHeight() const
{
	assertReadEnabled();
	return m_dOutHeight;
}

void TDbApron::SetDistArray(const Array<double> &aryDist)
{
	assertWriteEnabled();
	m_aryDist = aryDist;
}

void TDbApron::GetDistArray(Array<double> &aryDist) const
{
	assertReadEnabled();
	aryDist = m_aryDist;
}



//////////////////////////////////////////////////////////////////////
int TDbApron::GetDistNum() const
{
	return m_aryDist.GetLength();
}

void TDbApron::SetAllDists(double dDist, long lLength)
{
	assertWriteEnabled();
	if (GetDistNum() != 0)
	{
		m_aryDist.Clear(); // 首先清空
	}

	if (lLength == -1) // 使用路径的段数
	{
		lLength = m_polyBase.TotalSegments();
	}

	m_aryDist.Realloc(lLength);
	m_aryDist.SetAll(dDist);
}

BOOL TDbApron::SetDistAt(long lIndex, double dDist)
{
	assertWriteEnabled();
	int nLength = GetDistNum();
	if (lIndex<0 || lIndex>nLength-1)
	{
		return FALSE;
	}

	m_aryDist.SetAt(lIndex, dDist);
	return TRUE;
}

double TDbApron::GetDistAt(long lIndex) const
{
	int nLength = GetDistNum();
	if (lIndex<0 || lIndex>nLength-1)
	{
		return -1;
	}

	return m_aryDist.GetAt(lIndex);
}

BOOL TDbApron::InsertDistAt(long lIndex,  double dDist)
{
	if (lIndex < 0)
	{
		return FALSE;
	}

	int nLength = GetDistNum();
	if (lIndex >= nLength) // 超过数组长度，不考虑位置，在最后添加
	{
		m_aryDist.AddTail(dDist);
	}
	else // 在指定位置插入宽度值
	{
		m_aryDist.Insert(lIndex, dDist);
	}

	int nSegNum = m_polyBase.TotalSegments();
	if (nSegNum==3 && nLength==1 && m_polyBase.IsClosed())
	{
		m_aryDist.AddTail(dDist); // 注：此情况下，需要增加两段
	}
	return TRUE;
}

BOOL TDbApron::RemoveDistAt(long lIndex)
{
	int nLength = GetDistNum();
	if (lIndex<0 || lIndex>=nLength)
	{
		return FALSE;
	}
	m_aryDist.Del(lIndex);

	int nSegNum = m_polyBase.TotalSegments();
	if (nSegNum==1 && nLength==3)
	{
		m_aryDist.DelTail(); // 注：此情况下，需要删除两段
	}
	return TRUE;
}



//////////////////////////////////////////////////////////////////////
void TDbApron::Get2DInPoly(XPoly2D &poly2d) const
{
	assertReadEnabled();
	poly2d = m_polyBase;
	poly2d.SetElevation(0);
}

// aryIndex：polyBase的各顶点对应poly2d的顶点编号
// aryShow：polyBase的各线段对应poly2d的线段编号
BOOL TDbApron::Get2DOutPoly(XPoly2D &poly2d, Array<int> &aryIndex,
							Array<int> &aryShow) const
{
	assertReadEnabled();
	XPoly2D polyBase; // 内侧路径点
	Get2DInPoly(polyBase);
	int nDistNum = GetDistNum(),            // “宽度”数组数量
		nSegNum = polyBase.TotalSegments();	// “段”数
	if (nDistNum!=nSegNum || !IsValid())
		return FALSE;

	double dDist = m_aryDist.GetAt(0);
 	polyBase.QuickOffset(dDist, poly2d); // 首先快速生成一个外侧路径poly2d
	int nTmp = poly2d.TotalSegments();
	if (nTmp != nSegNum) // sg add 090522，当内侧路径有重合时，快速生成的路径数量和原来不一致，导致致命错误
		return FALSE;

	aryIndex.Realloc(polyBase.Length()); // sg add 081013，与内侧顶点对应的外侧顶点编号
	aryIndex.SetAll(0);
	aryShow.Realloc(nDistNum); // 与内侧段对应的外侧段编号
	aryShow.SetAll(0);

	// 以polyBase中的“段”为单位进行循环，对poly2d、aryIndex、aryShow进行修改
	for (int i=0, j=0; i<nSegNum; i++, j++) // sg modify 081013，j为aryShow中的数
	{
		XDirectionCurve cvBase, cvOffset;
		polyBase.Nth(i, cvBase); // 获取当前内侧段
		cvOffset = cvBase.Offset(m_aryDist.GetAt(i), LS_INFINITE); // 外侧段

		int nPrev = i - 1,     // 前一段编号
			nNext = i + 1;     // 后一段编号
		if (poly2d.IsClosed()) // 封闭路径，周期查找
		{
			nPrev = DePeriod(nSegNum, nPrev);
			nNext = DePeriod(nSegNum, nNext);
		}
		
		int nIndex = j; // sg add 081013，aryIndex中的数值
		XPoint ptStart, ptEnd;
		XDirectionCurve cvPrev, cvPrevOffset, cvNext, cvNextOffset;
		if (nPrev>=0 && nPrev<nSegNum) // 第2到最后1段，封闭路径时，包括第1段
		{
			polyBase.Nth(nPrev, cvPrev); // 前一段
			cvPrevOffset = cvPrev.Offset(m_aryDist.GetAt(nPrev), LS_INFINITE);
			
			XPoint ptInt[2];
			int nIntNum = cvOffset.Intersection(cvPrevOffset, ptInt[0], ptInt[1]); // 求交点
			if (nIntNum == 1) // 判断交点个数
			{
				ptStart = ptInt[0];
			}
			else if (nIntNum == 2)
			{
				ptStart = XLine(ptInt[0], ptInt[1]).NearPoint(cvOffset.StartPoint());
			}
			else // 没有交点，sg modfify，081013
			{
				XPoint pt1 = cvOffset.StartPoint(),
					pt2 = cvPrevOffset.EndPoint();
				ptStart = pt1;
				if (pt1.Distance(pt2) > _DIST_SNAP) // 两个偏移后的点不重合，需要加点
				{
					if (i == 0) // sg add 090602，解决首顶点处宽度不一致时，产生错误的情况
						*poly2d[j] = pt2;
					poly2d.SetBulge(j, 0); // 与新增加的点，直线连接
					poly2d.InsertNodeAt(++j, pt1, cvBase.GetBulge());
				}
				
				if (fabs(cvBase.GetBulge())<1.0E-5 && fabs(cvPrev.GetBulge())<1.0E-5) // 两直线
				{
					if (m_aryDist.GetAt(i) > m_aryDist.GetAt(nPrev) + 1.0E-5)
					{
						nIndex++; // pt1离cvBase.StartPoint()较远
					}
				}
				else // 有弧线
				{
					BOOL bSwap(FALSE); // 标记是否有弧段反向
					XPoint ptArcStart, ptArcEnd;
					if (fabs(cvBase.GetBulge()) > 1.0E-5) // 当前段是弧段
					{
						XArc arc = cvBase.GetArc();
						arc.GetStartPoint(ptArcStart);
						arc.GetEndPoint(ptArcEnd);
						bSwap = ptArcStart.Distance(cvPrev.EndPoint()) > _DIST_SNAP; // 弧段反向
					}
					if (!bSwap && fabs(cvPrev.GetBulge())>1.0E-5) // 前一段是弧段
					{
						XArc arc = cvPrev.GetArc();
						arc.GetStartPoint(ptArcStart);
						arc.GetEndPoint(ptArcEnd);
						bSwap = ptArcEnd.Distance(cvBase.StartPoint()) > _DIST_SNAP;
					}

					if (bSwap) // 有弧线产生了反向
					{
						nIndex = -1; // 不绘制“转角线”
					}
					else if (m_aryDist.GetAt(i) > m_aryDist.GetAt(nPrev) + 1.0E-5) // pt1较远
					{
						nIndex++;
						XDirectionCurve(pt1, cvBase.StartPoint()).Intersection(cvPrevOffset,
							ptArcStart, ptArcEnd); // 求交点
						*poly2d[j-1] = XLine(ptArcStart, ptArcEnd).NearPoint(cvOffset.StartPoint());
					}
					else // pt2较远
					{
						XDirectionCurve(pt2, cvBase.StartPoint()).Intersection(cvOffset,
							ptArcStart, ptArcEnd); // 求交点
						ptStart = XLine(ptArcStart, ptArcEnd).NearPoint(cvOffset.StartPoint());
					}
				}
			}
		}
		else // 不封闭路径时的第1段
		{
			ptStart = cvOffset.StartPoint();
		}
		
		if (nNext>=0 && nNext<nSegNum) // 第1到倒数第2段，封闭路径时，包括最后1段
		{
			polyBase.Nth(nNext, cvNext); // 后一段
			cvNextOffset = cvNext.Offset(m_aryDist.GetAt(nNext), LS_INFINITE);
			
			XPoint ptInt[2];
			int nIntNum = cvOffset.Intersection(cvNextOffset, ptInt[0], ptInt[1]); // 求交点
			if (nIntNum == 1) // 判断交点个数
			{
				ptEnd = ptInt[0];
			}
			else if (nIntNum == 2)
			{
				ptEnd = XLine(ptInt[0], ptInt[1]).NearPoint(cvOffset.EndPoint());
			}
			else // 没有交点，sg modfify，081013
			{
				ptEnd = cvOffset.EndPoint(); // 获取最近点
			}
		}
		else // 不封闭路径时的最后1段
		{
			ptEnd = cvOffset.EndPoint();
			aryIndex.SetAt(i+1, j+1); // 不封闭路径时，处理最后1点的对应关系
		}
		
		double dBulge = cvBase.GetBulge();      // 更新点的位置及Bulge
		if (fabs(cvOffset.GetBulge()) > 1.0E-5) // 当前段是弧段，需要修改起点的Bulge
		{
			XPoint ptMid = cvOffset.MidPoint();

			// sg add 091029，解决弧段较小时，出现的反向错误
			XArc arcTmp = cvOffset.GetArc();
			XPoint ptTmpCen = arcTmp.GetCenterPt();

			XLine lineTmp(ptTmpCen, ptMid, LS_FINITE);
			int nSide1 = lineTmp.OnWhichSide(ptStart),
				nSide2 = lineTmp.OnWhichSide(ptEnd);
			BOOL bSame = nSide1==nSide2;

			XArc arc(ptStart, ptMid, ptEnd);
//			if (!!arc) // 新弧有效
			// sg modify 091029，解决弧段较小时，出现的反向错误
			if (!bSame && !!arc) // 新弧有效
			{
				XPoint ptArcStart, ptArcEnd;
				arc.GetStartPoint(ptArcStart);
				arc.GetEndPoint(ptArcEnd);
				dBulge = arc.Bulge();
				if (ptArcStart.Distance(ptStart) > _DIST_SNAP) // 判断是否自动修改了弧的起点、终点
				{
					dBulge *= -1;
				}
			}
		}
		
		aryShow.SetAt(i, j); // sg add 081013
		aryIndex.SetAt(i, nIndex);
		*poly2d[j] = ptStart;
		poly2d.SetBulge(j, dBulge);
		if (j < poly2d.Length() - 1)
		{
			*poly2d[j+1] = ptEnd;
		}
	}
	poly2d.SetElevation(0);
	return TRUE;
}

BOOL TDbApron::Get2DRegion(XPoly2D &poly2d) const
{
    AcGeVector3d vt = m_vtNormal;
    if ((vt==AcGeVector3d(0,0,1)) && !m_polyBase.IsClosed())
	{
		XPoly2D poly1, poly2;
		Get2DInPoly(poly1);
		Array<int> aryIndex, aryShow;
 		if (!Get2DOutPoly(poly2, aryIndex, aryShow))
			return FALSE;

        poly2.Reverse();
		aryIndex.Reverse();
		aryShow.Reverse();

		int nLength = poly2.Length();
        for (int i=0; i<nLength; i++)
		{
			poly1.AppendNode(*poly2[i], poly2.GetBulge(i));
        }
        poly2d = poly1;
		return TRUE;
    }
	return FALSE;
}

BOOL TDbApron::GetShapePoly(long lIndex, XPoly2D &poly) const
{
	double dDist = GetDistAt(lIndex);
	if (dDist < -1.0E-5)
	{
		return FALSE;
	}

	poly.SetFlag(1); // 设置闭合
	XPoint ptVertex;
	poly.AppendNode(ptVertex);
	ptVertex.x += dDist;
	poly.AppendNode(ptVertex);
	ptVertex.y += m_dOutHeight;
	poly.AppendNode(ptVertex);
	ptVertex.x = 0;
	ptVertex.y = m_dInHeight;
	poly.AppendNode(ptVertex);
	return TRUE;
}



//////////////////////////////////////////////////////////////////////
BOOL TDbApron::AddNewVertex(XPoint ptAdd)
{
    assertWriteEnabled();
    XPoint ptOnCurve;
    if (!GetClosestPoint2d(ptAdd, ptOnCurve)) // 获取最近点
	{
		return FALSE;
	}

	XPoly2D poly2d,
		polyPath = m_polyBase;
	Get2DInPoly(poly2d);

	int nPos = HitTestOnBase2d(ptOnCurve);
	if (nPos < 0) // 命中边
	{
		nPos = abs(nPos);
		nPos--; // 获取边的索引号
		ptAdd.z = polyPath[nPos]->z; // 统一标高

		XDirectionCurve seg;
		poly2d.Nth(nPos, seg);
		if (seg.IsMinusArc())
		{
			XArc ar1 = seg.GetArc(),
				ar2 = seg.GetArc();
			ar1.SetAngleByPoints(seg.EndPoint(), ptOnCurve);
			ar2.SetAngleByPoints(ptOnCurve, seg.StartPoint());
			polyPath.SetBulge(nPos, -ar2.Bulge());
			polyPath.InsertNodeAt(nPos+1, ptAdd, ar1.Bulge());
		}
		else
		{
			XCurveSegment seg1 = seg,
				seg2 = seg;
			seg1.SetPoints(seg.StartPoint(), ptOnCurve);
			seg2.SetPoints(ptOnCurve, seg.EndPoint());
			polyPath.SetBulge(nPos, seg1.GetBulge());
			polyPath.InsertNodeAt(nPos+1, ptAdd, seg2.GetBulge());
		}
		m_polyBase = polyPath;
		return TRUE;
	}

	ptAdd.z = 0;
	ptOnCurve.z = 0;
	if (nPos>0 && ptOnCurve!=ptAdd) // 命中顶点
	{
		nPos--; // 获取顶点的索引号
		ptAdd.z = polyPath[nPos]->z; // 统一标高

		int nPrev = nPos - 1, // 前一点
			nNext = nPos + 1; // 后一点
		int nLength = polyPath.Length();
		if (polyPath.IsClosed()) // 封闭路径，周期查找
		{
			nPrev = DePeriod(nLength, nPrev);
			nNext = DePeriod(nLength, nNext);
		}

		BOOL bAddAfter(TRUE); // 标志是否将新点放在最近点之后
		if (nPrev<0 || nPrev>=nLength) // 最近点为首顶点，且路径不闭合
		{
			bAddAfter = FALSE;
		}
		else if (nNext>=0 && nNext<nLength)
		{
			ptOnCurve = ptAdd;
			ptOnCurve.z = 0;
			
			XCurveSegment seg(*poly2d[nPrev], *poly2d[nNext], 0, LS_FINITE); // 前1点及后1点的连线
			double dDistOld = fabs(seg.GetDist2Me(*poly2d[nPos])),
				dDistNew = fabs(seg.GetDist2Me(ptOnCurve));
			if (fabs(dDistOld - dDistNew) < _DIST_SNAP) // 距离连线的距离相等，比较左右情况
			{
				seg.SetPoints(*poly2d[nPrev], *poly2d[nPos]);
				int nRet = seg.OnWhichSide(ptOnCurve);
				bAddAfter = nRet==0; // 在右侧时，应该在最近点之前添加新点
			}
			else if (dDistOld > dDistNew + _DIST_SNAP) // 新点距离连线近
			{
				bAddAfter = FALSE;
			}
			else // 新点距离连线远
			{
				seg.SetPoints(*poly2d[nPos], *poly2d[nNext]);
				int nRet = seg.OnWhichSide(ptOnCurve);
				bAddAfter = nRet!=2; // 注：防止新点、最近点和下一点共线
			}
		}

		if (bAddAfter) // 放到最近点之后，否则放在最近点之前
		{
			nPos++;
		}
		polyPath.InsertNodeAt(nPos, ptAdd);
		m_polyBase = polyPath;
		return TRUE;
	}
	return FALSE;
}

Acad::ErrorStatus TDbApron::SetPathPoly(const XPoly2D &polyPath, const AcGeVector3d&normal)
{
	Acad::ErrorStatus es = TDbPolyCurveEnt::SetPathPoly(polyPath, normal);

	XPoly2D poly2d;
	Get2DInPoly(poly2d);

	int nSegNum = poly2d.TotalSegments(),
		nDistNum = GetDistNum();
	while (nSegNum > nDistNum)
	{
		InsertDistAt(nDistNum, _AS_SYS_UNIT(600));
		nDistNum++;
	}
	
	while (nSegNum < nDistNum)
	{
		RemoveDistAt(nDistNum-1);
		nDistNum--;
	}
	return es;
}


//////////////////////////////////////////////////////////////////////
double TDbApron::GetPathLength() const
{
    return m_polyBase.Distance3d();
}

double TDbApron::GetShapePerimeter(long lIndex) const
{
	XPoly2D poly2d;
	if (GetShapePoly(lIndex, poly2d)) // 获取指定段的截面
	{
		return poly2d.Distance2d();
	}
	return 0.0;
}

double TDbApron::GetShapeArea(long lIndex) const
{
	XPoly2D poly2d;
	if (!GetShapePoly(lIndex, poly2d)) // 获取指定段的截面
	{
		return 0.0;
	}
	
	if (!poly2d.IsClosed()) // 不闭合，不考虑面积
	{
		return 0.0;
	}
	return poly2d.Area();
}

double TDbApron::GetSideArea() const
{
	double dArea(0.0);
	int nLength = GetDistNum(); // 段数
	for (int i=0; i<nLength; i++)
	{
		double dPathLength = m_polyBase.Distance3d(i);
		dArea += GetShapePerimeter(i)*dPathLength;
	}
    return dArea;
}

double TDbApron::GetVolume() const
{
	double dVolume(0.0);
	int nLength = GetDistNum(); // 段数
	for (int i=0; i<nLength; i++)
	{
		double dPathLength = m_polyBase.Distance3d(i);
		dVolume += GetShapeArea(i)*dPathLength;
	}
    return dVolume;
}



//////////////////////////////////////////////////////////////////////
BOOL TDbApron::IsValid() const
{
	BOOL bRet = TDbPolyCurveEnt::IsValid();
	if (!bRet)
	{
		return bRet;
	}

	bRet = (m_polyBase.Length()>1 && m_aryDist.GetLength()>0);
	return bRet;
}

bool TDbApron::IsClipMe(const TEntityBase* pEnt)const
{
	if (TEntityBase::IsClipMe(pEnt))
	{
		return true;
	}
	
	//if (pEnt->GetMe()->isKindOf(TDbColumn::desc())||   // 柱子
	//	pEnt->GetMe()->isKindOf(TDbWallPatch::desc())) // 墙体附件
	//{
	//	return true;
	//}
	// sg modify 110504，根据8.5测试反馈，修改为内凹墙体造型不遮挡散水
	if (pEnt->GetMe()->isKindOf(TDbColumn::desc()))  // 柱子
	{
		return true;
	}

	if (pEnt->GetMe()->isKindOf(TDbWallPatch::desc())) // 墙体附件
	{
		TDbWallPatch *pWallPatch = TDbWallPatch::cast(pEnt->GetMe());
		if (pWallPatch != NULL)
		{
			if (pWallPatch->GetUsageFlag() == TDbWallPatch::kConcave) // 内凹墙体造型不遮挡散水
			{
				return false;
			}
			return true;
		}
	}

	TDbWall *pWall = TDbWall::cast(pEnt->GetMe());
	if (pWall != NULL)
	{
		if (pWall->HasOpeningOutWall())
			return true;
	}
	else
	{
		TDbOpening *pOpen = TDbOpening::cast(pEnt->GetMe());
		if (pOpen != NULL)
		{
			// 未处理组合门窗...
			if (pOpen->GetKind() == TOpeningData::OP_PROWIN) // 窗
			{
				return true;
			}
		}
		else
		{
			TDbCornerWin* pCornerWin = TDbCornerWin::cast(pEnt->GetMe());
			if (pCornerWin!=NULL && pCornerWin->IsProtrude()) // 角窗
			{
				return true;
			}
			else
			{
				TDbBalcony *pBalcony = TDbBalcony::cast(pEnt->GetMe());
				if (pBalcony != NULL) // 阳台
				{
					return true;
				}
				else
				{
					TDbAscent *pAscent = TDbAscent::cast(pEnt->GetMe());
					if (pAscent != NULL) // 坡道
					{
						return true;
					}
					else
					{
						TDbStep *pStep = TDbStep::cast(pEnt->GetMe());
						if (pStep != NULL) // 台阶
						{
							return true;
						}
					}
				}
			}
		}
	}
	return false;
}



//////////////////////////////////////////////////////////////////////
void TDbApron::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbPolyCurveEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbApron *pSrc = TDbApron::cast(pSrcEntity);
	if (pSrc != NULL)
	{
		m_dInHeight = pSrc->m_dInHeight;
		m_dOutHeight = pSrc->m_dOutHeight;
		m_nFlag = pSrc->m_nFlag;

		Array<double> aryDist;
		pSrc->GetDistArray(aryDist);
		SetDistArray(aryDist);

		XPoly2D poly2D;
		AcGeVector3d vec = pSrc->GetNormal();
		double dElev = pSrc->GetElevationAt(0);
		pSrc->GetPathPoly(poly2D, vec);
		poly2D.SetElevation(dElev);
		SetPathPoly(poly2D, vec);		
	}
}

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



//////////////////////////////////////////////////////////////////////
// 从DWG读入数据:
Acad::ErrorStatus TDbApron::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPolyCurveEnt::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_dInHeight);
	pFiler->readItem(&m_dOutHeight);

	if (m_aryDist.GetLength() != 0)
	{
		m_aryDist.Clear();
	}
	Adesk::UInt16 nTemp = 0;
	pFiler->readItem(&nTemp);
	for (Adesk::UInt16 i=0; i<nTemp; i++)
	{
		double dNum(0);
		pFiler->readItem(&dNum);
		m_aryDist.AddTail(dNum);
	}

	pFiler->readItem(&m_nFlag);
	return pFiler->filerStatus();
}

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

	pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_dInHeight);
	pFiler->writeItem(m_dOutHeight);

	Adesk::UInt16 nCount = (Adesk::UInt16)m_aryDist.GetLength();
	pFiler->writeItem(nCount);
	for (Adesk::UInt16 i=0; i<nCount; i++)
	{
		double dNum = m_aryDist.GetAt(i);
		pFiler->writeItem(dNum);
	}

	pFiler->writeItem(m_nFlag);
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbApron::dxfInFields (AcDbDxfFiler* pFiler)
{
	Acad::ErrorStatus es = TDbPolyCurveEnt::dxfInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	if (!pFiler->atSubclassData(_T("TDbApron")))
	{
		return Acad::eBadDxfSequence;
	}

	resbuf rb;
	Adesk::UInt32 nFlag = 0;
	Array<double> aryDist;
	double dInHeight(0), dOutHeight(0);
	while ((es==Acad::eOk) && ((es=pFiler->readResBuf(&rb))==Acad::eOk))
	{
		switch(rb.restype)
		{
		case AcDb::kDxfAngle:
			dInHeight = rb.resval.rreal;
			break;
		case AcDb::kDxfAngle+1:
			dOutHeight = rb.resval.rreal;
			break;
		case AcDb::kDxfAngle+2:
			aryDist.AddTail(rb.resval.rreal);
		    break;
		case AcDb::kDxfInt32:
			nFlag = rb.resval.rlong;
			break;
		default:
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
		    break;
		}
	}
	if (es != Acad::eEndOfFile)
	{
		return Acad::eInvalidResBuf;
	}

	long lCount = aryDist.GetLength();
	if (lCount < 1)
	{
        pFiler->setError(_T("\nError DXF group code: 11, 51"));
        return Acad::eMissingDxfField;
	}

	m_dInHeight = dInHeight;
	m_dOutHeight = dOutHeight;

	if (m_aryDist.GetLength() != 0)
	{
		m_aryDist.Clear();
	}
	for (long i=0; i<lCount; i++)
	{
		double dNum = aryDist.GetAt(i);
		m_aryDist.AddTail(dNum);
	}

	m_nFlag = nFlag;
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbApron::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	Acad::ErrorStatus es = TDbPolyCurveEnt::dxfOutFields(pFiler);
	assert(es == Acad::eOk);
	es = pFiler->writeItem(AcDb::kDxfSubclass, _T("TDbApron"));
	assert(es == Acad::eOk);

	pFiler->writeDouble(AcDb::kDxfAngle, m_dInHeight);
	pFiler->writeDouble(AcDb::kDxfAngle+1, m_dOutHeight);

	long lCount = m_aryDist.GetLength();
	for (long i=0; i<lCount; i++)
	{
		double dNum = m_aryDist.GetAt(i);
		pFiler->writeDouble(AcDb::kDxfAngle+2, dNum);
	}
	pFiler->writeInt32(AcDb::kDxfInt32, m_nFlag);
	return es;
}



//////////////////////////////////////////////////////////////////////
Acad::ErrorStatus TDbApron::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();

	TDbPolyCurveEnt::subTransformBy(xform);
 	if (IsMirrorMatrix(xform))
	{
		m_polyBase.Reverse();
		m_aryDist.Reverse();
		return Acad::eOk;
	}
	return Acad::eOk;
}

// sg modify 090521
Acad::ErrorStatus TDbApron::subGetOsnapPoints(AcDb::OsnapMode		osnapMode,
										   INT_PTR					gsSelectionMark,
										   const AcGePoint3d&	pickPoint,
										   const AcGePoint3d&	lastPoint,
										   const AcGeMatrix3d&	viewXform,
										   AcGePoint3dArray&	snapPoints,
										   AcDbIntArray&		geomIds) const
{
	assertReadEnabled();
	int nCount = m_entSet.length();
	for (int i=0; i<nCount; i++)
	{
		AcDbEntity *pEnt = (AcDbEntity *)m_entSet[i];
		pEnt->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint,
			viewXform, snapPoints, geomIds);
	}
	return Acad::eOk;
}


Acad::ErrorStatus TDbApron::subGetGripPoints(AcGePoint3dArray&  gripPoints,
										  AcDbIntArray&  osnapModes,
										  AcDbIntArray&  geomIds) const
{
	TDbPolyCurveEnt::subGetGripPoints(gripPoints, osnapModes, geomIds);

	XPoly2D poly2D;	// 外侧线
	Array<int> aryIndex, aryShow;	
	if (!Get2DOutPoly(poly2D, aryIndex, aryShow))
		return Acad::eOk;

	double dElev = GetElevationAt(0); // 获取路径标高
	poly2D.SetElevation(dElev);
	
	int nLength = aryShow.GetLength();
	for (long i=0; i<nLength; i++)
	{
		XDirectionCurve cv;
		int nNum = aryShow.GetAt(i); // polyIn的各段对应polyOut的段编号
		poly2D.Nth(nNum, cv);

		XPoint ptMid = cv.MidPoint();
		gripPoints.append(ptMid); // 增加外侧边中点为改变宽度的夹点
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbApron::subMoveGripPointsAt(const AcDbIntArray& indices,
											 const AcGeVector3d& offset)
{
	assertWriteEnabled();
	double dElev = GetElevationAt(0);
 	TDbPolyCurveEnt::subMoveGripPointsAt(indices, offset);
	m_polyBase.SetElevation(dElev); // 统一标高

	int nVertexCount = m_polyBase.Length(); // 路径点数量
	XPoint vtOffset = Wcs2Ecs(*(XPoint *)&offset, m_vtNormal);

	XPoly2D poly2d;
	Array<int> aryIndex, aryShow;
	if (!Get2DOutPoly(poly2d, aryIndex, aryShow))
		return Acad::eOk;

	poly2d.SetElevation(dElev);

	for (int i=0; i<indices.length(); i++)
	{
		int idx = indices[i],
			nTotalEdge = aryShow.GetLength(); // Poly的总边数，“宽度数组”的数量
		int nIndex = idx - nVertexCount - nTotalEdge;
		if (nIndex>=0 && nIndex<nTotalEdge) // 只需要处理用于“改变宽度”的夹点
		{
			XDirectionCurve cv; // 被移动的边，不修改点的位置，只修改宽度
			int nNum = aryShow.GetAt(nIndex);
			poly2d.Nth(nNum, cv);
			ASSERT(!!cv);

			AcGeVector3d vecMove;  // 允许的偏移方向
			if (cv.Is(CURVE_LINE)) // 直线
			{
				AcGeVector3d vecEdge = XVector3D(cv.EndPoint() - cv.StartPoint()).AsAcGeVector3d();
				vecMove = vecEdge.perpVector(); // 垂直方向
			}
			else // 弧线
			{
				XArc arc = cv.GetArc();
				XPoint ptStart, ptEnd, ptMid;
				arc.MidPoint(ptMid);
				arc.GetStartPoint(ptStart);
				arc.GetEndPoint(ptEnd);
				if (ptStart.Distance(cv.StartPoint()) > _DIST_SNAP) // 自动交换了起点、终点
				{
					vecMove = XVector3D(ptMid - arc.GetCenterPt()).AsAcGeVector3d();
				}
				else // 未交换起点、终点
				{
					vecMove = XVector3D(arc.GetCenterPt() - ptMid).AsAcGeVector3d();
				}
			}

			vecMove.normalize();
			double dNewDist = vtOffset.AsAcGeVector3d().dotProduct(vecMove), // 拖拽宽度
				dOldDist = GetDistAt(nIndex);   // 旧宽度 
			double dDist = dOldDist - dNewDist; // 新宽度
			//if (dDist < _DIST_SNAP)           // 只允许往外侧拖拽
			if (dOldDist*dDist < _DIST_SNAP)    // sg add 110126，解决8.5版本支持宽度为负数的情况，只允许往外侧拖拽
			{
				dDist = 0.0;
			}
			SetDistAt(nIndex, dDist);
		}
	}
	return Acad::eOk;
}



//////////////////////////////////////////////////////////////////////
Acad::ErrorStatus TDbApron::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet,
										  BOOL *bErase) // sg add 081021
{
	Acad::ErrorStatus es = Acad::eOk;
	if (g_nSaveTArchVer >= GetFirstVersion()) // 导出为T8格式
	{
		if (bErase)
		{
			*bErase = FALSE;
		}
		es = TDbPolyCurveEnt::DownGradeSave(nDrawMode, entSet, bErase);
	}
	else if (g_nSaveTArchVer == 7) // 导出为T7格式
	{
		Array<double> aryTmp = m_aryDist;
		double dDist = m_aryDist.GetAt(0);
		aryTmp.SetAll(dDist);

		int nLen1 = aryTmp.GetLength(),
			nLen2 = m_aryDist.GetLength();
		BOOL bFlag = nLen1 == nLen2; // 首先判断长度是否相等
		if (bFlag)
		{
			for (int i=0; i<nLen1; i++)
			{
				if (fabs(m_aryDist.GetAt(i)-aryTmp.GetAt(i)) > 1.0E-5)
				{
					bFlag = FALSE; // 再判断内容是否一致
					break;
				}
			}
		}

		if (bFlag) // 一样，存为“路径曲面”对象
		{
			XPoly2D polyShape;
			GetShapePoly(0, polyShape);
			
			TDbCurveMesh2 *pMesh = new TDbCurveMesh2;
			pMesh->CopyPropertiesFrom(this, 0);
			pMesh->SetPathPoly(m_polyBase, GetNormal());
			pMesh->SetShapePoly(polyShape);
			pMesh->SetShapeBase(XPoint());
			pMesh->SetHas2D(TRUE);
			pMesh->SetHasDivide2D(TRUE);
			pMesh->SetHas3D(TRUE);
			pMesh->setLayer(layerId());
			pMesh->setColorIndex(colorIndex());
			entSet.append(pMesh);
			if (bErase)
			{
				*bErase = TRUE;
			}
		}
		else // 不一样，炸开
		{
			XExplodeStream dc(entSet);
			if (!OnExplodeOrDraw(dc)) // sg add 090303，解决导出后，无遮挡关系的BUG
				return es;

			dc.SetPropertiesFrom(this);
			if (nDrawMode == DRAW_2D)
				es = ExplodeOrDraw2d(dc);
			else
				es = ExplodeOrDraw3d(dc);
			if (bErase)
				*bErase = TRUE;
		}
	}
	else // 导出为T3、T5、T6格式，炸开
	{
		XExplodeStream dc(entSet);
		if (!OnExplodeOrDraw(dc)) // sg add 090303，解决导出后，无遮挡关系的BUG
			return es;
		
		dc.SetPropertiesFrom(this);
		if (nDrawMode == DRAW_2D)
			es = ExplodeOrDraw2d(dc);
		else
			es = ExplodeOrDraw3d(dc);
		if (bErase)
			*bErase = TRUE;
	}
	return es;
}

// 绘制2D的显示，注：目前只考虑是散水对象
Acad::ErrorStatus TDbApron::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	assertReadEnabled();
	if (!IsValid()) // sg add 090601，只有一个点时，不绘制
		return Acad::eNotApplicable;

	// add by whl on 090324，捕捉时加速
	// sg modify 090521，解决加速后，散水外侧路径线，无捕捉问题
	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 || g_bOsnapExpl)
	{
		ReleaseEntSet(m_entSet); // sg modify 090521
	
		XPushMemVar<BOOL> bExpl(g_bOsnapExpl, FALSE);
		XPushMemVar<BOOL> bFull(XExplodeStream::m_bFullExplode, TRUE);
//		AcDbVoidPtrArray entSet; // sg delete 090521
//		XExplodeStream dcExp(entSet);
		XExplodeStream dcExp(m_entSet);
		dcExp.SetPropertiesFrom(this);

		//add by xlc on 100430 解决散水移动时速度慢的问题
		if (dc.IsDragging())
		{
			dcExp.SetIsDragging(Adesk::kTrue);
		}
		
		if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) // add by whl on 090427
			OnExplodeOrDraw(dcExp); // add by whl on 090423
		
		ExplodeOrDraw2d(dcExp);
		
		int nGsMarker = 1;
		INT_PTR nQuickMarker = GetQuickMarker();
//		int nCount = entSet.length(); // sg modify 090521
		int nCount = m_entSet.length();
	
		for (int i=0; i<nCount; i++)
		{
//			AcDbEntity *pEnt = (AcDbEntity *)entSet[i]; // sg modify 090521
			AcDbEntity *pEnt = (AcDbEntity *)m_entSet[i];
			dc.SetSelectionMarker(nGsMarker);
			nGsMarker++;
            if (nQuickMarker && (nGsMarker-1)!=nQuickMarker)
                continue;

			dc.DrawEntity(*pEnt);
            if (nQuickMarker && (nGsMarker-1)==nQuickMarker)
                break;
		}
	
//		ReleaseEntSet(entSet); // sg delete 090521
		return Acad::eOk;
	}

	AcGeVector3d vt;
	vt = m_vtNormal;
	if (vt == AcGeVector3d(0, 0, 1))
	{
		XPoly2D polyIn, polyOut;
		Get2DInPoly(polyIn);
		dc << polyIn; // 内侧线

		Array<int> aryIndex, aryShow;
		if (!Get2DOutPoly(polyOut, aryIndex, aryShow))
			return Acad::eOk;
		int nLength = aryShow.GetLength();
		if (nLength == polyIn.TotalSegments())
		{
			for (long i=0; i<nLength; i++) // 外侧线
			{
				XCurveSegment cv;
				int nNum = aryShow.GetAt(i); // polyIn的各段对应polyOut的段编号
				polyOut.Nth(nNum, cv);
 				dc << cv;
			}
		}
		
		nLength = polyIn.Length();
		if (nLength == aryIndex.GetLength()) // 转角线
		{
			for (long i=0; i<nLength; i++)
			{
				int nNum = aryIndex.GetAt(i); // polyIn的各顶点对应polyOut的顶点编号
				if (nNum != -1)
				{
					dc << XLine(*polyIn[i], *polyOut[nNum]);
				}
			}
		}
	}
	else
	{
		ExplodeOrDraw3d(dc);
	}
	return Acad::eOk;
}

// 绘制3D的显示，注：有部分内容是根据散水对象做的特殊处理
Acad::ErrorStatus TDbApron::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	assertReadEnabled();
	extern int GetCirDivNum(double r, double h);
	extern double g_nCirDeviation;

	DList<XPoly2D> lstPolys;
	DList<Adesk::UInt8> lstColVis;

	XPoly2D polyIn2d, polyOut2d;
	Array<int> aryIndex, aryShow;
	Get2DInPoly(polyIn2d);
	if (!Get2DOutPoly(polyOut2d, aryIndex, aryShow))
		return Acad::eOk;
	lstPolys.Append(new XPoly2D(polyIn2d)); // 路径曲线，基线
	lstColVis.Append(new Adesk::UInt8(TRUE));
	lstPolys.Append(new XPoly2D(polyOut2d)); // 外侧线
	lstColVis.Append(new Adesk::UInt8(TRUE));

	XPoly2D polyIn3d = polyIn2d,
		polyOut3d = polyOut2d;
	polyIn3d.SetElevation(m_dInHeight);
	polyOut3d.SetElevation(m_dOutHeight);
	lstPolys.Append(new XPoly2D(polyOut3d));
	lstColVis.Append(new Adesk::UInt8(TRUE));
	lstPolys.Append(new XPoly2D(polyIn3d));
	lstColVis.Append(new Adesk::UInt8(TRUE));

	lstPolys.Append(new XPoly2D(polyIn2d)); // 注：截面曲线为封闭曲线
	lstColVis.Append(new Adesk::UInt8(TRUE));

	double dElev = GetElevationAt(0); // 散水各点标高一致
	int nPolyNum = lstPolys.Length(); // 截面点数量=5
	for (int i=0; i<nPolyNum; i++)
	{
		XPoly2D &rPoly = *lstPolys[i];
		int nPtNum = rPoly.Length(); // 各条路径顶点数量
		for (int j=0; j<nPtNum; j++)
		{
			rPoly[j]->z += dElev; // 调整标高
		}
	}

	int nTotalSeg = m_polyBase.TotalSegments(); // 路径段数
	for (int n=0; n<nTotalSeg; n++)
	{
		DList<XDirectionCurve> lstCurves; // 构成每“段”的五条边
		for (int j=0; j<nPolyNum; j++)
		{
			int nNum = n;
			if (j==1 || j==2) // 对散水对象做的特殊处理，绘制外侧边时，找实际绘制的段
			{
				nNum = aryShow[n];
			}

			XDirectionCurve *pCurve = new XDirectionCurve;
			lstPolys[j]->Nth(nNum, *pCurve);
			lstCurves.Append(pCurve);
		}

		int nDiv = 30;
		XDirectionCurve mSeg;
		polyIn2d.Nth(n, mSeg);
		if (mSeg.Is(CURVE_ARC)) // 将弧线分成若干段直线
		{
			nDiv = TchExport::GetCirDivNum(mSeg.GetArc().GetRadius(), _AS_SYS_UNIT(TchGeLib::g_nCirDeviation));
		}

		int nStep = AS_INT(fabs(mSeg.GetBulge())/PI/2.0*nDiv);
		if (nStep <= 0)
		{
			nStep = 1;
		}

		int nCol = lstCurves.Length(), // =5
			nRow = nStep + 1;		
		XPoint *ptArray = new XPoint[nCol*nRow];
		for (int col=0; col<nCol; col++)
		{
			XDirectionCurve &segThis = *lstCurves[col];
			double nDistStep = segThis.GetLength()/nStep;
			for (int row=0; row<nRow; row++)
			{
				XPointDir2d ptDir2d;
				segThis.Polar(nDistStep*row, ptDir2d);
				ptArray[row*nCol+col] = ptDir2d;
			}
		}
		
		int nEdgeNum = nRow*(nCol-1) + nCol*(nRow-1);
		Adesk::UInt8 *pVisArray = new Adesk::UInt8[nEdgeNum]; // 控制各个边是否可见
		for (int k=0; k<nEdgeNum; k++)
		{
			pVisArray[k] = kAcGiVisible; // 每个边都可见
		}
		
		for (k=1; k<nRow-1; k++) // 除首末行外，其余各行的边均不可见
		{
			for (int j=0; j<nCol-1; j++)
			{
				pVisArray[k*(nCol-1)+j] = kAcGiInvisible;
			}
		}

		int nIndexBase = nRow*(nCol-1);
		for (col=0; col<nCol; col++)
		{
			Adesk::UInt8 bVis = *lstColVis[col];
			for (int row=0; row<nRow-1; row++)
			{
				pVisArray[nIndexBase+col*(nRow-1)+row] = bVis;
			}
		}
		
		int nVertexNum = nCol*nRow;
		for (k=0; k<nVertexNum; k++)
		{
			ptArray[k] = Ecs2Wcs(ptArray[k], m_vtNormal);
		}
		
		AcGiEdgeData edgeInfo;
		edgeInfo.setVisibility(pVisArray);
		dc.DrawMesh(nRow, nCol, (AcGePoint3d *)ptArray, &edgeInfo);
		if (n==0 && !polyIn2d.IsClosed())
		{
			XPoly2D polyTemp1(1);
			for (col=0; col<nCol-1; col++)
			{
				polyTemp1.AppendNode(ptArray[col]);
			}
			dc.DrawShell(polyTemp1, DList<XPoly2D>());
		}

		if (n==nTotalSeg-1 && !polyIn2d.IsClosed())
		{
			XPoly2D polyTemp2(1);
			for (col=0; col<nCol-1; col++)
			{
				polyTemp2.AppendNode(ptArray[(nRow-1)*nCol+col]);
			}
			dc.DrawShell(polyTemp2, DList<XPoly2D>());
		}
		delete []pVisArray;
		delete []ptArray;
	}
	return Acad::eOk;
}


//////////////////////////////////////////////////////////////////////
void TDbApron::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
	lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("散水")));
	lstInfo.Append(new TObjInfoUnit(_T("路径长度"), Dist2Str(GetPathLength())));
 	lstInfo.Append(new TObjInfoUnit(_T("侧面面积"), XString(_T("%.2f"), _AS_SQMETER(GetSideArea()))));
 	lstInfo.Append(new TObjInfoUnit(_T("体积"), XString(_T("%.3f"), _AS_CUMETER(GetVolume()))));
}

// 取得夹点说明
Acad::ErrorStatus TDbApron::GetGripText(int idx, CString &cs) const
{
    Acad::ErrorStatus es = TDbPolyCurveEnt::GetGripText(idx, cs);
    if (es == Acad::eOk)
	{
        return es;
	}
	
	int nVertexCount = m_polyBase.Length(),
		nTotalEdge = m_polyBase.TotalSegments();
	int nIndex = idx - nVertexCount - nTotalEdge;
	if (nIndex>=0 && nIndex<nTotalEdge) // 只需要处理用于“改变宽度”的夹点
	{
		cs.Format(_T("改变第%d条边宽度"), nIndex+1);
	}
	return Acad::eOk;
}


//////////////////////////////////////////////////////////////////////
void TDbApron::ModifyAllDistByOld(TDbApron *pNewApron) const
{
	pNewApron->SetAllDists(_AS_SYS_UNIT(600)); // 保证数组长度与新实体中的路径段数一致

	XPoly2D polyOld2D, poly2D;
	Get2DInPoly(polyOld2D);         // 获取当前的POLY
	pNewApron->Get2DInPoly(poly2D); // 获取操作后新产生的POLY

	int nSegCount = poly2D.TotalSegments();
	for (long j=0; j<nSegCount; j++)
	{
		XPoint ptNew = *poly2D[j];
		int nRet = polyOld2D.HitTestOnCurve(ptNew);
		if (nRet != 0) // 命中的是边或顶点
		{
			nRet = abs(nRet) - 1;
			double dDist = GetDistAt(nRet);
			if (dDist < -1.0E-5)
			{
				continue;
			}

			pNewApron->SetDistAt(j, dDist);
		}
	}
}

// TRIM调用
Acad::ErrorStatus TDbApron::getSplitCurves(const AcGeDoubleArray& params,
										   AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
 	Acad::ErrorStatus es = TDbPolyCurveEnt::getSplitCurves(params, curveSegments);
	int nLength = curveSegments.length();
	for (long i=0; i<nLength; i++)
	{
		TDbApron *pApron = (TDbApron*)curveSegments[i];
		pApron->m_polyBase.SetFlag(0); // 强制修改为不闭合
		ModifyAllDistByOld(pApron);
	}
	return es;
}

// BREAK调用
Acad::ErrorStatus TDbApron::getSplitCurves(const AcGePoint3dArray& points,
										   AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbPolyCurveEnt::getSplitCurves(points, curveSegments);
	int nLength = curveSegments.length();
	for (long i=0; i<nLength; i++)
	{
		TDbApron *pApron = (TDbApron*)curveSegments[i];
		pApron->m_polyBase.SetFlag(0); // 强制修改为不闭合
		ModifyAllDistByOld(pApron);
	}
	return es;
}

// OFFSET调用
Acad::ErrorStatus TDbApron::getOffsetCurves(double offsetDist,
											AcDbVoidPtrArray& offsetCurves) const
{
	XPoly2D polyOld2D;
	AcDbPolyline pline;
	Get2DInPoly(polyOld2D);
    PolyConvert(polyOld2D, pline); // 转化成CAD中的PLINE线

    AcDbVoidPtrArray entSet;
	Acad::ErrorStatus es = pline.getOffsetCurves(offsetDist, entSet);
    if (es == Acad::eOk)
	{
        int nCount = entSet.length();
		double dElev = GetElevationAt(0);
        for (int n=0; n<nCount; n++)
		{
            AcDbEntity *pEnt = (AcDbEntity *)entSet[n];
            if (pEnt->isKindOf(AcDbPolyline::desc()))
			{
				XPoly2D poly2D;
                AcDbPolyline *pCurve = AcDbPolyline::cast(pEnt);
				PolyConvert(*pCurve, poly2D); // 再转化为XPoly2D
				poly2D.SetElevation(dElev);   // 修改标高

				TDbApron *pClone = new TDbApron;
				pClone->setPropertiesFrom(this);
				if (pClone->SetPathPoly(poly2D, GetNormal()) == Acad::eOk)
				{
					offsetCurves.append(pClone);
				}
				else
				{
					delete pClone;
				}
            }
        }
    }
    ReleaseEntSet(entSet);
    return es;
}

#if ADS>14
Acad::ErrorStatus
TDbApron::getOffsetCurvesGivenPlaneNormal(const AcGeVector3d& normal,
										  double offsetDist,
										  AcDbVoidPtrArray& offsetCurves) const
{
	// 注：散水对象为2D实体，忽略normal
    return getOffsetCurves(offsetDist, offsetCurves);
}
#endif


//////////////////////////////////////////////////////////////////////
#if ADS>15
void TDbApron::CreateGrip()
{
	TDbPolyCurveEnt::CreateGrip(); // 由基类添加

	int nSegNum = m_polyBase.TotalSegments(), // 段的数量
		nVertexNum = m_polyBase.Length();     // 点的数量
	long lFirset = nSegNum + nVertexNum;      // 起始编号

	XPoly2D poly2D;	// 外侧线
	Array<int> aryIndex, aryShow;
	if (!Get2DOutPoly(poly2D, aryIndex, aryShow))
		return;
	if (aryShow.GetLength() != nSegNum)
	{
		return;
	}

	for (int i=0; i<nSegNum; i++)
	{
		long iSeg = i + lFirset;
		GetGrip(iSeg)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength));        // 宽度
		GetGrip(iSeg)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength, false)); // 偏移量
	}
}

Acad::ErrorStatus TDbApron::EntityToDim(long iGrip, long iDim, const AcDbEntity *pEnt)
{
	TDbGripDim *pDim = GetGripDim(iGrip, iDim);
	if (pDim == NULL)
	{
		return Acad::eInvalidInput;
	}

	TDbApron *pApron = TDbApron::cast(pEnt);
	if (pApron == NULL)
	{
//		return Acad::eInvalidInput;
		pApron = this; // sg modify 080916，动态输入打开，查看夹点时，也显示标注
	}

	int nSegNum = m_polyBase.TotalSegments(), // 段的数量
		nVertexNum = m_polyBase.Length();     // 点的数量
	long lFirset = nSegNum + nVertexNum;      // 起始编号
	if (lFirset > iGrip) // 与基类处理相同 
	{
		XPoly2D polyPath;
		AcGeVector3d normal;
		pApron->GetPathPoly(polyPath, normal);
		return ::EntityToDim(this, polyPath, iGrip, iDim, 0);
	}

	XPoly2D polyIn2D, polyOut2D;
	Array<int> aryIndex, aryShow;
	Get2DInPoly(polyIn2D);
	if (!Get2DOutPoly(polyOut2D, aryIndex, aryShow))
		return Acad::eOk;

	XDirectionCurve cvIn, cvOut;
	long lSegNum = iGrip - lFirset;
	int nNum = aryShow.GetAt(lSegNum);
	polyIn2D.Nth(lSegNum, cvIn);
	polyOut2D.Nth(nNum, cvOut);
	ASSERT(!!cvIn || !!cvOut);

	XPoint ptMidOut = cvOut.MidPoint(),
		ptNew, ptMidIn;
	cvIn.ProjectToMe(ptMidOut, ptMidIn);
	double dAngle = ads_angle(XPoint(), XVector3D(ptMidOut-ptMidIn)),
		dDist = pApron->GetDistAt(lSegNum);
	ads_polar(ptMidIn, dAngle, dDist, ptNew);

	switch(iDim)
	{
	case 0: // 宽度
		{
			TDbGripDistDim *pDistDim = (TDbGripDistDim*)pDim;
			pDistDim->SetData(ptMidIn, ptNew, _AS_SYS_UNIT(800));
		}
		break;
	case 1: // 位置偏移
		{
			TDbGripDistDim *pDistDim = (TDbGripDistDim*)pDim;
			pDistDim->SetData(ptMidOut, ptNew, _AS_SYS_UNIT(-800));
		}
		break;
	default:
		return Acad::eNotImplementedYet;
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbApron::DimToEntity(long iGrip, long iDim, double newValue, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	int nSegNum = m_polyBase.TotalSegments(), // 段的数量
		nVertexNum = m_polyBase.Length();     // 点的数量
	long lFirset = nSegNum + nVertexNum;      // 起始编号
	if (lFirset > iGrip) // 与基类处理相同 
	{
		TDbApron apron;
		apron.CopyPropertiesFrom(this, 0);

		Acad::ErrorStatus es = ::DimToEntity(this, m_polyBase, iGrip, iDim, newValue, offset, 0);
		if ((es==Acad::eOk) && !IsValid())
		{
			CopyPropertiesFrom(&apron, 0);
			return Acad::eInvalidInput;
		}
		return es;
	}

 	double dNewDist(newValue);
	long lSegNum = iGrip - lFirset;
	switch(iDim)
	{
	case 1: // 位置偏移
		{
			XPoly2D polyIn2D, polyOut2D;
			Array<int> aryIndex, aryShow;
			Get2DInPoly(polyIn2D);
			if (!Get2DOutPoly(polyOut2D, aryIndex, aryShow))
				return Acad::eOk;

			XDirectionCurve cvIn, cvOut;
			int nNum = aryShow.GetAt(lSegNum);
			polyIn2D.Nth(lSegNum, cvIn);
			polyOut2D.Nth(nNum, cvOut);
			ASSERT(!!cvIn || !!cvOut);

			XPoint ptMidIn,
				ptMidOut = cvOut.MidPoint();
			cvIn.ProjectToMe(ptMidOut, ptMidIn);
			AcGePoint3d ptNew = GetGripPoint(iGrip) + offset; // 输入时，点的位置

			AcGeVector3d vtOld = ptMidOut.AsAcGePoint3d() - ptMidIn.AsAcGePoint3d(),
				vtNew = ptNew - ptMidOut.AsAcGePoint3d();
			if (fabs(vtNew.angleTo(vtOld)) < 1.0E-5) // 同向拖拽
			{
				dNewDist += GetDistAt(lSegNum);
			}
			else // 反向拖拽
			{
				dNewDist = GetDistAt(lSegNum) - dNewDist;
				if (dNewDist < -1.0E-5) // 宽度小于0，自动修正
				{
					dNewDist = 0;
				}
			}
		}
	case 0: // 宽度
		SetDistAt(lSegNum, dNewDist);
		break;
	default:
		return Acad::eNotImplementedYet;
	}
	return Acad::eOk;
}
#endif 

CString TDbApron::GetXml( const AcGeMatrix3d& mat ) const
{
	XPoly2D polyIn, polyOut;
	Get2DInPoly(polyIn); // 内侧线
	Array<int> aryIndex, aryShow;
	if (!Get2DOutPoly(polyOut, aryIndex, aryShow)) // 外侧线
	{
		return CString();
	}

	polyIn.TransformBy(mat);
	polyOut.TransformBy(mat);

	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_APRON"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("散水"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	int nPre = 3; // 精度
	POSITION posIn = xmlTree.Insert(_T("PolyIn"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posIn, _T("name"), _T("内侧线"));
		POSITION posTemp = NULL;
		int nLen = polyIn.Length();
		CString sPt, sX, sY, sZ;
		XPoint ptTemp;
		for (int i = 0; i < nLen; ++i)
		{
			ptTemp = *polyIn[i];
			sPt.Format(_T("Point_%d"), i + 1);
			posTemp = xmlTree.Insert(sPt, posIn, posTemp);
			{
				sPt.Format(_T("第%d点"), i + 1);
				xmlTree.SetAttribute(posTemp, _T("name"), sPt);
				sX = DoubleToString(ptTemp.x, nPre);
				sY = DoubleToString(ptTemp.y, nPre);
		        sZ = DoubleToString(ptTemp.z, nPre);
				sPt.Format(_T("%s,%s,%s"), sX, sY, sZ);
				xmlTree.SetItemText(posTemp, sPt);
			}
			sPt.Format(_T("Ang_%d"), i + 1);
			posTemp = xmlTree.Insert(sPt, posIn, posTemp);
			{
				sPt.Format(_T("圆心角%d"), i + 1);
				xmlTree.SetAttribute(posTemp, _T("name"), sPt);
				sPt = DoubleToString(polyIn.GetBulge(i), nPre);
				xmlTree.SetItemText(posTemp, sPt);
			}
		}
	}

	POSITION posOut = xmlTree.Insert(_T("PolyOut"), posRoot, posIn);
	{
		xmlTree.SetAttribute(posOut, _T("name"), _T("外侧线"));
		POSITION posTemp = NULL;
		int nLen = polyOut.Length();
		CString sPt, sX, sY, sZ;
		XPoint ptTemp;
		for (int i = 0; i < nLen; ++i)
		{
			ptTemp = *polyOut[i];
			sPt.Format(_T("Point_%d"), i + 1);
			posTemp = xmlTree.Insert(sPt, posOut, posTemp);
			{
				sPt.Format(_T("第%d点"), i + 1);
				xmlTree.SetAttribute(posTemp, _T("name"), sPt);
				sX = DoubleToString(ptTemp.x, nPre);
				sY = DoubleToString(ptTemp.y, nPre);
				sZ = DoubleToString(ptTemp.z, nPre);
				sPt.Format(_T("%s,%s,%s"), sX, sY, sZ);
				xmlTree.SetItemText(posTemp, sPt);
			}
			sPt.Format(_T("Ang_%d"), i + 1);
			posTemp = xmlTree.Insert(sPt, posOut, posTemp);
			{
				sPt.Format(_T("圆心角%d"), i + 1);
				xmlTree.SetAttribute(posTemp, _T("name"), sPt);
				sPt = DoubleToString(polyIn.GetBulge(i), nPre);
				xmlTree.SetItemText(posTemp, sPt);
			}
		}
	}

	POSITION posInHeight = xmlTree.Insert(_T("InHeight"), posRoot, posOut);
	{
		xmlTree.SetAttribute(posInHeight, _T("name"), _T("截面内侧高度"));
		CString sTemp = DoubleToString(m_dInHeight, nPre);
		xmlTree.SetItemText(posInHeight, sTemp);
	}

	POSITION posOutHeight = xmlTree.Insert(_T("OutHeight"), posRoot, posInHeight);
	{
		xmlTree.SetAttribute(posOutHeight, _T("name"),  _T("截面外侧高度"));
		CString sTemp = DoubleToString(m_dInHeight, nPre);
		xmlTree.SetItemText(posOutHeight, sTemp);
	}

	POSITION posItemId = xmlTree.Insert(_T("Object_ID"), posRoot, posOutHeight);
	{
		xmlTree.SetAttribute(posItemId, _T("name"), _T("ID"));
		xmlTree.SetAttribute(posItemId, _T("comment"), _T("散水ID"));
		CString sText;
		sText.Format(_T("%ld"), objectId().asOldId());
		xmlTree.SetItemText(posItemId, sText);
	}

	CString sXml = xmlTree.GetXml();
	int nIdex = -1;
	nIdex = sXml.Find(_T("</ATS_APRON>"));
	if (nIdex != -1)
	{
		CString sTemp = TDbPolyCurveEnt::GetXml(mat);
		sXml.Insert(nIdex, sTemp);
	}
	return sXml;
}


void InitDbApron(BOOL bTrue)
{
	if (bTrue)
	{
		TDbApron::rxInit();
		acrxBuildClassHierarchy();
 		TDbApron::InitMatchProtocol(TRUE);
	}
	else
	{
 		TDbApron::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbApron::desc());
	}
}