#include "stdafx.h"

#include "dbid.h"

extern int GetContourDivNum(double dPerimeter);

static int CompareObjectIds(const AcDbSoftPointerId *p1, const void *p2)
{
    if(*p1==*(const AcDbSoftPointerId *)p2)
        return 0;
    return 1;
}

static int CompareArea(const XPoly2D *p1, const XPoly2D *p2)
{
    if(p1->Area()>p2->Area())
        return 1;
    return -1;
}


TReactor::TReactor()
{
}

TReactor::TReactor(const TReactor& src)
{
	int nCount = src.m_lstReactor.Length();
	for (int i = 0; i < nCount; i++) {
		AcDbSoftPointerId* objId = 
			new AcDbSoftPointerId(src.m_lstReactor[i]);
		m_lstReactor.Append(objId);
	}
}

TReactor::~TReactor()
{
}

BOOL TReactor::IsValid() const
{
	int nCount = m_lstReactor.Length();
	for (int i=0; i<nCount; i++) {
		if (m_lstReactor[i].isNull()) {
			return FALSE;
		}
	}
	return TRUE;
}

BOOL TReactor::HasReactor() const
{
	return m_lstReactor.Length()>0;
}

void TReactor::
GetReactors(DList<AcDbObjectId>& lstReactorId) const
{
	lstReactorId.Reset();
	int nCount = m_lstReactor.Length();
	for (int i=0; i<nCount; i++) {
		AcDbObjectId* objId = 
			new AcDbObjectId(m_lstReactor[i]);
		lstReactorId.Append(objId);
	}
}

void TReactor::
SetReactors(const DList<AcDbObjectId>& lstReactorId)
{
	int nCount = lstReactorId.Length();
	for (int i=0; i<nCount; i++) {
		AcDbSoftPointerId* objId = 
			new AcDbSoftPointerId(lstReactorId[i]);
		m_lstReactor.Append(objId);
	}
}

void  TReactor::
GetReactors(AcDbObjectIdArray& arReactorId) const
{
	arReactorId.setLogicalLength(0);
	int nCount = m_lstReactor.Length();
	for (int i=0; i<nCount; i++) {
		arReactorId.append(m_lstReactor[i]);
	}
}

void  TReactor::
SetReactors(const AcDbObjectIdArray& arReactorId)
{
	int nCount = arReactorId.length();
	for (int i=0; i<nCount; i++) {
		AcDbSoftPointerId* objId = 
			new AcDbSoftPointerId(arReactorId[i]);
		m_lstReactor.Append(objId);
	}
}

BOOL TReactor::
IsExist(const AcDbObjectId& objId)
{
	if(m_lstReactor.FindNode(&objId,CompareObjectIds))
		return TRUE;
	return FALSE;
}

Acad::ErrorStatus
TReactor::Attach(AcDbObject* pObj)
{
	if(pObj==NULL)
		return Acad::eNullObjectPointer;

	return Attach(pObj->objectId());
}



Acad::ErrorStatus
TReactor::Detach(AcDbObject* pObj)
{
	if(pObj==NULL)
		return Acad::eNullObjectPointer;

	return Detach(pObj->objectId());
}

Acad::ErrorStatus
TReactor::Attach(const AcDbObjectId& objId)
{
	if(IsExist(objId))
		return Acad::eAlreadyInDb;

	m_lstReactor.Append(new AcDbSoftPointerId(objId));
	return Acad::eOk;
}


Acad::ErrorStatus
TReactor::Detach(const AcDbObjectId& objId)
{
	if (!IsExist(objId))
		return Acad::eKeyNotFound;
	m_lstReactor.Remove();

	return Acad::eOk;
}

void TReactor::DetachAll()
{
	m_lstReactor.Reset();
}


Acad::ErrorStatus
TReactor::DwgInFields(AcDbDwgFiler* pFiler)
{
	Adesk::Int32 nCount;
	pFiler->readItem(&nCount);
	m_lstReactor.Reset();
	for (int i=0; i<nCount; i++) {
		AcDbSoftPointerId idTemp;
		pFiler->readItem(&idTemp);
		m_lstReactor.Append(new AcDbSoftPointerId(idTemp));
	}

    return pFiler->filerStatus();
}

Acad::ErrorStatus
TReactor::DwgOutFields(AcDbDwgFiler* pFiler) const
{
	int nCount = m_lstReactor.Length();
	pFiler->writeInt32(nCount);// nCount of ids
	for (int i=0; i<nCount; i++) {
		AcDbSoftPointerId idRector = m_lstReactor[i];
		pFiler->writeSoftPointerId(idRector);
	}

    return pFiler->filerStatus();
}


Acad::ErrorStatus
TReactor::DxfInFields(AcDbDxfFiler* pFiler)
{
    resbuf rb;
	Acad::ErrorStatus es=Acad::eOk;
	m_lstReactor.Reset();
    while ((es == Acad::eOk) &&
		((es=pFiler->readResBuf(&rb)) == Acad::eOk)) {
        if (rb.restype == AcDb::kDxfSoftPointerId) {
            AcDbSoftPointerId idTemp;
#ifdef _WIN64
			idTemp.setFromOldId(rb.resval.mnInt64);
#else
			idTemp.setFromOldId(rb.resval.rlong);
#endif
            
			m_lstReactor.Append(new AcDbSoftPointerId(idTemp));
        }
		else {
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
        }
    }

    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;

    return pFiler->filerStatus();
}


Acad::ErrorStatus
TReactor::DxfOutFields(AcDbDxfFiler* pFiler) const
{
    int nCount = m_lstReactor.Length();
    for (int i=0; i<nCount; i++) {
		pFiler->writeItem(AcDb::kDxfSoftPointerId,m_lstReactor[i]);
    }

    return pFiler->filerStatus();
}

void TReactor::TransformBy(const AcGeMatrix3d xform)
{
    int nCount = m_lstReactor.Length();
    for (int i=0; i<nCount; i++) {
		AcDbObjectId &idReactor = *m_lstReactor[i];
		OPENOBJ_BEGIN(idReactor,AcDb::kForWrite,AcDbEntity,pEnt);
		if (pEnt != NULL) {
			pEnt->transformBy(xform);
		}
		OPENOBJ_END();
    }
}

BOOL TReactor::IsShowReactor() const
{
	BOOL bShow=TRUE;
	int nCount = m_lstReactor.Length();
	for(int i=0; i<nCount; i++) {
		AcDbObjectId objId = m_lstReactor[i];
		OPENOBJ_BEGIN(objId, AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt != NULL) {
			AcDb::Visibility oldVas;
			oldVas = pEnt->visibility();
			if (oldVas == AcDb::kInvisible) {
				bShow = FALSE;
				break;
			}
		}
		OPENOBJ_END();
	}
	return bShow;
}


void TReactor::ShowReactor(BOOL bShow)
{
	AcDb::Visibility oldVas, newVal = 
		bShow?AcDb::kVisible:AcDb::kInvisible;
	int nCount = m_lstReactor.Length();
	for(int i=0; i<nCount; i++) {
		AcDbObjectId& objId = *m_lstReactor[i];
		OPENOBJ_BEGIN(objId, AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt != NULL) {
			oldVas = pEnt->visibility();
			if (oldVas != newVal) {
				if(pEnt->upgradeOpen()==Acad::eOk) {
					pEnt->assertWriteEnabled();
					pEnt->setVisibility(newVal);
					pEnt->downgradeOpen();
				}
			}
		}
		OPENOBJ_END();
	}
}

void TReactor::EraseReactor(BOOL bEraseAll)
{
	int nCount = m_lstReactor.Length();
	if(bEraseAll){
		for(int i=0; i<nCount; i++) {
			AcDbObjectId& objId = *m_lstReactor[i];
			OPENOBJ_BEGIN(objId, AcDb::kForWrite, AcDbObject, pObj);
			if (pObj != NULL) {
				pObj->erase();
			}
			OPENOBJ_END();
		}
	}
	else {
		for(int i=0; i<nCount; i++) {
			AcDbObjectId& objId = *m_lstReactor[i];
			OPENOBJ_BEGIN(objId, AcDb::kForRead, AcDbObject, pObj);
			if (pObj != NULL) {
				//判断有多少永久实体
				int nPersistentNum = 0;
				const AcDbVoidPtrArray *pReactors;
				void             *pSomething;
				pReactors = pObj->reactors();
				if (pReactors != NULL && pReactors->length() > 0) {
					for (int j = 0; j < pReactors->length(); j++) {
						pSomething = pReactors->at(j);
						if (acdbIsPersistentReactor(pSomething)) {
							nPersistentNum++;
							break;
						}
					}
				}
				//如果少于两个，删除
				if (nPersistentNum<=0){
					if(pObj->upgradeOpen()==Acad::eOk) {
						pObj->assertWriteEnabled();
						pObj->erase();
						pObj->downgradeOpen();
					}
				}
			}
			OPENOBJ_END();
		}
	}
	DetachAll();
}

void TReactor::RemovePersistentReactor(const AcDbObjectId& objId)
{
	if (objId.isNull())
		return;

	int nCount = m_lstReactor.Length();
	for(int j=0; j<nCount; j++) {
		AcDbObjectId& idReactor = *m_lstReactor[j];
		OPENOBJ_BEGIN(idReactor, AcDb::kForRead, AcDbObject, pReactor);
		if (pReactor==NULL)
			continue;
		const AcDbVoidPtrArray *pReactors;
		void			*pSomething;
		pReactors = pReactor->reactors();
		if (pReactors==NULL || pReactors->length()<=0)
			continue;
		for (int k = 0; k < pReactors->length(); k++) {
			pSomething = pReactors->at(k);
			if (acdbIsPersistentReactor(pSomething)) {
				AcDbObjectId idPer=acdbPersistentReactorObjectId(pSomething);
				if (idPer == objId) {
					if(pReactor->upgradeOpen()==Acad::eOk) {
						pReactor->assertWriteEnabled();
						pReactor->removePersistentReactor(objId);
						pReactor->downgradeOpen();
					}
					break;
				}
			}
		}
		OPENOBJ_END();
	}
}

///////////////////////////////////////////////////////////////
//	类名 : TReactor			END
//	类名 : TSlope			BEGIN
///////////////////////////////////////////////////////////////

void TSlope::ResetAll()
{
	m_subSlopes.Reset();
	Reset();
}

void TSlope::GetPolys(DList<XPoly2D> &lstPoly) const
{
	XPoly2D* poly2d = new XPoly2D(*this);
	if(poly2d->Length() > 0)
		lstPoly.Append(poly2d);
	else
		delete poly2d;

	int nCount = m_subSlopes.Length();
    for(int i=0; i<nCount; i++) {
        m_subSlopes[i].GetPolys(lstPoly);
    }
}

void TSlope::ProcessSlope(DList<XPoly2D> &sortedRegions, TSlope *parent)
{
    if(!IsValid())
        return;
    DList<XPoly2D> lstOutside(FALSE), lstInside(FALSE);
    int nRegionNum=sortedRegions.Length();
    XPoly2D polyThis=(*this);
    polyThis.SetElevation(0.0);
    for(int n=nRegionNum-1; n>=0; n--) {
        XPoly2D *polyTemp=sortedRegions[n];
        XPoly2D &poly2d=(*polyTemp);
        XPoint ptMid=poly2d.GetInsidePoint(); // 
        ptMid.z=0;
        int nPrFlag=(ptMid&polyThis); //只有z坐标为0，才能判断正确的关系
        DList<XPoly2D> &rList=(nPrFlag==PR_INSIDE? lstInside : lstOutside);
        if(!rList)
            rList.Append(polyTemp);
        else {
            rList[0];
            rList.Insert(polyTemp);
        }
    }

    if(lstInside.Length()) {
        TSlope *pSub=new TSlope;
        (XPoly2D &)(*pSub)=*lstInside.Tail();
        lstInside.Remove(lstInside.Length()-1); //Remove tail
        m_subSlopes.Append(pSub);
        if(lstInside.Length())
            pSub->ProcessSlope(lstInside, this);
    }

    if(parent && lstOutside.Length())
        parent->ProcessSlope(lstOutside);
}


void TSlope::TransformBy(const AcGeMatrix3d xform) 
{
    XPoly2D::TransformBy(xform);
    for(int i=0; i<m_subSlopes.Length(); i++)
        m_subSlopes[i]->TransformBy(xform);
}

Acad::ErrorStatus TSlope::DwgInFields (AcDbDwgFiler* filer)
{
    double nElev=0;
    filer->readItem(&nElev);
    Acad::ErrorStatus es=ReadPoly2D(filer, *this);
    if(es!=Acad::eOk)
        return es;
    SetElevation(nElev);

    m_subSlopes.Reset();
    Adesk::UInt16 nCount=0;
    filer->readItem(&nCount);

    for(int i=0; i<nCount; i++) {
        TSlope *pSub=new TSlope;
        pSub->DwgInFields(filer);
        m_subSlopes.Append(pSub);
    }
    return Acad::eOk;
}

Acad::ErrorStatus TSlope::DwgOutFields(AcDbDwgFiler* filer) const
{
    if(Length()<1)
        return Acad::eInvalidInput;
    double nElev=(*this)[0].z;
    filer->writeItem(nElev);
    Acad::ErrorStatus es=WritePoly2D(filer, *this);
    if(es!=Acad::eOk)
        return es;

    Adesk::UInt16 nCount=m_subSlopes.Length();
    filer->writeItem(nCount);
    for(int i=0; i<nCount; i++) {
        const TSlope &rSub=m_subSlopes[i];;
        es=rSub.DwgOutFields(filer);
        if(es!=Acad::eOk)
            return es;
    }
    return Acad::eOk;
}


BOOL TSlope::IsValid() const
{
    BOOL bRet=((GetFlag()&0x01) && Length()>=2);
    return bRet;
}

// 绘制二维
Acad::ErrorStatus 
TSlope::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    XPoly2D poly2d(*this);
    poly2d.SetElevation(0.0);
    dc << poly2d;
    for(int i=0; i<m_subSlopes.Length(); i++) {
        m_subSlopes[i].ExplodeOrDraw2d(dc);
    }

    return Acad::eOk;
}


Acad::ErrorStatus
TSlope::ExplodeOrDraw3d(XExplodeDraw &dc,BOOL bSlope,int nVertexNum) const
{
    if(!IsValid())
        return Acad::eInvalidInput;

	int nCount=m_subSlopes.Length();
    XPoly2D polyThis(*this);
	if (!polyThis)
		return Acad::eOk;

	if (bSlope) {//斜坡模式
		XContour contourThis(polyThis,nVertexNum);
		polyThis.Reset();
		polyThis.SetFlag(1);
		contourThis.AsPoly2D(polyThis);
		dc.DrawShell(polyThis); 
		
		for(int i=0; i<nCount; i++) {
			XPoly2D polySub(m_subSlopes[i]);
			if(!polySub)
				continue;
			XContour contourSub(polySub,nVertexNum);
			if (contourThis.Length()==contourSub.Length()) {
				polySub.Reset();
				polySub.SetFlag(1);
				contourSub.AsPoly2D(polySub);
				dc.DrawMesh(polySub, polyThis);
			}
		}
		for(i=0; i<nCount; i++)
			m_subSlopes[i].ExplodeOrDraw3d(dc,bSlope,nVertexNum);
	}
	else {//梯田模式
		double nElev=polyThis[0]->z;
        dc.DrawShell(polyThis); 
		
        for(int i=0; i<nCount; i++) {
            XPoly2D polySub(m_subSlopes[i]);
            if(!polySub)
                continue;
            double nElev1=polySub[0]->z;
            polySub.SetElevation(nElev);
            XVector3D vt(0,0, nElev1-nElev);
            dc.DrawMesh(polySub, vt);
        }
		for(i=0; i<nCount; i++)
			m_subSlopes[i].ExplodeOrDraw3d(dc,bSlope,nVertexNum);
	}
    return Acad::eOk;
}

///////////////////////////////////////////////////////////////
//	类名 : TSlope	END
//	类名 : TDbSlope	BEGIN
///////////////////////////////////////////////////////////////


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

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

TDbSlope::TDbSlope()
:m_nControlFlag(0),m_nVertexNum(0),
m_nCMFlag(0),m_bEnableReact(TRUE),
m_bShowSlope(TRUE),m_bTransformBy(TRUE)
{
}

void TDbSlope::ShowSlope(BOOL bSlope)
{
	assertWriteEnabled();
	m_bShowSlope = bSlope;
}

BOOL TDbSlope::IsShowSlope() const
{
	assertReadEnabled();
	return m_bShowSlope;
}

void TDbSlope::EnableReact(BOOL bFlag)
{
	assertWriteEnabled();
	m_bEnableReact = bFlag;
}

BOOL TDbSlope::IsEnableReact() const
{
	assertReadEnabled();
	return m_bEnableReact;
}

void TDbSlope::SetVertexNum(int nNum)
{
	assertWriteEnabled();
	m_nVertexNum = nNum;
}

int  TDbSlope::GetVertexNum() const
{
	assertReadEnabled();

	//未初始化时
	if (m_nVertexNum < 3) {
		int nVertexNum = 90;
		double dPerimeter=m_slope.Distance3d();
		if(dPerimeter<=0)
			return 0;
		nVertexNum=AS_INT(GetContourDivNum(dPerimeter)/2);//减小一倍
		return nVertexNum;
	}

	return m_nVertexNum;
}

BOOL TDbSlope::Has2D() const
{
	assertReadEnabled();
	return (m_nCMFlag&CMF_NO2D)==0;
}

void TDbSlope::SetHas2D(BOOL bHas)
{
	assertWriteEnabled();
    if(!bHas) {
        m_nCMFlag |= CMF_NO2D;
    } else {
        m_nCMFlag &= ~CMF_NO2D;
    }
}

void TDbSlope::EnableTransformBy(BOOL bFlag)
{
	assertWriteEnabled();
	m_bTransformBy = bFlag;
}

BOOL TDbSlope::IsTransformBy() const
{
	assertReadEnabled();
	return m_bTransformBy;
}


void TDbSlope::NewReactor(Adesk::UInt16 color)
{
	assertWriteEnabled();
	AcDbObjectId idSlope=objectId();
	if (idSlope.isNull())
		return;

	if(Has2D()) {//关闭二维显示
		SetHas2D(FALSE);
	}
	RemovePersistentReactor(idSlope);
	EraseReactor();

	//得到等高线的XPoly2D
	DList<XPoly2D> lstPoly;
	m_slope.GetPolys(lstPoly);
	int nCount=lstPoly.Length();
	if(nCount <= 0)
		return;

	//生成新的Pline线
    PickSet ssPline(SS_FREE);
	ssPline.IncludeBegin();
	for (int i=0; i<nCount; i++) {
		XPoly2D &polyPline = *lstPoly[i];
		polyPline.Make();
	}
	ssPline.IncludeEnd();
	long lCount=ssPline.Length();
	if(lCount <= 0)
		return;

	//转换成AcDbObjectId
	AcDbObjectIdArray arReactorId;
	for(long index=0L; index<lCount; index++) {
		Entity objName=ssPline[index];
		AcDbObjectId objId;
		if(acdbGetObjectId(objId,objName)==Acad::eOk) {
			arReactorId.append(objId);
		}
    }

	//构造反应堆(永久响应)
	EnableReact(FALSE);
	int nLen=arReactorId.length();
	for(int j=0; j<lCount; j++) {
		AcDbObjectId objId;
		objId=arReactorId[j];
		//设置响应为不可见、红色、建立永久响应连接
		OPENOBJ_BEGIN(objId, AcDb::kForWrite, AcDbEntity, pEnt);
		if(pEnt != NULL) {
			pEnt->setColorIndex(color);
			pEnt->addPersistentReactor(idSlope);
		}
		OPENOBJ_END();
	}
	SetReactors(arReactorId);
	EnableReact(TRUE);
}

// 提供对格式刷的支持
void TDbSlope::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbSlope *pSrc=TDbSlope::cast(pSrcEntity);
    if(pSrc) {
    }
}


BOOL TDbSlope::IsValid() const
{
    BOOL bValid=TDbEntity::IsValid();
    if(!bValid)
        return bValid;
    bValid=TReactor::IsValid();
    if(!bValid)
        return bValid;
    bValid = m_slope.IsValid();
    return bValid;
}

/*
Acad::ErrorStatus
TDbSlope::getClassID(CLSID* pClsid) const
{
    return Acad::eOk;

}
*/

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

    Acad::ErrorStatus es = TDbEntity::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;
    }

    es = pFiler->readItem(&m_nControlFlag);
    es = pFiler->readItem(&m_nVertexNum);
    es = pFiler->readItem(&m_nCMFlag);
    es = pFiler->readItem(&m_bEnableReact);
    es = pFiler->readItem(&m_bShowSlope);	
    es = pFiler->readItem(&m_bTransformBy);	

	es = TReactor::DwgInFields(pFiler);
    if(es != Acad::eOk) return es;
	es = m_slope.DwgInFields(pFiler);
    if(es != Acad::eOk) return es;

    return pFiler->filerStatus();
}

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

    es = pFiler->writeItem(g_nVersion);
    es = pFiler->writeItem(m_nControlFlag);
    es = pFiler->writeItem(m_nVertexNum);
    es = pFiler->writeItem(m_nCMFlag);
    es = pFiler->writeItem(m_bEnableReact);
    es = pFiler->writeItem(m_bShowSlope);
    es = pFiler->writeItem(m_bTransformBy);

	es = TReactor::DwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
    es = m_slope.DwgOutFields(pFiler);
	if(es != Acad::eOk) return es;

    return pFiler->filerStatus();
}


Acad::ErrorStatus TDbSlope::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es=TDbEntity::dxfInFields(pFiler);
    if(es!=Acad::eOk)    return es;

    if (!pFiler->atSubclassData(_T("TDbSlope"))) {
        return Acad::eBadDxfSequence;
    }
    es = TReactor::DxfInFields(pFiler);
    if(es!=Acad::eOk)    return es;

    return pFiler->filerStatus();
}

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

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

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbSlope"));
   assert(es == Acad::eOk);
   es = TReactor::DxfOutFields(pFiler);
   assert(es == Acad::eOk);

   return es;
}

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


Acad::ErrorStatus
TDbSlope::subDeepClone(AcDbObject*    pOwner,
					AcDbObject*&   pClonedObject,
					AcDbIdMapping& idMap,
					Adesk::Boolean isPrimary) const
{
    Acad::ErrorStatus es=
		TDbEntity::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
    if(es!=Acad::eOk)
        return es;
	if(!HasReactor())
		return Acad::eOk;

    TDbSlope *pClonedSlope = TDbSlope::cast(pClonedObject);
    ASSERT(pClonedSlope);
	pClonedSlope->DetachAll();

    return Acad::eOk;
}

Acad::ErrorStatus 
TDbSlope::subTransformBy(const AcGeMatrix3d& xform)
{
	extern XString GetCurCommand();
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
	if (!m_bTransformBy)
		return Acad::eOk;

	if(HasReactor()) {
		if(database()!=NULL) {
			EnableReact(FALSE);
			TReactor::TransformBy(xform);
			EnableReact(TRUE);
		}
	}

	//圆周的分段数
	BOOL bComputeVertex=FALSE;
	int nVertexOld=0,nVertexNew=0;
	if (_tcsicmp(GetCurCommand(), _T("SCALE"))==0 &&
		m_nVertexNum>0) {
		bComputeVertex=TRUE;
	}
	if (bComputeVertex) {
		double dPerimeter=m_slope.Distance3d();
		if(dPerimeter>0) {
			nVertexOld=GetContourDivNum(dPerimeter);
		}
	}

    m_slope.TransformBy(xform);

	//圆周的分段数
	if (bComputeVertex) {
		double dPerimeter=m_slope.Distance3d();
		if(dPerimeter>0) {
			nVertexNew=GetContourDivNum(dPerimeter);
		}
		if (nVertexOld>0 && nVertexNew>0) {
			double dScale = nVertexNew/nVertexOld;
			m_nVertexNum = AS_INT(m_nVertexNum*dScale);
		}
	}

    return Acad::eOk;
}


Acad::ErrorStatus 
TDbSlope::subGetOsnapPoints(AcDb::OsnapMode       osnapMode, 
                         INT_PTR                   gsSelectionMark, 
                         const AcGePoint3d&    ptPick, 
                         const AcGePoint3d&    lastPoint, 
                         const AcGeMatrix3d&   viewXform, 
                         AcGePoint3dArray&     snapPoints, 
                         AcDbIntArray&     geomIds) const
{
    Acad::ErrorStatus es=Acad::eOk;
    int expMode=GetExplodeMode();
    if(expMode==DRAW_2D) {
        es = TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick,
            lastPoint, viewXform, snapPoints, geomIds);
    }

    return es;
}


Acad::ErrorStatus TDbSlope::subErase(Adesk::Boolean bErasing)
{
	AcDbObjectId idSlope=objectId();

	Acad::ErrorStatus es = TDbEntity::subErase(bErasing);
	if (es != Acad::eOk)
		return es;

	RemovePersistentReactor(idSlope);
	EraseReactor();

    return Acad::eOk;
}


// 绘制二维
Acad::ErrorStatus 
TDbSlope::ExplodeOrDraw2d(XExplodeDraw &dc) const
{

	if (!Has2D()) {
		return Acad::eOk;
	} else {
		return m_slope.ExplodeOrDraw2d(dc);
	}
}

static int CompareByX(const XPoint *p1, const XPoint *p2)
{
	if(p1->x<p2->x)
		return -1;
	return 1;
}


static int CompareByY(const XPoint *p1, const XPoint *p2)
{
	if(p1->y<p2->y)
		return -1;
	return 1;
}

// 由X和Y两个方向进行拟合出高度
Acad::ErrorStatus TDbSlope::DrawSlope3d(XExplodeDraw &dc) const
{
	DList<XPoly2D> lstOutlines;
	m_slope.GetPolys(lstOutlines);
	XPoly2D polyExt=m_slope;
	int row=100, col=100;
	double nExtElev=polyExt.Head()->z;

	XPoint ptLow, ptUp;
	polyExt.SetElevation(0.0);
	polyExt.GetExtend(ptLow, ptUp);
	AcGePoint3d *vertices=new AcGePoint3d[row*col];
	XPointList *rowIntPoints=new XPointList[row];
	XPointList *colIntPoints=new XPointList[col];

	double nRowSpace=(ptUp.y-ptLow.y)/(row-1);
	double nColSpace=(ptUp.x-ptLow.x)/(col-1);

	// 求行交点，并按x由小到大排序
	XLine lnRow;
	lnRow.SetLineFlag(LS_FINITE);
	lnRow.StartPoint().x=ptLow.x-_DIST_SNAP;
	lnRow.EndPoint().x=ptUp.x+_DIST_SNAP;
	for(int m=0; m<row; m++) {
		lnRow.StartPoint().y=lnRow.EndPoint().y=ptLow.y+m*nRowSpace;
		AcDbLine ln2d(lnRow.StartPoint(), lnRow.EndPoint());
		for(int i=0; i<lstOutlines.Length(); i++) {
			AcGePoint3dArray ptArray;
			XPoly2D poly(*lstOutlines[i]);
			double nElev=poly.Head()->z;
			poly.SetElevation(0.0);
			AcDbPolyline pline;
			PolyConvert(poly, pline);
			ln2d.intersectWith(&pline, AcDb::kOnBothOperands, ptArray);
			for(int k=0; k<ptArray.length(); k++) {
				XPoint ptInt;
				ptInt=ptArray[k];
				ptInt.z=nElev;
				BOOL bAdd=TRUE;
				for(int j=0; j<rowIntPoints[m].Length(); j++) {
					XPoint &rpt=*rowIntPoints[m][j];
					if(rpt.Distance2d(ptInt)<_DIST_SNAP) {
						rpt.z = max(rpt.z, ptInt.z);
						bAdd=FALSE;
						break;
					}
				}
				if(bAdd)
					rowIntPoints[m].Append(new XPoint(ptInt));
			}
		}
		rowIntPoints[m].QuickSort(CompareByX);
	}

	// 求列交点，并按y由小到大排序
	XLine lnCol;
	lnCol.SetLineFlag(LS_FINITE);
	lnCol.StartPoint().y=ptLow.y-_DIST_SNAP;
	lnCol.EndPoint().y=ptUp.y+_DIST_SNAP;
	for(int n=0; n<col; n++) {
		lnCol.StartPoint().x=lnCol.EndPoint().x=ptLow.x+n*nColSpace;
		AcDbLine ln2d(lnCol.StartPoint(), lnCol.EndPoint());
		for(int i=0; i<lstOutlines.Length(); i++) {
			AcGePoint3dArray ptArray;
			XPoly2D poly(*lstOutlines[i]);
			double nElev=poly.Head()->z;
			poly.SetElevation(0.0);
			AcDbPolyline pline;
			PolyConvert(poly, pline);
			ln2d.intersectWith(&pline, AcDb::kOnBothOperands, ptArray);
			for(int k=0; k<ptArray.length(); k++) {
				XPoint ptInt;
				ptInt=ptArray[k];
				ptInt.z=nElev;
				BOOL bAdd=TRUE;
				for(int j=0; j<colIntPoints[n].Length(); j++) {
					XPoint &rpt=*colIntPoints[n][j];
					if(rpt.Distance2d(ptInt)<_DIST_SNAP) {
						rpt.z = max(rpt.z, ptInt.z);
						bAdd=FALSE;
						break;
					}
				}
				if(bAdd)
					colIntPoints[n].Append(new XPoint(ptInt));
			}
		}
		colIntPoints[n].QuickSort(CompareByY);
	}

	// 由行列两方向找交点拟合
	for(m=0; m<row; m++) {
		for(n=0; n<col; n++) {
			AcGePoint3d &rPoint=vertices[m*col+n];
			rPoint.y = ptLow.y+m*nRowSpace;
			rPoint.x = ptLow.x+n*nColSpace;
			double zx=nExtElev, zy=nExtElev;
			XPointList &rRowList=rowIntPoints[m];
			for(int i=0; i<rRowList.Length(); i++) {
				XPoint &rInt=*rRowList[i];
				if(Equal(rInt.x, rPoint.x, _DIST_SNAP)) {
					zx=rInt.z;
					break;
				} else if(rPoint.x<rInt.x) {
					if(!i)
						break;
					XPoint &rInt1=*rRowList[i-1];
                    if(Equal(rInt.x, rInt1.x, _DIST_SNAP)) {
						zx=(rInt.z+rInt1.z)/2.0;
						ASSERT(0);
					} else { //线性插值
						ASSERT(!Equal(rInt.x, rInt1.x, _DIST_SNAP));
						zx = rInt1.z + (rPoint.x-rInt1.x)*(rInt.z-rInt1.z)/(rInt.x-rInt1.x);
					}
					break;
				}
			}

			XPointList &rColList=colIntPoints[n];
			for(i=0; i<rColList.Length(); i++) {
				XPoint &rInt=*rColList[i];
				if(Equal(rInt.y, rPoint.y, _DIST_SNAP)) {
					zy=rInt.z;
					break;
				} else if(rPoint.y<rInt.y) {
					if(!i)
						break;
					XPoint &rInt1=*rColList[i-1];
                    if(Equal(rInt.y, rInt1.y, _DIST_SNAP)) {
						zy=(rInt.z+rInt1.z)/2.0;
						ASSERT(0);
					} else { //线性插值
						ASSERT(!Equal(rInt.y, rInt1.y, _DIST_SNAP));
						zy = rInt1.z + (rPoint.y-rInt1.y)*(rInt.z-rInt1.z)/(rInt.y-rInt1.y);
					}
					break;
				}
			}

			rPoint.z = (zx+zy)/2.0;
		}
	}

	dc.DrawMesh(m, n, vertices);
	delete [] vertices;
	delete [] rowIntPoints;
	delete [] colIntPoints;
	return Acad::eOk;
}

Acad::ErrorStatus
TDbSlope::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;
	if (m_bShowSlope) {
		if (m_nVertexNum < 3) {
			int nVertexNum = 90;
			double dPerimeter = m_slope.Distance3d();
			if(dPerimeter<=0)
				return Acad::eNotApplicable;
			nVertexNum = AS_INT(GetContourDivNum(dPerimeter)/2);  //减小一倍
			if (nVertexNum < 3) {
				adsout << _T("\n顶点数太少！请重新设置参数或者增大该实体。");
				return Acad::eNotApplicable;
			}
			//es= m_slope.ExplodeOrDraw3d(dc,TRUE,nVertexNum);
			es=DrawSlope3d(dc);
		} else {
			es=DrawSlope3d(dc);
		    //es = m_slope.ExplodeOrDraw3d(dc,TRUE,m_nVertexNum);
		}
	}	else {
		es = m_slope.ExplodeOrDraw3d(dc);
	}
	return es;
}


void TDbSlope::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    lstInfo.Append(new TObjInfoUnit(_T("对象类型"),  _T("等高线")));
}


void TDbSlope::erased(const AcDbObject* pObj,Adesk::Boolean bErasing)
{
	if (!IsEnableReact())
		return;

	Adesk::Boolean bWritable;
	Acad::ErrorStatus es = upgradeFromNotify(bWritable);
	if (es == Acad::eOk) {
		AcDbObjectId idReactor = pObj->objectId();
		if (bErasing) {
			Detach(idReactor);
		} else {
			Attach(idReactor);
		}
		downgradeToNotify(bWritable);
	}

}


void TDbSlope::modified(const AcDbObject* pObj)
{
	if (!IsEnableReact())
		return;
	if (pObj->database()==NULL)
		return;
	if (isErased())
		return;
	
	ads_name entReactor;
	AcDbObjectId idReactor = pObj->objectId();
	//当前实体是否是自己的反应器
	if(!IsExist(idReactor) || 
		acdbGetAdsName(entReactor,idReactor)!=Acad::eOk) {
		return;
	}
	
	//当前反应器
	DList<XPoly2D> lstRegion;		
	XPoly2D* pReg=new XPoly2D(entReactor);
	pReg->Compress();
	if (pReg->Length()>0 && pReg->IsClosed()) {
		lstRegion.Append(pReg);
	} else {
		delete pReg;
		return;
	}
	
	//构造截面
	int nCount = m_lstReactor.Length();
	for (int i=0; i<nCount; i++) {
		ads_name objName;
		AcDbObjectId& objId = *m_lstReactor[i];
		if(objId!=idReactor && acdbGetAdsName(objName,objId)==Acad::eOk) {
			XPoly2D* pReg=new XPoly2D(objName);
			pReg->Compress();
			if (pReg->Length()>0 && pReg->IsClosed()) {
				lstRegion.Append(pReg);
			} else {
				delete pReg;
			}
		}
	}
	if (lstRegion.Length()<=0)
		return;


	Adesk::Boolean bWritable;
	Acad::ErrorStatus es = upgradeFromNotify(bWritable);
	if (es == Acad::eOk) {	
		assertWriteEnabled();
		m_slope.ResetAll();
		lstRegion.QuickSort(CompareArea);
		(XPoly2D &)(m_slope)=*lstRegion.Tail();
		lstRegion.Remove(lstRegion.Length()-1);
		m_slope.ProcessSlope(lstRegion);
		downgradeToNotify(bWritable);
	}/*
	else {
		if(upgradeOpen()==Acad::eOk) {
			m_slope.ResetAll();
			lstRegion.QuickSort(CompareArea);
			(XPoly2D &)(m_slope)=*lstRegion.Tail();
			lstRegion.Remove(lstRegion.Length()-1);
			m_slope.ProcessSlope(lstRegion);
			downgradeOpen();
		}
	}*/
}


//   创建斜坡等高线
void CreateSlope()
{
    RBList mask=ads_buildlist(-4, _T("<or"),
							  -4, _T("<and"), 
							  	  RTDXF0, _T("POLYLINE,LWPOLYLINE"), 
							  	  70, 1,
							  -4, _T("and>"),
						  	  RTDXF0, _T("CIRCLE"),
							  -4, _T("or>"), NULL);
    PickSet ssSelect(SS_FREE);
    if(SelectEntities(_T("\n选择闭合曲线"), ssSelect, mask)!=RTNORM)
		return;

	//**** 以下是未定义永久响应的斜坡实体 ****//
	/*DList<XPoly2D> lstRegion;
	long lCount=ssSelect.Length();
	for(long idx=0L; idx<lCount; idx++) {
		Entity ent=ssSelect[idx];
		XPoly2D *pReg=new XPoly2D(ent);
		if(pReg->IsSelfIntersect())
			delete pReg;
		else
			lstRegion.Append(pReg);
	}
	int nRegionNum=lstRegion.Length();
	if(!nRegionNum)	return;

	TDbSlope *pSlope=new TDbSlope;
	lstRegion.QuickSort(CompareArea);//快速排序(从小到大)
	(XPoly2D &)(pSlope->m_slope)=*lstRegion.Tail();
	lstRegion.Remove(lstRegion.Length()-1);
	pSlope->m_slope.ProcessSlope(lstRegion);
	pSlope->AddToMSpace(Adesk::kTrue);*/
	//**** 以上是未定义永久响应的斜坡实体 ****//

	//****  以下是定义永久响应的斜坡实体  ****//
	//转换成Id,去除不符合的实体
	DList<XPoly2D>		lstRegion;//截面
	AcDbObjectIdArray	arReactorId;//id值
	long lCount=ssSelect.Length();
	for(long index=0L; index<lCount; index++) {
		Entity  objName=ssSelect[index];
        XPoly2D polyTemp(objName);
		polyTemp.Compress();
		AcDbObjectId objId;
        if(polyTemp.Length()<=0 || polyTemp.IsSelfIntersect()) 
			continue;
		if(acdbGetObjectId(objId,objName)==Acad::eOk) {
			if(!arReactorId.contains(objId)) {
				arReactorId.append(objId);//id值
				XPoly2D *pReg=new XPoly2D(objName);
				lstRegion.Append(pReg);//截面
			}
		}
    }

    int nRegionNum=lstRegion.Length();
    if(!nRegionNum)  return;

	//斜坡
	AcDbObjectId idSlope;
    TDbSlope *pSlope=new TDbSlope;
	pSlope->EnableReact(FALSE);
    lstRegion.QuickSort(CompareArea);//快速排序(从小到大)
    (XPoly2D &)(pSlope->m_slope)=*lstRegion.Tail();
    lstRegion.Remove(lstRegion.Length()-1);
    pSlope->m_slope.ProcessSlope(lstRegion);
	idSlope=pSlope->AddToMSpace(Adesk::kFalse);

	//构造斜坡反应堆(永久响应)
	if(!idSlope.isNull()) {
		int nLen=arReactorId.length();
		for(int i=0; i<nLen; i++) {
			AcDbObjectId objId;
			objId=arReactorId[i];
			//设置响应为不可见、红色、建立永久响应连接
			OPENOBJ_BEGIN(objId, AcDb::kForWrite, AcDbEntity, pEnt);
			if(pEnt != NULL) {
				pEnt->setColorIndex(1);
				pEnt->setVisibility(AcDb::kInvisible);
				pEnt->addPersistentReactor(idSlope);
			}
			OPENOBJ_END();
		}
	}
	pSlope->SetReactors(arReactorId);
	pSlope->EnableReact(TRUE);
	pSlope->close();
	//****  以上是定义永久响应的斜坡实体  ****//
}

//  编辑TDbSlope实体
int EditSlope(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSlope, pSlope);
    if(pSlope == NULL)
		return RTERROR;

    while(1) {
        XString sPrompts, sKeywords;
		BOOL bHas2D=pSlope->Has2D();
		BOOL bHasReactor=pSlope->HasReactor();
		BOOL bShowSlope=pSlope->IsShowSlope();
		
		if(!bHas2D) {
			sPrompts << _T("\n选择 [显示二维(S)");
			sKeywords << _T("S");
		} else {
			if(bHasReactor) {
				sPrompts << _T("\n选择 [显示响应(S)");
				sKeywords << _T("S");
			} else {
				sPrompts << _T("\n选择 [新建响应(N)");
				sKeywords << _T("N");
			}
		}

		//显示模式：梯田和斜坡
		if(bShowSlope) {
			sPrompts << _T("/改变分段数(C)/显示梯田(M)]<退出>:");
			sKeywords << _T(" C M");
		}
		else {
			sPrompts << _T("/显示斜坡(M)]<退出>:");
			sKeywords << _T(" M");
		}

        XString sKeyword;
        int nRet=0;
        INITGET_BEG(0, sKeywords);
        nRet=ads_getkword(sPrompts, sKeyword);
        INITGET_END();
        if(nRet!=RTNORM)
			break;
		
        TCHAR cKey=sKeyword[0];
		if(cKey==_T('S')) {
			if(pSlope->upgradeOpen()==Acad::eOk) {
				pSlope->assertWriteEnabled();
				pSlope->EnableReact(FALSE);
				if(!bHas2D) {
					pSlope->SetHas2D(TRUE);
					pSlope->ShowReactor(FALSE);
					pSlope->EnableTransformBy(TRUE);
				} else {
					pSlope->SetHas2D(FALSE);
					pSlope->ShowReactor(TRUE);
					pSlope->EnableTransformBy(FALSE);
				}
				pSlope->EnableReact(TRUE);
				pSlope->downgradeOpen();
			}
        }
		/*else if(cKey==_T('E')){//删除响应
			if(pSlope->upgradeOpen()==Acad::eOk) {
				pSlope->assertWriteEnabled();
				pSlope->EraseReactor();
				pSlope->downgradeOpen();
			}
        }*/
		else if(cKey==_T('N')) {//新建响应
			if(pSlope->upgradeOpen()==Acad::eOk) {
				pSlope->assertWriteEnabled();
				pSlope->NewReactor();
				pSlope->downgradeOpen();
			}
		}
		else if(cKey==_T('C')) {//顶点数
			int  nVertexNum=pSlope->GetVertexNum();
			while(1) {
				XString sPrompts(_T("\n输入圆周上分段数目<%d>:"),nVertexNum);
				if (acedGetInt(sPrompts,&nVertexNum)!=RTNORM) {
					break;
				}
				if (nVertexNum<3) {
					adsout << _T("\n分段数不能小于3，请重新输入！");
				} else {
					if(pSlope->upgradeOpen()==Acad::eOk) {
						pSlope->assertWriteEnabled();
						pSlope->SetVertexNum(nVertexNum);
						pSlope->downgradeOpen();
						break;
					}
				}
			}
		}
		else if(cKey==_T('M')) {//显示模式
			if(pSlope->upgradeOpen()==Acad::eOk) {
				pSlope->assertWriteEnabled();
				pSlope->ShowSlope(!bShowSlope);
				pSlope->downgradeOpen();
			}
		}
	}

    OPENOBJ_END();
    return RTNORM;
}

void InitDbSlope(BOOL bTrue)
{
    if(bTrue) {
        TDbSlope::rxInit();
		TDbSlope::SetEditMethod(EditSlope);
        acrxBuildClassHierarchy();
        TDbSlope::InitMatchProtocol(TRUE);
    } else {
        TDbSlope::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbSlope::desc());
    }
}