#include "stdafx.h"

//GEOAPI Acad::ErrorStatus ExplodeAcis(const AcDbEntity *pEntity, AcDbVoidPtrArray &entSet);
void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray &entSet);
//extern BOOL g_bMakeBlock;
/////////////////////////////////////////////////////////////
// 路径排列类
//TArch7 Beta1、2：1;TArch7 Beta3 2
const Adesk::UInt8 TDbPolyPathArray::g_nVersion = 2;
ACRX_DXF_DEFINE_MEMBERS(ATSPolyPathArray, ATSPolyCurveEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_PATH_ARRAY, "ATS_PATH_ARRAY图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbPolyPathArray);

TDbPolyPathArray::TDbPolyPathArray()
{
    m_nUnitHeight=1;	
    m_nRailFlag=0;
	m_nRatio=1.0;
}
BOOL TDbPolyPathArray::IsValid() const  
{
    BOOL bRet=TDbPolyCurveEnt::IsValid();
    if(!bRet)
        return bRet;

    bRet=(m_nUnitHeight>_DIST_SNAP&&m_nRatio>0.1); //单元宽
    return bRet;
}
// 提供对格式刷的支持
void TDbPolyPathArray::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPolyCurveEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbPolyPathArray *pSrc=TDbPolyPathArray::cast(pSrcEntity);
    if(pSrc) {
		if(database()==NULL||
		   pSrcEntity->database()==NULL||
		   database()==pSrcEntity->database())//add by whl on 060317
		{
			m_idUnit=pSrc->m_idUnit; //自定义扶手
		}
        m_nUnitHeight=pSrc->m_nUnitHeight; //初始间距
        m_nRailFlag=pSrc->m_nRailFlag; //单元对齐方式
		m_nRatio=pSrc->m_nRatio;
    }
}

Acad::ErrorStatus TDbPolyPathArray::subGetClassID(CLSID* pClsid) const
{
	return Acad::eOk;
}
// 从DWG读入数据:
Acad::ErrorStatus TDbPolyPathArray::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_idUnit);
   pFiler->readItem(&m_nUnitHeight);
   pFiler->readItem(&m_nRailFlag);

   if(nVer>1)//TArch7 Beta3
	   pFiler->readItem(&m_nRatio);
   else
	   m_nRatio=1.0;

   return pFiler->filerStatus();
}

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

   pFiler->writeItem(g_nVersion);

   pFiler->writeItem(m_idUnit);
   pFiler->writeItem(m_nUnitHeight);
   pFiler->writeItem(m_nRailFlag);
   pFiler->writeItem(m_nRatio);

   return pFiler->filerStatus();
}


Acad::ErrorStatus TDbPolyPathArray::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();

    Acad::ErrorStatus es =  TDbPolyCurveEnt::dxfInFields(pFiler);
    if(es!=Acad::eOk)
        return es;

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

	int fieldsFlags=0;
	resbuf rb;
	int n1;
	double r1;
	XString sName;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
		case AcDb::kDxfBlockName:
			sName=rb.resval.rstring;
			fieldsFlags |= 0x01;
			break;
		case AcDb::kDxfInt16:
			n1=rb.resval.rint;
			fieldsFlags |= 0x02;
			break;
        case AcDb::kDxfReal:
			r1=rb.resval.rreal;
			fieldsFlags |= 0x08;
			break;
        default:
            // An unrecognized group. Push it back so that
            // the subclass can read it again.
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    // At this point the es variable must contain eEndOfFile
    // - either from readResBuf() or from pushback. If not,
    // it indicates that an error happened and we should
    // return immediately.
    //
    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;
	if(!(fieldsFlags&0x01)) {
		pFiler->setError(_T("\nMissing DXF group code: 3"));
        return Acad::eMissingDxfField;
	}
	if(!(fieldsFlags&0x08)) {
		pFiler->setError(_T("\nMissing DXF group code: 40"));
        return Acad::eMissingDxfField;
	}

	AcDbObjectId idUnit=InitBlock(sName);
	if(!idUnit) {
		pFiler->setError(_T("\nError DXF group code: 3"));
        return Acad::eMissingDxfField;
	}
	m_idUnit=idUnit;
	if(fieldsFlags&0x02)
		m_nRailFlag=n1;
	m_nUnitHeight=r1;
    


    return pFiler->filerStatus();
}
Acad::ErrorStatus TDbPolyPathArray::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    assertReadEnabled();
   Acad::ErrorStatus es;

   es = TDbPolyCurveEnt::dxfOutFields(pFiler);
   assert(es == Acad::eOk);

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPolyPathArray"));
   assert(es == Acad::eOk);
   XString sName=GetSymbolName(m_idUnit);
   
   pFiler->writeString(AcDb::kDxfBlockName, sName);
   pFiler->writeDouble(AcDb::kDxfReal, m_nUnitHeight);
   pFiler->writeInt16(AcDb::kDxfInt16, m_nRailFlag);

   return pFiler->filerStatus();
}
//extern double g_nAcadVer;
Acad::ErrorStatus
TDbPolyPathArray::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();
	if(m_idUnit.isNull()||!m_idUnit.isValid())
		return Acad::eOk;


	BOOL bFullExplode = ((TGGiExplodeDraw &)dc).m_bFullExplode;
	BOOL bIsWdDraw = FALSE;

	if (_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor()) == 0)
	{
		bIsWdDraw = TRUE;
		bFullExplode = TRUE;
	}

	if (!bFullExplode)
	{
		return Acad::eOk;
	}

	XPoint ptLow,ptUp;
	GetBlockExtents(m_idUnit,ptLow,ptUp);
	double nOldSy=ptUp.y-ptLow.y;

    INT_PTR nQuickMarker=GetQuickMarker();
	XPoly2D polyBase(m_polyBase);
	polyBase.SetElevation(0.0);
	polyBase.Compress();

    int nEdgeNum=polyBase.TotalSegments();
	{
		BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
			_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);

		//add by xlc on 120424 线图案填充显示时裁剪特殊处理 
		if (g_bWallLinepatClip)
		{
			bNewMethod = FALSE;
		}
		
		double nUnitWidth=GetUnitWidth(),nNewUnitWidth=nUnitWidth;
		int nGsMarker=1; 
		for(int n=0; n<nEdgeNum; n++)
		{
			XDirectionCurve cvSeg;
			polyBase.Nth(n, cvSeg);
			if(GetBaseType()==0)
				cvSeg=cvSeg.Offset(m_nUnitHeight*(1-m_nRatio)*0.5,LS_FINITE);
			else if(GetBaseType()==1)
				cvSeg=cvSeg.Offset(-m_nUnitHeight*(1+m_nRatio)*0.5,LS_FINITE);
			else 
				cvSeg=cvSeg.Offset(-m_nUnitHeight*m_nRatio/2,LS_FINITE);

			XDirectionCurve seg2d=cvSeg;
			seg2d.SetElevation(0.0);
			double leng=seg2d.GetLength();
			if(leng<_DIST_SNAP)
				continue;
	      
			double sy=GetScaleY(),sz=sy,sx=sy;
			int nSeg=int((leng+_DIST_SNAP)/nUnitWidth);
			if(nSeg<1)
				continue;

			double nEmpty=leng-nSeg*nUnitWidth;
			if(IsEqualScale())
			{
				if(IsAutoExpand())
					nNewUnitWidth=(leng+nEmpty/(nSeg-1))/nSeg;
				sx=sy;
			}
			else
			{
				nNewUnitWidth=leng/nSeg;
				sx*=nNewUnitWidth/nUnitWidth;
			}

			double sArc=1.0;
			//if(cvSeg.IsMinusArc())
			//	sArc=(cvSeg.GetArc().radius-nOldSy)/cvSeg.GetArc().radius;

			for(int i=0; i<nSeg; i++)
			{
				dc.SetSelectionMarker(nGsMarker);
				nGsMarker++;
				if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
					continue;

				XPointDir2d ptIns; 
				double nDist=i*nNewUnitWidth;
				double dx=nNewUnitWidth;
				if(IsEqualScale()&&!IsAutoExpand())
				{
					nDist+=nEmpty/2;
					dx+=nEmpty/2;
				}

				if(IsReversed())
				{
					seg2d.Polar(nDist+nNewUnitWidth, ptIns);
					ptIns.z = cvSeg.StartPoint().z; 
					if(seg2d.Is(CURVE_LINE))
						dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(-sx,sy,sz), ptIns.nDirection, bNewMethod);
					else
					{
						XPointDir2d ptIns1,ptMid,ptMid1; 
						seg2d.Polar(nDist,ptIns1);
						seg2d.Polar(nDist+dx/2,ptMid);
						Midpoint(ptIns,ptIns1,ptMid1);
						XPoint vtOffset=ptMid-ptMid1;
						XPoint vt=ptIns-ptIns1;
						vt.Normalize();
						dc<<XBlockRef(m_idUnit, ptIns+vtOffset, AcGeScale3d(-sx*(ptIns1.Distance2d(ptIns)/nNewUnitWidth)*sArc,sy,sz),vt.AsAcGeVector2d().angle(), bNewMethod);
					}
				}
				else
				{
					seg2d.Polar(nDist, ptIns);
					ptIns.z = cvSeg.StartPoint().z; 
					if(seg2d.Is(CURVE_LINE))
						dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx,sy,sz), ptIns.nDirection, bNewMethod);
					else
					{
						XPointDir2d ptIns1,ptMid,ptMid1; 
						seg2d.Polar(nDist+nNewUnitWidth,ptIns1);
						seg2d.Polar(nDist+dx/2,ptMid);
						Midpoint(ptIns,ptIns1,ptMid1);
						XPoint vtOffset=ptMid-ptMid1;
						XPoint vt=ptIns1-ptIns;
						vt.Normalize();
						dc<<XBlockRef(m_idUnit, ptIns+vtOffset, AcGeScale3d(sx*(ptIns1.Distance2d(ptIns)/nNewUnitWidth)*sArc,sy,sz),vt.AsAcGeVector2d().angle(), bNewMethod);
					}
				}
				if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
					break;
			} 
		}
	}
    return Acad::eOk;
}
Acad::ErrorStatus 
TDbPolyPathArray::subGetOsnapPoints(         AcDb::OsnapMode       osnapMode,
                                 INT_PTR                   gsSelectionMark,
                                 const AcGePoint3d&    ptPick,
                                 const AcGePoint3d&    lastPoint,
                                 const AcGeMatrix3d&   viewXform,
                                 AcGePoint3dArray&        snapPoints,
                                 AcDbIntArray&     geomIds) const
{
    assertReadEnabled();
	XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
	return TDbCurveEntity::GetOsnapPoints(osnapMode,gsSelectionMark,
                   ptPick, lastPoint, viewXform,snapPoints, geomIds);
}
Acad::ErrorStatus 
TDbPolyPathArray::subGetOsnapPoints(         AcDb::OsnapMode       osnapMode,
                                 INT_PTR                   gsSelectionMark,
                                 const AcGePoint3d&    ptPick,
                                 const AcGePoint3d&    lastPoint,
                                 const AcGeMatrix3d&   viewXform,
                                 AcGePoint3dArray&        snapPoints,
                                 AcDbIntArray&     geomIds,
								 const AcGeMatrix3d &mat) const
{
    assertReadEnabled();
    Acad::ErrorStatus es=Acad::eOk;
	XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
	return TDbCurveEntity::GetOsnapPoints(osnapMode,gsSelectionMark,
                   ptPick, lastPoint, viewXform,snapPoints, geomIds,mat);
}
Acad::ErrorStatus TDbPolyPathArray::subTransformBy(const AcGeMatrix3d&mat)
{
	assertWriteEnabled();

	Acad::ErrorStatus es=TDbPolyCurveEnt::subTransformBy(mat);
	ads_matrix mat1;
	AsAdsMatrix(mat,mat1);
	if(IsMirrorMatrix(mat1))
	{
		Reverse();//左右翻转
		m_polyBase.Reverse();//上下翻转
	}

	return es;
}

// k3D 有错
TEntityBase::DrawType TDbPolyPathArray::GetDrawType() const
{
    return TEntityBase::k2Dand3D;
}

const TCHAR * TDbPolyPathArray::GetDefaultLayer() const
{
    return LAY_RAIL;
}
void TDbPolyPathArray::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    assertReadEnabled();
   lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("线图案")));
   lstInfo.Append(new TObjInfoUnit(_T("线宽"), Dist2Str(m_nUnitHeight)));
   lstInfo.Append(new TObjInfoUnit(_T("填充比例"), XString(_T("%d %%"),(int)(m_nRatio*100))));
   lstInfo.Append(new TObjInfoUnit(_T("长度"), Dist2Str(m_polyBase.Distance2d())));
   if(IsEqualScale())
	   lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), IsAutoExpand()? _T("两边对齐") : _T("中间对齐")));
   else
	   lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), _T("单元自调")));
   XString sBase;
   if(GetBaseType()==0)
	   sBase=_T("基线居左");
   else if(GetBaseType()==1)
	   sBase=_T("基线居右");
   else
	   sBase=_T("基线居中");
	lstInfo.Append(new TObjInfoUnit(_T("基线位置"), sBase));
}
////////////////////////////////////////////////////////////////
AcDbObjectId TDbPolyPathArray::GetUnitId() const
{
    assertReadEnabled();
    return m_idUnit;
}
int TDbPolyPathArray::GetBaseType() const
{
    assertReadEnabled();
	if((m_nRailFlag&RF_RIGHTBASE)!=0)
		return 1;
	else if((m_nRailFlag&RF_MIDBASE)!=0)
		return 2;
	else
		return 0;
}
void TDbPolyPathArray::SetBaseType(int type)
{
    assertWriteEnabled();
    if(type==1)
	{
		m_nRailFlag |= RF_RIGHTBASE;
		m_nRailFlag &=~RF_MIDBASE;
	}
	else if(type==2)
	{
		m_nRailFlag &=~RF_RIGHTBASE;
		m_nRailFlag |= RF_MIDBASE;
	}
    else
	{
		m_nRailFlag &=~RF_RIGHTBASE;
		m_nRailFlag &=~RF_MIDBASE;
	}
}
BOOL TDbPolyPathArray::IsAutoExpand() const
{
    assertReadEnabled();
    return ((m_nRailFlag&RF_AUTOEXPAND)!=0);
}
void TDbPolyPathArray::SetAutoExpand(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nRailFlag |= RF_AUTOEXPAND;
    else
        m_nRailFlag &= ~RF_AUTOEXPAND;
}
BOOL TDbPolyPathArray::IsEqualScale() const
{
    assertReadEnabled();
    return ((m_nRailFlag&RF_EQUALSCALE)!=0);
}
void TDbPolyPathArray::SetEqualScale(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nRailFlag |= RF_EQUALSCALE;
    else
        m_nRailFlag &= ~RF_EQUALSCALE;
}
BOOL TDbPolyPathArray::IsReversed() const
{
    assertReadEnabled();
    return ((m_nRailFlag&RF_REVERSE)!=0);
}
void TDbPolyPathArray::Reverse()
{
    assertWriteEnabled();
    if((m_nRailFlag&RF_REVERSE)!=0)
        m_nRailFlag &= ~RF_REVERSE;
	else
        m_nRailFlag |= RF_REVERSE;
}
void TDbPolyPathArray::SetUnitId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idUnit=id;
}
double TDbPolyPathArray::GetScaleY()const
{
	XPoint ptLow, ptUp;
	double nRet=1.0;
	if(GetBlockExtents(m_idUnit, ptLow, ptUp)==RTNORM) 
	{
		double height0=ptUp.y-ptLow.y;
		nRet=m_nUnitHeight*m_nRatio/height0;
	}
	return nRet;
}
double TDbPolyPathArray::GetUnitHeight()const
{
	assertReadEnabled();
	return m_nUnitHeight;
}
void TDbPolyPathArray::SetUnitHeight(double height)
{
	assertWriteEnabled();
	m_nUnitHeight=height;
}
double TDbPolyPathArray::GetRatio()const
{
	assertReadEnabled();
	return m_nRatio;
}
void TDbPolyPathArray::SetRatio(double ratio)
{
	assertWriteEnabled();
	m_nRatio=ratio;
}
double TDbPolyPathArray::GetUnitWidth() const
{
    assertReadEnabled();
	XPoint ptLow, ptUp;
	GetBlockExtents(m_idUnit, ptLow, ptUp);
	double width0=ptUp.x-ptLow.x;
	return GetScaleY()*width0;
}

int EditPolyPathArray(AcDbObjectId id);
void InitDbPolyPathArray(BOOL bTrue)
{
    AecObjectEditMethod pOldEdit=NULL;
    if(bTrue) 
	{
        TDbPolyPathArray::rxInit();
        acrxBuildClassHierarchy();
        TDbPolyPathArray::InitMatchProtocol(TRUE);
        pOldEdit=TDbPolyPathArray::SetEditMethod(EditPolyPathArray);
    } 
	else 
	{
        TDbPolyPathArray::InitMatchProtocol(FALSE);
        TDbPolyPathArray::SetEditMethod(pOldEdit);
        deleteAcRxClass(TDbPolyPathArray::desc());
    }
}

//TARCH_IMPEXP Acad::ErrorStatus ExplodeBlockRef(const AcDbBlockTableRecord &blockRec, 
//											   const AcGeMatrix3d &mat, AcDbVoidPtrArray &entSet);

void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray & entSet)
{
    //AcDbBlockReference blkIns(AcGePoint3d(0,0,0), idBlock);
    AcDbVoidPtrArray entSet0;
    ads_matrix mat;
    OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
    ASSERT(pBlock);
    XPoint ptOrg=pBlock->origin();
    ConstructMatrix(ptOrg, XPoint(0,0,0), 1.0, 1.0, 1.0, 0.0, mat);
    ExplodeBlockRef(*pBlock, AsAcGeMatrix3d(mat), entSet0);
    OPENOBJ_END();

    //if(blkIns.explode(entSet0)==Acad::eOk) {
        int nCount=entSet0.length();
        for(int i=0; i<nCount; i++) {
            AcDbEntity *pEnt=(AcDbEntity *)entSet0[i];
            AcRxClass *pRxInfo=pEnt->isA();
            if(pEnt->isKindOf(AcDbFace::desc())) { // 3DFACE
                entSet.append(pEnt);
                entSet0.removeAt(i);
                i--;
                nCount--; 
            } else if(pEnt->isKindOf(AcDbPolyFaceMesh::desc()) ||
                pEnt->isKindOf(AcDbPolygonMesh::desc())) {
                pEnt->explode(entSet);
            } else if(_tcscmp(pRxInfo->dxfName(), _T("3DSOLID"))==0 ||
                _tcscmp(pRxInfo->dxfName(), _T("REGION"))==0) {
                ExplodeAcis(pEnt, entSet);
            } else { 
                BOOL bExp=FALSE;
                if(pEnt->isKindOf(AcDbPolyline::desc())) {
                    AcDbPolyline *pline=AcDbPolyline::cast(pEnt);
                    ASSERT(pline);
                    double nWidth=0.0;
                    if(pline->normal()==AcGeVector3d(0,0,1) && pline->thickness()>_DIST_SNAP && 
                        pline->getConstantWidth(nWidth)==Acad::eOk && nWidth<1.0E-3) {
                        double nHeight=pline->thickness();
                        XPoly2D poly;
                        PolyConvert(*pline, poly);
                        XPoly poly1;
                        poly.MapToPolygon(poly1);
                        if(poly.IsClosed()) {
                            XPolygonEx polyEx(poly1);
                            XTrianglePface lstTris;
                            if(polyEx.Trianglize(lstTris, FALSE)==RTNORM) {
                                for(int n=0; n<lstTris.Length(); n++) {
                                    XTriangle *triangle=lstTris[n];
                                    Adesk::Boolean bSide1=!(triangle->m_nFlag&SIDE1_INVISIBLE);
                                    Adesk::Boolean bSide2=!(triangle->m_nFlag&SIDE2_INVISIBLE);
                                    Adesk::Boolean bSide3=!(triangle->m_nFlag&SIDE3_INVISIBLE);
                                    AcDbFace *pFace=new AcDbFace(triangle->vertex1, triangle->vertex2,
                                        triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
                                    entSet.append(pFace);
                                    triangle->vertex1.z += nHeight;
                                    triangle->vertex2.z += nHeight;
                                    triangle->vertex3.z += nHeight;
                                    pFace=new AcDbFace(triangle->vertex1, triangle->vertex2,
                                        triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
                                    entSet.append(pFace);
                                }
                            }
                        }
                        int nSeg=poly1.Length();
                        if(!poly.IsClosed())
                            nSeg --;
                        for(int n=0; n<nSeg; n++) {
                            XLine ln, ln1;
                            poly1.NthLine(n, ln);
                            ln1=ln;
                            ln1.StartPoint().z += nHeight;
                            ln1.EndPoint().z += nHeight;
                            bool bVisStart=poly.HitTestOnCurve(ln.StartPoint(), 1.0E-3)>0;
                            bool bVisEnd=poly.HitTestOnCurve(ln.EndPoint(), 1.0E-3)>0;
                            AcDbFace *pFace=new AcDbFace(ln.StartPoint(), ln.EndPoint(),
                                ln1.EndPoint(), ln1.StartPoint(), 
                                Adesk::kTrue, bVisStart, Adesk::kTrue, bVisEnd);
                            entSet.append(pFace);                            
                        }
                        bExp=TRUE;
                    }
                }
                if(!bExp) {
                    entSet.append(pEnt);
                    entSet0.removeAt(i);
                    i--;
                    nCount--;
                }
            }

        }
    //}
    ReleaseEntSet(entSet0);
}
// 编辑路径排列
int EditPolyPathArray(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPolyPathArray, pStep);
    if(!pStep)
        return RTERROR;
    while(1) {
        const TCHAR *szPrompts[2]= {
            _T("\n选择 [加顶点(A)/减顶点(D)/设顶点(S)/宽度(W)/填充比例(G)/图案翻转(F)/单元对齐(R)/基线位置(B)]<退出>:"),
				_T("\n选择 [宽度(W)/填充比例(G)/图案翻转(F)/单元对齐(R)/基线位置(B)]<退出>:")
        };
        const TCHAR *szKeywords[2] = {_T("A D S W G F R B"), _T("W G F R B"),};
        int nIdx=pStep->IsBind()? 1: 0;
        XString sKeyword;
        int nRet=0;
        INITGET_BEG(0, szKeywords[nIdx]);
        nRet=ads_getkword(szPrompts[nIdx], sKeyword);
        INITGET_END();

        if(nRet!=RTNORM)
            break;
        if(sKeyword[0]==_T('A')) {
            int nOsMode=0;
            xg_getvar(_T("OSMODE"), &nOsMode);
            nOsMode &= ~0x4000;
            nOsMode |= OS_INT;
            XPushVar<int> tVar(_T("OSMODE"), nOsMode);
            XPoint ptAdd;
            if(XGetPoint(NULL, _T("\n点取新的顶点位置"), ptAdd)==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                if(!pStep->AddVertex(ptAdd)) {
                    adsout << _T("\n请正确点取!");
                }
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('D')) {
            XPushVar<int> osmode(_T("OSMODE"), OS_END);
			XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
            XPoint ptVert;
            while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
                int nPos=pStep->HitTestOnBase2d(ptVert);
                if(nPos>0) {
                    nPos--;
                    if(pStep->upgradeOpen()!=Acad::eOk)
                        return RTERROR;
                    pStep->RemoveVertexAt(nPos);
                    pStep->downgradeOpen();
                }else {
                    adsout << _T("\n请正确点取!");
                }
            }
        } else if(sKeyword[0]==_T('S')) {
            XPushVar<int> osmode(_T("OSMODE"), OS_END);
			XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
            XPoint ptVert;
            while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
                int nPos=pStep->HitTestOnBase2d(ptVert);
                if(nPos>0) {
                    nPos--;
                    if(nPos==0) {
                        XPoly2D poly2d;
						AcGeVector3d normal;
                        pStep->GetPathPoly(poly2d,normal);
                        poly2d.SetElevation(0.0);
                        if(poly2d.IsClosed()) {
                            int nAns=YesNoQuestion(_T("\n起点和终点的平面投影相同,您指的是起点吗"));
                            if(nAns==RTCAN)
                                continue;
                            else if(nAns==Q_NO)
                                nPos = poly2d.Length();
                        }
                    }
                    double nElev=pStep->GetElevationAt(nPos);
                    adsout << _T("\n改夹角[A]/点取[P]/输入顶点标高<") 
                           << Dist2Str(nElev)
                           << _T(">: ");
                    int nCode;
                    INITGET_BEG(0, _T("A P"));
                    nCode=ads_getreal(_T(""), &nElev);
                    INITGET_END();
                    if(nCode==RTKWORD) {
                        TCHAR szKey[80]=_T("");
                        ads_getinput(szKey);
                        if(szKey[0]==_T('P')) {
                            XPushVar<int> osMode(_T("OSMODE"), OS_NEA);
                            XPoint ptElev;
                            nCode=ads_getpoint(NULL, _T("\n点取参照物:"), ptElev);
                            if(nCode==RTNORM) {
                                nElev=ptElev.z;
                                if(pStep->upgradeOpen()!=Acad::eOk)
                                    return RTERROR;
                                pStep->SetElevationAt(nPos, nElev);
                                pStep->downgradeOpen();
                            }
                        } else if(szKey[0]==_T('A')) {
                            double nOldAng=pStep->GetSweepAngleAt(nPos)*180.0/PI;
                            nCode=GetReal(_T("\n输入夹角"), nOldAng);
                            if(nCode==RTNORM) {
                                nOldAng *= PI/180.0;
                                if(pStep->upgradeOpen()!=Acad::eOk)
                                    return RTERROR;
                                pStep->SetSweepAngleAt(nPos, nOldAng);
                                pStep->downgradeOpen();
                            }
                        }
                    } else if(nCode==RTNORM) {
                        if(pStep->upgradeOpen()!=Acad::eOk)
                            return RTERROR;
                        pStep->SetElevationAt(nPos, nElev);
                        pStep->downgradeOpen();
                    }
                } else {
                    adsout << _T("\n请正确点取!");
                }
            }
        } else if(sKeyword[0]==_T('W')) {
            double nWidth=pStep->GetUnitHeight();
            nRet=GetReal(_T("\n线宽"), nWidth, RSG_NOZERO|RSG_NONEG);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->SetUnitHeight(nWidth);
                pStep->downgradeOpen();
            }
        }else if(sKeyword[0]==_T('G')) {
            double nWidth=pStep->GetRatio();
            nRet=GetReal(_T("\n填充比例"), nWidth, RSG_NOZERO|RSG_NONEG);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->SetRatio(nWidth);
                pStep->downgradeOpen();
            }
        }
		 else if(sKeyword[0]==_T('R'))
		{
            if(pStep->upgradeOpen()!=Acad::eOk)
                return RTERROR;
			if(!pStep->IsEqualScale())
			{
				pStep->SetEqualScale(TRUE);
				pStep->SetAutoExpand(TRUE);
				adsout<<_T("<两边对齐>");
			}
			else if(pStep->IsAutoExpand())
			{
				pStep->SetAutoExpand(FALSE);
				adsout<<_T("<中间对齐>");
			}
			else
			{
				pStep->SetEqualScale(FALSE);
				adsout<<_T("<单元自调>");
			}
            pStep->downgradeOpen();
        }
		else if(sKeyword[0]==_T('B'))
		{
            if(pStep->upgradeOpen()!=Acad::eOk)
                return RTERROR;
			if(pStep->GetBaseType()==0)
			{
				pStep->SetBaseType(1);
				adsout<<_T("<基线居右>");
			}
			else if(pStep->GetBaseType()==1)
			{
				pStep->SetBaseType(2);
				adsout<<_T("<基线居中>");
			}
			else
			{
				pStep->SetBaseType(0);
				adsout<<_T("<基线居左>");
			}
            pStep->downgradeOpen();
        }
		else if(sKeyword[0]==_T('F')) 
		{
            if(pStep->upgradeOpen()!=Acad::eOk)
                return RTERROR;
			pStep->Reverse();
            pStep->downgradeOpen();
		}
    }
    OPENOBJ_END();

    return RTNORM;
}