#include "StdAfx.h"
#include "StdArx.h"
#include "dbproxy.h"
#include "geassign.h"
#include "acgi.h"
#include "TDbFitting.h"
#include "TDbImpFitting.h"
#include "TGripImp.h"

// #define VERSION_TDBFITTINGBASE 1
#define VERSION_TDBFITTINGBASE 2 // change by hh 2013-9-2 TXDataMap改在底层中进行读写 暖通图纸版本升级到2

// TDb::GripAppData TDbFittingBase::s_gripAppData[10];
TDb::GripAppData TDbFittingBase::s_gripAppData[GRIP_MAXNUM_FITTING];

//{{AFX_ARX_MACRO
ACRX_DXF_DEFINE_MEMBERS( TDbFittingBase, TDbInterfacesObj,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
                         AcDbProxyEntity::kAllAllowedBits,
						 ATS_DBFITTINGBASE, "图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
//}}AFX_ARX_MACRO
IMPLEMENT_TENTBASE(TDbFittingBase);

TDbFittingBase::TDbFittingBase()
{
	//{{AFX_ARX_DATA_INIT(TDbFittingBase)
	//}}AFX_ARX_DATA_INIT
	m_pImpFitting = new TDbImpFitting(this);
}

TDbFittingBase::~TDbFittingBase()
{
	if (m_pImpFitting != NULL)
	{
		delete m_pImpFitting;
	}
}

BOOL TDbFittingBase::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetInterface(nIndex,pipeInterface);
	}
	return FALSE;
}

BOOL TDbFittingBase::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetInterface(ptCon,pipeInterface);
	}
	return FALSE;
}

BOOL TDbFittingBase::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->HasInterface(ptCon,vtDir);
	}
	return FALSE;
}

int	TDbFittingBase::GetInterfaceCount() const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetInterfaceCount();
	}
	return 0;
}

BOOL TDbFittingBase::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->SetInterfaceRelation(ptConnect,idConnect);
	}
	return FALSE;
}

BOOL TDbFittingBase::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect1,const AcDbObjectId& idConnect2)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->SetInterfaceRelation(ptConnect,idConnect1,idConnect2);
	}
	return FALSE;	
}

BOOL TDbFittingBase::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->RemoveInterfaceRelation(ptConnect,idConnect);
	}
	return FALSE;
}

BOOL TDbFittingBase::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->NotifyInterfaceToModify(iModiMsg,iModiMsgs);
	}
	return FALSE;
}

// TDbXDataMap* TDbFittingBase::GetSpecialtyData()
// {
// 	if (m_pImpFitting != NULL)
// 	{
// 		if (isWriteEnabled())
// 		{
// 			assertWriteEnabled();
// 		}
// 		else
// 		{
// 			assertReadEnabled();
// 		}
// 		return m_pImpFitting->GetSpecialtyData();
// 	}
// 	return NULL;
// }
// 
// TDbXDataMap* TDbFittingBase::GetSpecialtyDataReadOnly() const
// {
// 	assertReadEnabled();
// 	if (m_pImpFitting != NULL)
// 	{
// 		return m_pImpFitting->GetSpecialtyData();
// 	}
// 	return NULL;
// }

void TDbFittingBase::GetKindName(CString& sName)
{
	assertReadEnabled();
	sName = _T("TCH_DBFITTING");
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->GetKindName(sName);
	}
}

BOOL TDbFittingBase::ReCreateByXDataMap()
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->ReCreateByXDataMap();
	}
	return FALSE;
}

BOOL TDbFittingBase::AddCoverEdge(AcDbObjectId& id,TComplexCurve& curEdge)
{
	assertWriteEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->AddCoverEdge(id,curEdge);
	}
	return FALSE;
}

BOOL TDbFittingBase::RemoveCoverEdge(AcDbObjectId& id)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->RemoveCoverEdge(id);
	}
	return FALSE;
}

BOOL TDbFittingBase::GetCoverEdgeIds(AcDbObjectIdArray& arIds)
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetCoverEdgeIds(arIds);
	}
	return FALSE;
}

BOOL TDbFittingBase::AddIdsCoverByMe(AcDbObjectId& id)
{
	assertWriteEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->AddIdsCoverByMe(id);
	}
	return FALSE;
}

BOOL TDbFittingBase::GetIdsCoverByMe(AcDbObjectIdArray& arByMeIds)
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetIdsCoverByMe(arByMeIds);
	}
	return FALSE;
}

BOOL TDbFittingBase::GetGeomExtentsEdge(TComplexCurve& crLoop)
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetGeomExtentsEdge(crLoop);
	}
	return FALSE;
}

Acad::ErrorStatus TDbFittingBase::setNormal(const AcGeVector3d& vtNorm)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->setNormal(vtNorm);
	}
	return Acad::eOk;
}

AcGeVector3d TDbFittingBase::normal() const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->normal();
	}
	return AcGeVector3d::kZAxis;
}

Acad::ErrorStatus TDbFittingBase::copyFrom(const AcRxObject* pSrc)
{
	assertWriteEnabled();

	TDbInterfacesObj::copyFrom(pSrc);

	Acad::ErrorStatus eState = Acad::eNotImplementedYet;
	if (m_pImpFitting != NULL)
	{
		TDbFittingBase* pFitting = TDbFittingBase::cast(pSrc);
		if (pFitting != NULL)
		{
			eState = m_pImpFitting->copyFrom(pFitting->m_pImpFitting);
			
			if (cloneMeForDragging())
				m_pImpFitting->GetSpecialtyData()->SetAt(KEY_THISID,pFitting->objectId());
		}
	}
	return Acad::eOk;
}

void TDbFittingBase::subList() const
{
	assertReadEnabled();

	TDbInterfacesObj::subList();
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->list();
	}
}

Acad::ErrorStatus TDbFittingBase::subDeepClone(	AcDbObject* pOwnerObject,
												AcDbObject*& pClonedObject,
												AcDbIdMapping& idMap,
												Adesk::Boolean isPrimary) const
{
	assertReadEnabled();

	Acad::ErrorStatus es = TDbInterfacesObj::subDeepClone(pOwnerObject,pClonedObject,idMap,isPrimary);
	if (pClonedObject != NULL)
	{
		TDbFittingBase* pFitt = TDbFittingBase::cast(pClonedObject);
		if (pFitt != NULL)
		{
			pFitt->UserCall(KEY_USER_CALL, NULL);	// 目前仅用于暖通法兰，删除接口。mcl 090916
			pFitt->GetSpecialtyData()->SetAt(KEY_DEEPCLONEFLAG, 1);
		}
	}
	if (pClonedObject != NULL)
	{
		TDbFittingBase* pBase = TDbFittingBase::cast(pClonedObject);
		if (pBase != NULL)
		{
			TDbXDataMap* pMapClone = NULL;
			TDbXDataMap* pMapThis = m_pImpFitting->GetSpecialtyData();

			if ( pBase->m_pImpFitting != NULL)
			{
				pMapClone = pBase->m_pImpFitting->GetSpecialtyData();
			}

			if ( pMapThis != NULL)
			{
				pMapThis->BeginCloneXlation(pMapClone,idMap);
			}
		}
	}
	return es;
}


Acad::ErrorStatus TDbFittingBase::subWblockClone( AcRxObject* pOwnerObject,
												 AcDbObject*& pClonedObject,
												 AcDbIdMapping& idMap,
												 Adesk::Boolean isPrimary) const
{

	assertReadEnabled();

	Acad::ErrorStatus es = TDbInterfacesObj::subWblockClone(pOwnerObject, pClonedObject, idMap, isPrimary);
	if (pClonedObject != NULL)
	{
		TDbFittingBase* pBase = TDbFittingBase::cast(pClonedObject);
		if (pBase != NULL)
		{
			TDbXDataMap* pMapClone = NULL;
			TDbXDataMap* pMapThis = m_pImpFitting->GetSpecialtyData();

			if ( pBase->m_pImpFitting != NULL)
			{
				pMapClone = pBase->m_pImpFitting->GetSpecialtyData();
			}

			if ( pMapThis != NULL)
			{
				pMapThis->BeginCloneXlation(pMapClone,idMap);
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbFittingBase::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;

	// Call dwgInFields from TDbInterfacesObj
	if ((es = TDbInterfacesObj::dwgInFields(pFiler)) != Acad::eOk) 
	{
		return es;
	}

	// Read version number.
	Adesk::UInt16 version;
	pFiler->readItem(&version);
	if (version > VERSION_TDBFITTINGBASE)
		return Acad::eMakeMeProxy;
	
	AcDbSoftPointerId idThis;
	/*switch (version)
	{
	case (1):
		{
			pFiler->readItem(&idThis);
			m_pImpFitting->dwgInFields(pFiler);
			if (m_pImpFitting->GetSpecialtyData() != NULL)
			{
				m_pImpFitting->GetSpecialtyData()->SetAt(KEY_THISID,idThis);
			}
			break;
		}
	default:
		break;
	}*/

	// add by hh 2013-9-2 设置图纸版本 用于在Imp类中处理版本问题
	pFiler->readItem(&idThis);
	m_pImpFitting->SetVersion(version);
	m_pImpFitting->dwgInFields(pFiler);
	if(2 > version)
	{
		if (m_pImpFitting->GetSpecialtyData() != NULL)
		{
			m_pImpFitting->GetSpecialtyData()->SetAt(KEY_THISID,idThis);
		}
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbFittingBase::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es;

	// Call dwgOutFields from TDbInterfacesObj
	if ((es = TDbInterfacesObj::dwgOutFields(pFiler)) != Acad::eOk) 
	{
		return es;
	}

	// Write version number.
	// change by hh 2013-9-2 另存为9以下图纸时，版本号置为1
	// pFiler->writeItem((Adesk::UInt16) VERSION_TDBFITTINGBASE);
	if (g_nSaveTArchVer <= 9)
		pFiler->writeItem((Adesk::UInt16) 1);
	else
		pFiler->writeItem((Adesk::UInt16) VERSION_TDBFITTINGBASE);

	pFiler->writeItem(AcDbSoftPointerId(objectId()));
	m_pImpFitting->dwgOutFields(pFiler);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbFittingBase::dxfInFields(AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	struct resbuf rb;

	if ((TDbInterfacesObj::dxfInFields(pFiler) != Acad::eOk) ||
	    !pFiler->atSubclassData(_T("TDbFittingBase")))
		return pFiler->filerStatus();

	// Read version number.
	pFiler->readItem(&rb);
	if (rb.restype != AcDb::kDxfInt16)
	{
		pFiler->pushBackItem();
		pFiler->setError(Acad::eInvalidDxfCode,
		                _T("Error: expected object version group code %d"),
		                 AcDb::kDxfInt16);
		return pFiler->filerStatus();
	} 
	else
	{
		Adesk::UInt16 version = rb.resval.rint;
		if (version > VERSION_TDBFITTINGBASE)
			return Acad::eMakeMeProxy;
	}
	return pFiler->filerStatus();
}

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

	if ((es = TDbInterfacesObj::dxfOutFields(pFiler)) != Acad::eOk)
		return es;

	// Write subclass marker.
	pFiler->writeItem(AcDb::kDxfSubclass, _T("TDbFittingBase"));

	// Write version number.
	pFiler->writeItem(AcDb::kDxfInt16, (Adesk::UInt16) VERSION_TDBFITTINGBASE);
	return es;
}

Acad::ErrorStatus TDbFittingBase::extend(Adesk::Boolean extendStart,
                                     const AcGePoint3d& toPoint)
{
	assertWriteEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->extend(extendStart,toPoint);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbFittingBase::extend(double newParam)
{
	assertWriteEnabled();

	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->extend(newParam);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbFittingBase::subGetClassID(CLSID* pClsid) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->getClassID(pClsid);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbFittingBase::getClosestPointTo(const AcGePoint3d& givenPnt,
                                                AcGePoint3d& pointOnCurve,
                                                Adesk::Boolean extend) const
{
	assertReadEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getClosestPointTo(givenPnt,pointOnCurve,extend);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getClosestPointTo(const AcGePoint3d& givenPnt,
                                                const AcGeVector3d& direction,
                                                AcGePoint3d& pointOnCurve,
                                                Adesk::Boolean extend) const
{
	assertReadEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getDistAtParam(double param,
                                             double& dist) const
{
	assertReadEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getDistAtParam(param,dist);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getDistAtPoint(const AcGePoint3d& x0,
                                             double& x1)const
{
	assertReadEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getDistAtPoint(x0,x1);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getEndParam(double& x0) const
{
	assertReadEnabled();
	
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getEndParam(x0);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getEndPoint(AcGePoint3d& x0) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getEndPoint(x0);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getFirstDeriv(const AcGePoint3d& x0,
                                            AcGeVector3d& firstDeriv) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getFirstDeriv(x0,firstDeriv);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getFirstDeriv(double param,
                                            AcGeVector3d& firstDeriv) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getFirstDeriv(param,firstDeriv);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subGetGeomExtents(AcDbExtents& extents) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getGeomExtents(extents);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subGetGripPoints(AcGePoint3dArray& gripPoints,
                                            AcDbIntArray& osnapModes,
                                            AcDbIntArray& geomIds) const
{
	assertReadEnabled();
#if ADS==15
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getGripPoints(gripPoints,osnapModes,geomIds);
	}
#endif
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subMoveGripPointsAt(const AcDbIntArray& indices,
                                               const AcGeVector3d& offset)
{
	assertWriteEnabled();

	if (m_pImpFitting != NULL)
	{
		// mcl add.2010.11.08 忽略z标高差
		if(TAuxTools::Is2DView())
		{
			AcGeVector3d vtNoneZ = offset.orthoProject(TAuxTools::GetUcsZvt());
			return m_pImpFitting->moveGripPointsAt(indices, vtNoneZ);
		}
		else
			return m_pImpFitting->moveGripPointsAt(indices,offset);
	}
	return Acad::eInvalidInput;
}

#if ADS>15
Acad::ErrorStatus TDbFittingBase::subGetGripPoints(AcDbGripDataPtrArray& grips,
											 const double viewSize,
											 const int gripSize,
											 const AcGeVector3d& curViewDir, 
											 const int bitflags) const
{

	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		AcDbIntArray osnapModes;
		AcDbIntArray geomIds;
		AcGePoint3dArray gripPoints;
		Acad::ErrorStatus eSta = m_pImpFitting->getGripPoints(gripPoints,osnapModes,geomIds);

		AcDbGripData* pGripData = NULL;
		TDb::Position ePos;

		CString sCmd = _T("");
		GetGlobalContext(KEY_CABGRIPCMD,sCmd);

//		for (int i = 0;i < gripPoints.length();i++) // mcl changed by below .检查夹点数目
		for (int i = 0;i < gripPoints.length() && i < GRIP_MAXNUM_FITTING; i++)
		{
			ePos = m_pImpFitting->ExplainGripIndex(i);
			if (ePos >= TDb::eCommand0 && ePos <= TDb::eCommand3)
			{
				pGripData = new AcDbGripData;
				
				memset(&s_gripAppData[i],0,sizeof(TDb::GripAppData));
				s_gripAppData[i].nIndex = i;
				s_gripAppData[i].ePos = ePos;
				s_gripAppData[i].ptGrip = gripPoints.at(i);
				_tcscpy(s_gripAppData[i].szTip,sCmd);
				s_gripAppData[i].pOwner = (AcDbEntity*)this;
				pGripData->setGripPoint(gripPoints.at(i));
				pGripData->setAppData((void*)&s_gripAppData[i]);
				pGripData->setWorldDraw(GripCback::WorldDrawfunc);
				pGripData->setToolTipFunc(GripCback::GripToolTipFunc);
			}
			else
			{
				pGripData = new AcDbGripData;

				memset(&s_gripAppData[i],0,sizeof(TDb::GripAppData));
				s_gripAppData[i].nIndex = i;
				s_gripAppData[i].ePos = ePos;
				s_gripAppData[i].ptGrip = gripPoints.at(i);
				_tcscpy(s_gripAppData[i].szTip,_T("拉伸夹点"));
				s_gripAppData[i].pOwner = (AcDbEntity*)this;
				pGripData->setGripPoint(gripPoints.at(i));
				pGripData->setAppData((void*)&s_gripAppData[i]);
				pGripData->setToolTipFunc(GripCback::GripToolTipFunc);
			}
			grips.append(pGripData);
		}
		return eSta;
	}
	return Acad::eOk;
}

Acad::ErrorStatus  TDbFittingBase::subMoveGripPointsAt(const AcDbVoidPtrArray& gripAppData,
												 const AcGeVector3d& offset,
												 const int bitflags)
{
	assertWriteEnabled();
	TDb::GripAppData* pAppData = NULL;
	AcDbIntArray arIndex;
	int nSize = gripAppData.length();
	for (int i = 0;i < gripAppData.length();i++)
	{
		pAppData = (TDb::GripAppData*)gripAppData.at(i);
		arIndex.append(pAppData->nIndex);
	}

	Acad::ErrorStatus eSta = Acad::eOk;
	if (m_pImpFitting != NULL)
	{
		// mcl add.2010.09.21 忽略z标高差
		if(TAuxTools::Is2DView())
		{
			AcGeVector3d vtNoneZ = offset.orthoProject(TAuxTools::GetUcsZvt());
			eSta = m_pImpFitting->moveGripPointsAt(arIndex, vtNoneZ);
		}
		else
			eSta = m_pImpFitting->moveGripPointsAt(arIndex,offset);
	}
	return eSta;
}
#endif

Acad::ErrorStatus TDbFittingBase::getOffsetCurves(double offsetDist,
                                              AcDbVoidPtrArray& offsetCurves) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getOffsetCurves(offsetDist,offsetCurves);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
                                             INT_PTR gsSelectionMark,
                                             const AcGePoint3d& pickPoint,
                                             const AcGePoint3d& lastPoint,
                                             const AcGeMatrix3d& viewXform,
                                             AcGePoint3dArray& snapPoints,
                                             AcDbIntArray& geomIds) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,
											 lastPoint,viewXform,snapPoints,geomIds);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getParamAtDist(double dist,
                                             double& param) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getParamAtDist(dist,param);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getParamAtPoint(const AcGePoint3d& x0,
                                              double& x1)const
{
	assertReadEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getParamAtPoint(x0,x1);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getPointAtDist(double x0,
                                             AcGePoint3d& x1) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getPointAtDist(x0,x1);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getPointAtParam(double x0,
                                              AcGePoint3d& x1) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getPointAtParam(x0,x1);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getSplitCurves(const AcGeDoubleArray& params,
                                             AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getSplitCurves(params,curveSegments);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getSplitCurves(const AcGePoint3dArray& points,
                                             AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getSplitCurves(points,curveSegments);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getStartParam(double& x0) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getStartParam(x0);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::getStartPoint(AcGePoint3d& x0) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getStartPoint(x0);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->getStretchPoints(stretchPoints);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subGetTransformedCopy(const AcGeMatrix3d& xform,AcDbEntity*& pEnt) const
{
	assertReadEnabled();
	
	pEnt = new TDbFittingBase;
	(TDbFittingBase*)pEnt->copyFrom(this);
	pEnt->transformBy(xform);

	return Acad::eOk;
}

Acad::ErrorStatus TDbFittingBase::subIntersectWith(	const AcDbEntity* pEnt,
													AcDb::Intersect intType,
													AcGePoint3dArray& points,
													INT_PTR thisGsMarker,
													INT_PTR otherGsMarker) const
{
	assertReadEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->intersectWith(pEnt,intType,
									 points,thisGsMarker,
									 otherGsMarker);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subIntersectWith(	const AcDbEntity* pEnt,
													AcDb::Intersect intType,
													const AcGePlane& projPlane,
													AcGePoint3dArray& points,
													INT_PTR thisGsMarker,
													INT_PTR otherGsMarker) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subMoveStretchPointsAt(const AcDbIntArray& indices,
														 const AcGeVector3d& offset)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		// mcl add.2010.11.09 忽略z标高差
		AcGeVector3d vtOffset = offset;
		if(TAuxTools::Is2DView())
			vtOffset = offset.orthoProject(TAuxTools::GetUcsZvt());

		return m_pImpFitting->moveStretchPointsAt(indices, vtOffset);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbFittingBase::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->GetSpecialtyData()->SetAt(KEY_DEEPCLONEFLAG,0);
		// mcl add.2010.11.08 move 及复制时，忽略z标高差
//		XString &sCmd=GetCurDocData()->m_sCurCommand;
		// Lixl add 指针有效性判断2012-6-18
		TArchPerDocData* pDoc = GetCurDocData();
		if (NULL != pDoc)
		{
			XString &sCmd = pDoc->m_sCurCommand;
			if((_tcsicmp(sCmd,_T("MOVE"))==0 || _tcsicmp(sCmd,_T("copy"))==0 || _tcsicmp(sCmd,_T("pasteclip"))==0)
				&& TAuxTools::Is2DView())
			{
				//change by dyw 20141009 ucs下pasteclip命令角度错误
// 				AcGeVector3d vtNoneZ = xform.translation();
// 				vtNoneZ = vtNoneZ.orthoProject(TAuxTools::GetUcsZvt());
// 				return m_pImpFitting->transformBy(vtNoneZ);

				AcGeVector3d vtNoneZ = xform.translation();
				AcGeMatrix3d mat(xform);
				if(fabs(vtNoneZ.x) > 0.0001 || fabs(vtNoneZ.y) > 0.0001)//2012-9-2 SR 修正：z轴位移除外
				{
					vtNoneZ.x = 0.0;
					vtNoneZ.y = 0.0;
					vtNoneZ.z *= -1;
					AcGeMatrix3d mat1;
					mat1.setToTranslation(vtNoneZ);
					mat *= mat1;
				}
				return m_pImpFitting->transformBy(mat);
			}
			else
				return m_pImpFitting->transformBy(xform);
		}
		else
			return m_pImpFitting->transformBy(xform);
	}
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus TDbFittingBase::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->ExplodeOrDraw2d(mode);
	}
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus TDbFittingBase::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->ExplodeOrDraw3d(mode);
		return Acad::eOk;
	}
	return Acad::eNotImplementedYet;
}

BOOL TDbFittingBase::MakeCurves(TComplexCurve& cplCurve) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->MakeCurves(cplCurve);
	}
	return FALSE;
}

BOOL TDbFittingBase::GetCurvesInSide(TComplexCurve& compCurve) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetCurvesInSide(compCurve);
	}
	return FALSE;
}

AcDbPolyline* TDbFittingBase::MakePolyCurve() const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->MakePolyCurve();
	}
	return NULL;
}

BOOL TDbFittingBase::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->MakePolyCurveFaces(arFaces);
	}
	return NULL;
}

void TDbFittingBase::GetTips(CMapStringToString& mapLable2Tip) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		m_pImpFitting->GetTips(mapLable2Tip);
	}
}

TDb::Position TDbFittingBase::ExplainGripIndex(int nIndex) const
{
	assertReadEnabled();
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->ExplainGripIndex(nIndex);
	}
	return TDb::eStart;
}

BOOL TDbFittingBase::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	if (isWriteEnabled())
		assertWriteEnabled();
	else
		assertReadEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->OPMInfo(pszName, pInfo);
	}

	return FALSE;
}

BOOL TDbFittingBase::IsValid(TDbXDataMap* pXMap)
{
	assertReadEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->IsValid(pXMap);
	}

	return FALSE;
}

LRESULT TDbFittingBase::UserCall(long i,LPVOID pData)
{
	assertWriteEnabled();

	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->UserCall(i,pData);
	}
	return 0l;
}

Acad::ErrorStatus TDbFittingBase::subErase( Adesk::Boolean erasing )
{
	Acad::ErrorStatus eState = TDbInterfacesObj::subErase(erasing);
	if (eState == Acad::eOk)
	{
		if (m_pImpFitting != NULL)
			m_pImpFitting->OnSubErase(erasing);
	}

	return eState;
}

int TDbFittingBase::GetXBaseShell(TXShell& xShell)
{
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetXBaseShell(xShell);
	}
	return 0;
}

int TDbFittingBase::GetBodyBox(AcDbExtents& ext)
{
	if (m_pImpFitting != NULL)
	{
		return m_pImpFitting->GetBodyBox(ext);
	}
	return 0;
}

CString TDbFittingBase::GetXml(const AcGeMatrix3d& mat) const
{
	if (m_pImpFitting == NULL)
		return _T("");

	TDbXDataMap* pMap = GetSpecialtyDataReadOnly();
	if (NULL == pMap)
		return _T("");

	HvacModelType eType(TDb::eModel);
	pMap->GetAt(HVAC_ModeType, (int&)eType);
	if (TDb::eSystem == eType)
		return _T("");

	CString csXml = m_pImpFitting->GetXml(mat);
	CString csBase = TEntityBase::GetXml(mat);
	int nIndex = csXml.Find(_T("</TCH_"));
	if (nIndex > -1)
		csXml.Insert(nIndex, csBase);

	return csXml;
}

bool TDbFittingBase::GetSection( const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir, 
								std::vector<TObjSectionRecord> &sectionRecord, AcDbVoidPtrArray& arFillPtrs ) const
{
	if (m_pImpFitting != NULL)
		return m_pImpFitting->GetSection(face, vtPlaneSecDir, sectionRecord, arFillPtrs);
	
	return false;
}

Acad::ErrorStatus TDbFittingBase::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	if (m_pImpFitting != NULL)
		return m_pImpFitting->GetExtents(ptLow, ptUp);
	
	return Acad::eNotImplementedYet;					
}		

// add by hh 2014-08-06 支持管件与水管遮挡
Acad::ErrorStatus TDbFittingBase::GetClipBoundary(TGGePoly2D& poly)const
{
	if(NULL == m_pImpFitting)
		return Acad::eNotImplementedYet;

	return m_pImpFitting->GetClipBoundary(poly);
}

bool TDbFittingBase::IsMeClip() const
{
	if(NULL == m_pImpFitting)
		return false;

	return m_pImpFitting->IsMeClip();
}

bool TDbFittingBase::IsClipMe(const TEntityBase* pEn)const//ok是否被裁剪
{
	if(NULL == m_pImpFitting)
		return false;

	return m_pImpFitting->IsClipMe(pEn);
}