#include "stdafx.h"

GEOAPI Acad::ErrorStatus ExplodeAcis(const AcDbEntity *pEntity, AcDbVoidPtrArray &entSet);
void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray &entSet);
//extern BOOL g_bMakeBlock;
/////////////////////////////////////////////////////////////
// 栏杆对象类
/////////////////////////////////////////////////////////////

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


ACRX_DXF_DEFINE_MEMBERS(ATSRail, ATSPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_RAIL, "ATS_RAIL图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");

IMPLEMENT_TENTBASE(TDbRail);

TDbRail::TDbRail()
{
    m_nUnitWidth=m_nInitDist=0;
    m_nRailFlag=0;
    m_nQuickMarker=0;
}


TDbRail::~TDbRail()
{
}

BOOL TDbRail::IsValid() const
{
    BOOL bRet=TDbPolyPathEnt::IsValid();
    if(!bRet)
        return bRet;

    bRet=(m_nUnitWidth>_DIST_SNAP); //单元宽
    return bRet;
}

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


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

// 从DWG读入数据:
Acad::ErrorStatus TDbRail::dwgInFields (AcDbDwgFiler* pFiler)
{
   assertWriteEnabled();

   Acad::ErrorStatus es = TDbPolyPathEnt::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);
   m_polyBase.Reset();
   Adesk::UInt8 nPolyFlag;
   pFiler->readItem(&nPolyFlag);
   m_polyBase.SetFlag(nPolyFlag);

   Adesk::UInt16 m_nCount=0;
   pFiler->readItem(&m_nCount);
   for(Adesk::UInt16 i=0; i<m_nCount; i++) {
       AcGePoint3d pt;
       double nBulge=0.0;
       pFiler->readItem(&pt);
       pFiler->readItem(&nBulge);
       m_polyBase.AppendNode(XPoint(pt), nBulge);
   }
       
   pFiler->readItem(&m_nUnitWidth);
   pFiler->readItem(&m_nInitDist);
   pFiler->readItem(&m_nRailFlag);

   return pFiler->filerStatus();
}

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

   pFiler->writeItem(g_nVersion);
   pFiler->writeItem(m_idUnit);

   pFiler->writeItem((Adesk::UInt8) m_polyBase.GetFlag());
   Adesk::UInt16 nCount=m_polyBase.Length();
   pFiler->writeItem(nCount);
   for(Adesk::UInt16 i=0; i<nCount; i++) {
       pFiler->writeItem((AcGePoint3d &)m_polyBase[i]);
       pFiler->writeItem(m_polyBase.GetBulge(i));
   }


   pFiler->writeItem(m_nUnitWidth);
   pFiler->writeItem(m_nInitDist);
   pFiler->writeItem(m_nRailFlag);

   return pFiler->filerStatus();
}


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

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

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

	int fieldsFlags=0;
	resbuf rb;
	int n1, n2;
	double r1, r2;
	DList<XPoint> pts;
    DList<double> bulges;
	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::kDxfInt16+1:
			n2=rb.resval.rint;
			fieldsFlags |= 0x04;
			break;
        case AcDb::kDxfReal:
			r1=rb.resval.rreal;
			fieldsFlags |= 0x08;
			break;
        case AcDb::kDxfReal+1:
			r2=rb.resval.rreal;
			fieldsFlags |= 0x10;
			break;
		case AcDb::kDxfXCoord:
            pts.Append(new XPoint(rb.resval.rpoint));
            break;
		case AcDb::kDxfAngle:
			bulges.Append(new double(rb.resval.rreal));
			break;
            //fall through intentional
        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;
	}
	if(pts.Length()<2 || pts.Length()!=bulges.Length()) {
        pFiler->setError(_T("\nError DXF group code: 10, 50"));
        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;
    if(fieldsFlags&0x04)
		m_polyBase.SetFlag(n2);
	m_nUnitWidth=r1;
    if (fieldsFlags&0x10) 
        m_nInitDist=r2;
    
    m_polyBase.Reset();
	for(int i=0; i<pts.Length(); i++) {
		m_polyBase.AppendNode(*pts[i], *bulges[i]);
	}

    return pFiler->filerStatus();
}

Acad::ErrorStatus TDbRail::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    assertReadEnabled();
   Acad::ErrorStatus es;

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

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbRail"));
   assert(es == Acad::eOk);
   XString sName=GetSymbolName(m_idUnit);
   
   pFiler->writeString(AcDb::kDxfBlockName, sName);
   pFiler->writeDouble(AcDb::kDxfReal, m_nUnitWidth);
   pFiler->writeDouble(AcDb::kDxfReal+1, m_nInitDist);
   pFiler->writeInt16(AcDb::kDxfInt16, m_nRailFlag);
   pFiler->writeInt16(AcDb::kDxfInt16+1, m_polyBase.GetFlag());
   for(int i=0; i<m_polyBase.Length(); i++) {
       pFiler->writePoint3d(AcDb::kDxfXCoord, m_polyBase[i]);
	   pFiler->writeDouble(AcDb::kDxfAngle, m_polyBase.GetBulge(i));
   }

   return pFiler->filerStatus();
}



Acad::ErrorStatus
TDbRail::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
//    extern double g_nAcadVer;
    assertReadEnabled();
    if(!Has3D()) 
		return Acad::eOk;
    
	//add by whl 060106
	if(g_bOsnapExpl&&!g_bGetExtents)
		return Acad::eOk;

	//if(g_bOsnapExpl)
	//	return Acad::eOk;

	//TPushProperty vProp(this, dc);

    // Add 2 line on 2002/10/41
	BOOL bAutoProp=dc.IsAutoProp();
	dc.SetAutoProp(FALSE);

    INT_PTR nQuickMarker=GetQuickMarker();

    int nEdgeNum=m_polyBase.TotalSegments();
    AcDbVoidPtrArray entSet;
    AcDbBlockReference entInsert(AcGePoint3d(0,0,0), m_idUnit);
    entInsert.setPropertiesFrom(this);
    
    TMasterProperties prop;
    prop.SetFrom(this);
    //BOOL bAcGi=false;
    //if(g_nAcadVer>15.0001)
    //    bAcGi=(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0);
    
    //ExplodeBlock3d(m_idUnit, entSet); 
    BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
		_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);

	{
		extern BOOL g_bExplodeMesh;
		int nDrawMode=DocGetDrawMode();
		DocSetDrawMode(DRAW_3D);
		XPushMemVar<BOOL> tVar1(TchGeLib::g_bExplodeMesh, TRUE); //不能使用ACIS
	    InitModel(prop, &entInsert, NULL, entSet); 
		DocSetDrawMode(nDrawMode);
	}
    

    int nGsMarker=1; 
    for(int n=0; n<nEdgeNum; n++) {
        XDirectionCurve cvSeg;
        m_polyBase.Nth(n, cvSeg);
        XDirectionCurve seg2d=cvSeg;
        seg2d.SetElevation(0.0);
        double leng=seg2d.GetLength();
        if(leng<_DIST_SNAP)
            continue;
        double nSlopeRate=(cvSeg.EndPoint().z - cvSeg.StartPoint().z)/leng;
        leng -= m_nInitDist;
      
        int nSeg=IsAutoExpand()? AS_INT(leng/m_nUnitWidth) : int((leng+_DIST_SNAP)/m_nUnitWidth);
        if(nSeg<1)
            continue;
        double nNewUnitWidth=IsAutoExpand()? leng/nSeg : m_nUnitWidth ;
        double sx = nNewUnitWidth/m_nUnitWidth; 

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

            XPointDir2d ptIns;
            double nDist=m_nInitDist+(i+ (IsLeftAlign()? 0.0 : 0.5))*nNewUnitWidth;
            seg2d.Polar(nDist, ptIns);
            ptIns.z = cvSeg.StartPoint().z + nSlopeRate*nDist; 

            AcGeMatrix3d matTrans;
            matTrans.setToIdentity();

            if(fabs(sx-1.0)>1.0E-6) {
                AcGeMatrix3d mat;
                mat.setToIdentity();
                mat(0,0)=sx;
                matTrans.preMultBy(mat);
            }
            double zs=nSlopeRate;
            if(fabs(zs)>_DIST_SNAP) {
                AcGeMatrix3d mat;
                mat.setToIdentity();
                mat(2,0)=zs;
                matTrans.preMultBy(mat);
            }

            double nRot=ptIns.nDirection;
            if(fabs(nRot)>_angSnap) {
                AcGeMatrix3d mat;
                mat.setToIdentity();
                mat(0,0)=cos(nRot); mat(0,1)=-sin(nRot);
                mat(1,0)=sin(nRot); mat(1,1)=cos(nRot);
                matTrans.preMultBy(mat);
            }
            if(ptIns.Distance(XPoint())>_DIST_SNAP) {
                AcGeMatrix3d mat;
                mat.setToTranslation(ptIns);
                matTrans.preMultBy(mat);
            }
			if(!bNewMethod || fabs(zs)>_DIST_SNAP) {
				dc.SetAutoProp(FALSE);
                dc.DrawAtomicEntSet(entSet, matTrans);
            } else {
				dc.SetAutoProp(TRUE);
	            dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx, 1.0, 1.0), ptIns.nDirection, bNewMethod);
            }

            if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
                break;
        } 
    }
    ReleaseEntSet(entSet);
	dc.SetAutoProp(bAutoProp); // Add On 2002/10/13
    return Acad::eOk;
}

//extern double g_nAcadVer;
Acad::ErrorStatus
TDbRail::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    if(!Has2D()) 
		return Acad::eOk;
    assertReadEnabled();
	if(g_bOsnapExpl&&!g_bGetExtents)
		return Acad::eOk;

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

    int nEdgeNum=polyBase.TotalSegments();
   
    BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
		_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);
	
    int nGsMarker=1; 
    for(int n=0; n<nEdgeNum; n++) 
	{
        XDirectionCurve cvSeg;
        polyBase.Nth(n, cvSeg);
        XDirectionCurve seg2d=cvSeg;
        seg2d.SetElevation(0.0);
        double leng=seg2d.GetLength();
        if(leng<_DIST_SNAP)
            continue;
        leng -= m_nInitDist;
      
        int nSeg=IsAutoExpand()? AS_INT(leng/m_nUnitWidth) : int((leng+_DIST_SNAP)/m_nUnitWidth);
        if(nSeg<1)
            continue;
        double nNewUnitWidth=IsAutoExpand()? leng/nSeg : m_nUnitWidth ;
        double sx = nNewUnitWidth/m_nUnitWidth; 

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

            XPointDir2d ptIns; 
            double nDist=m_nInitDist+(i+ (IsLeftAlign()? 0.0 : 0.5))*nNewUnitWidth;
            seg2d.Polar(nDist, ptIns);
            ptIns.z = cvSeg.StartPoint().z; 
            dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx, 1.0, 1.0), ptIns.nDirection, bNewMethod);
            if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
                break;
        } 
    }
    return Acad::eOk;
}

/*
Acad::ErrorStatus TDbRail::getOsnapPoints(
                                 AcDb::OsnapMode       osnapMode,
                                 int                   gsSelectionMark,
                                 const AcGePoint3d&    ptPick,
                                 const AcGePoint3d&    lastPoint,
                                 const AcGeMatrix3d&   viewXform,
                                 AcGePoint3dArray&     snapPoints,
                                 AcDbIntArray&     geomIds) const
{  
   assertReadEnabled();
 return Acad::eOk;
}
*/

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

const TCHAR *
TDbRail::GetDefaultLayer() const
{
    return LAY_RAIL;
}


void 
TDbRail::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    assertReadEnabled();
   lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("路径排列")));
   lstInfo.Append(new TObjInfoUnit(_T("单元宽度"), Dist2Str(GetUnitWidth())));
   lstInfo.Append(new TObjInfoUnit(_T("初始间距"), Dist2Str(GetInitDist())));

   lstInfo.Append(new TObjInfoUnit(_T("单元自调"), IsAutoExpand()? _T("是") : _T("否")));
   lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), IsLeftAlign()? _T("左对齐") : _T("中间对齐")));

   //lstInfo.Append(new TObjInfoUnit(_T("路径长度"), Dist2Str(GetLength())));
}




////////////////////////////////////////////////////////////////

Acad::ErrorStatus 
TDbRail::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal)
{
    assertWriteEnabled();
    m_polyBase=polyPath;
	SetNormal(normal);
	return Acad::eOk;
}

Acad::ErrorStatus 
TDbRail::GetPathPoly(XPoly2D &polyPath,AcGeVector3d &normal) const
{
    assertReadEnabled();
    polyPath=m_polyBase;
	normal=GetNormal().AsAcGeVector3d();
	return Acad::eOk;
}


AcDbObjectId 
TDbRail::GetUnitId() const
{
    assertReadEnabled();
    return m_idUnit;
}

BOOL
TDbRail::IsLeftAlign() const
{
    assertReadEnabled();
    return ((m_nRailFlag&RF_ALIGN_LEFT)!=0);
}

BOOL
TDbRail::IsAutoExpand() const
{
    assertReadEnabled();
    return ((m_nRailFlag&RF_AUTOEXPAND)!=0);
}


void 
TDbRail::SetLeftAlign(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nRailFlag |= RF_ALIGN_LEFT;
    else
        m_nRailFlag &= ~RF_ALIGN_LEFT;
}

void 
TDbRail::SetAutoExpand(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nRailFlag |= RF_AUTOEXPAND;
    else
        m_nRailFlag &= ~RF_AUTOEXPAND;
}

void
TDbRail::SetUnitId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idUnit=id;
}

double
TDbRail::GetInitDist() const
{
    assertReadEnabled();
    return m_nInitDist;
}

double
TDbRail::GetUnitWidth() const
{
    assertReadEnabled();
    return m_nUnitWidth;
}


void
TDbRail::SetInitDist(double h)
{
    assertWriteEnabled();
    m_nInitDist=h;
}

void
TDbRail::SetUnitWidth(double w)
{
    assertWriteEnabled();
    m_nUnitWidth = w;
}

void 
TDbRail::SetHas2D(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nRailFlag |= RF_NEED2D;
    else
        m_nRailFlag &= ~RF_NEED2D;
}

void 
TDbRail::SetHas3D(BOOL bTrue)
{
    assertWriteEnabled();
    if(!bTrue)
        m_nRailFlag |= RF_DISABLE3D;
    else
        m_nRailFlag &= ~RF_DISABLE3D;
}

BOOL TDbRail::Has2D() const
{
    return ((m_nRailFlag&RF_NEED2D)!=0);
}

BOOL TDbRail::Has3D() const
{
    return ((m_nRailFlag&RF_DISABLE3D)==0);
}

int EditRail0(AcDbObjectId id);

void InitDbRail(BOOL bTrue)
{
    AecObjectEditMethod pOldEdit=NULL;
    if(bTrue) {
        TDbRail::rxInit();
        acrxBuildClassHierarchy();
        TDbRail::InitMatchProtocol(TRUE);
        pOldEdit=TDbRail::SetEditMethod(EditRail0);
    } else {
        TDbRail::InitMatchProtocol(FALSE);
        TDbRail::SetEditMethod(pOldEdit);
        deleteAcRxClass(TDbRail::desc());
    }
}

// 编辑扶手
int EditRail0(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbRail, pStep);
    if(!pStep)
        return RTERROR;
    while(1) {
        const TCHAR *szPrompts[2]= {
            _T("\n选择 [加顶点(A)/减顶点(D)/设顶点(S)/单元宽(W)/单元对齐(R)/单元自调(F)/初始间距(H)/上下移动(M)/视图模式(V)]<退出>:"),
				_T("\n选择 [单元宽(W)/单元对齐(R)/单元自调(F)/初始间距(H)/上下移动(M)/二维视图(V)]<退出>:")
        };
        const TCHAR *szKeywords[2] = {_T("A D R S F W H M V"), _T(" W R F H M V"),};
        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_NOD);
            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 if(sKeyword[0]==_T('S')) {
            XPushVar<int> osmode(_T("OSMODE"), OS_NOD);
            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->GetUnitWidth();
            nRet=GetReal(_T("\n单元宽度"), nWidth, RSG_NOZERO|RSG_NONEG);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->SetUnitWidth(nWidth);
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('H')) {
            double nHeight=pStep->GetInitDist();
            nRet=GetReal(_T("\n初始间距"), nHeight, RSG_NONEG);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                Acad::ErrorStatus es=pStep->upgradeOpen();
                if(es!=Acad::eOk)
                    return RTERROR;
                pStep->SetInitDist(nHeight);
                es=pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('R')) {
            BOOL nAlignment=pStep->IsLeftAlign();
            adsout << _T("\n单元对齐方式[中间对齐(0)/左对齐(1)]<") << int(nAlignment) << _T(">: ");
            XString sAlignment;
            INITGET_BEG(0, _T("0 1"));
            nRet=ads_getkword(_T(""), sAlignment);
            INITGET_END();

            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->SetLeftAlign(_ttoi(sAlignment));
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('F')) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->SetAutoExpand(!pStep->IsAutoExpand());
                pStep->downgradeOpen();
        } else if(sKeyword[0]==_T('M')) {
            double nDistMove=0.0;
            if(GetDist(_T("\n移动距离(正数--上移;负数--下移)"), nDistMove)==RTNORM) {
                AcDbObjectId idUnit=pStep->GetUnitId();
                OPENOBJ_BEGIN(idUnit, AcDb::kForWrite, AcDbBlockTableRecord, pBlock);
                if(pBlock) {
                    AcGeMatrix3d mat;
                    mat.setToTranslation(AcGeVector3d(0, 0, nDistMove));
                    AcDbBlockTableRecordIterator *pIter=NULL;
                    VERIFY(pBlock->newIterator(pIter)==Acad::eOk);
                    for(pIter->start(); !pIter->done(); pIter->step()) {
                        AcDbEntity *pEnt=NULL;
                        VERIFY(pIter->getEntity(pEnt, AcDb::kForWrite)==Acad::eOk);
                        ASSERT(pEnt);
                        pEnt->transformBy(mat);
                        pEnt->close();
                    }
                    delete pIter;

                    //XPoint ptOrg=pBlock->origin();
                    //ptOrg.z -= nDistMove;
                    //pBlock->setOrigin(ptOrg);
                }
                OPENOBJ_END();
                if(pStep->upgradeOpen()==Acad::eOk) {
                    pStep->assertWriteEnabled();
                    pStep->downgradeOpen();
                }
            }
        } else if(sKeyword[0]==_T('V')) {
            if(pStep->upgradeOpen()==Acad::eOk) {
                pStep->assertWriteEnabled();
				BOOL bHas3D=pStep->Has3D();
				BOOL bHas2D=pStep->Has2D();
				if(bHas2D && bHas3D)
					pStep->SetHas2D(FALSE); // Disable 2d
				else if(bHas3D && !bHas2D) {
					pStep->SetHas3D(FALSE);
					pStep->SetHas2D(TRUE);
				} else {
					pStep->SetHas2D(TRUE);
					pStep->SetHas3D(TRUE);
				}
                //pStep->SetHas2D(!pStep->Has2D());
                pStep->downgradeOpen();
            }
        }
    }
    OPENOBJ_END();

    return RTNORM;
}