#include "stdafx.h"
#include "TDbImpPartBase.h"
#include "acgs.h"
#include "gs.h"
#include "TImpSpecPart.h"
#include "TDbFittingCreatorService.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

TDbImpPartBase::TDbImpPartBase(TDbPartBase* pEnt)
	: m_XDataMap(*pEnt->GetSpecialtyData())
{
	m_pSpecPart = NULL;
	m_pOwnerEnt = pEnt;
	m_nDwgVersion = 1;
}

TDbImpPartBase::~TDbImpPartBase()
{
	if (m_pSpecPart != NULL)
	{
		m_pSpecPart->Destroy();
	}
}

void TDbImpPartBase::SetVersion(int nVersion)
{
	m_nDwgVersion = nVersion;
}

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

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

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

int	 TDbImpPartBase::GetInterfaceCount() const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->GetInterfaceCount();
	}
	return 0;
}

BOOL TDbImpPartBase::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->SetInterfaceRelation(ptConnect,idConnect);
	}
	return 0;
}

BOOL TDbImpPartBase::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->RemoveInterfaceRelation(ptConnect,idConnect);
	}
	return 0;	
}

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

TDbXDataMap* TDbImpPartBase::GetSpecialtyData()
{
	return &m_XDataMap;
}

BOOL TDbImpPartBase::AddCoverEdge(AcDbObjectId& id,TComplexCurve& curEdge)
{
	return FALSE;
}

BOOL TDbImpPartBase::RemoveCoverEdge(AcDbObjectId& id)
{
	return FALSE;
}

BOOL TDbImpPartBase::GetGeomExtentsEdge(TComplexCurve& crLoop)
{
	return FALSE;
}

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

BOOL TDbImpPartBase::ReCreateByXDataMap()
{
	CString sService;
	m_XDataMap.GetAt(KEY_FITSRV,sService);

	TDbFittingCreatorService* pFitCreatorService = NULL;
	pFitCreatorService = (TDbFittingCreatorService*)acrxServiceDictionary->at(sService);
	if (pFitCreatorService != NULL)
	{
		TImpSpecPart* pNewFitting = NULL;
		pNewFitting = pFitCreatorService->CreateSpecialPart(&m_XDataMap,m_pOwnerEnt);
		if (pNewFitting != NULL)
		{
			if (m_pSpecPart != NULL)
				m_pSpecPart->Destroy();
			m_pSpecPart = pNewFitting;
			return TRUE;
		}
	}
	return FALSE;
}

Acad::ErrorStatus TDbImpPartBase::setNormal(const AcGeVector3d& vtNorm)
{
	m_XDataMap.SetAt(KEY_NORMAL,vtNorm);
	return Acad::eOk;
}

AcGeVector3d TDbImpPartBase::normal() const
{
	AcGeVector3d vt = AcGeVector3d::kZAxis;
	m_XDataMap.GetAt(KEY_NORMAL,vt);
	return vt;
}

Acad::ErrorStatus TDbImpPartBase::copyFrom(const TDbImpPartBase* pSrc)
{
 	if (pSrc != NULL)
 	{
		m_XDataMap.CopyFrom(&pSrc->m_XDataMap);
		ReCreateByXDataMap();
		return Acad::eOk;
 	}
 	return Acad::eInvalidInput;
}

void TDbImpPartBase::list() const
{
	if (m_pSpecPart != NULL)
	{
		m_pSpecPart->list();
	}
}

Acad::ErrorStatus TDbImpPartBase::dwgInFields(AcDbDwgFiler* pFiler)
{
	// change by hh 2013-9-2 版本小于2时 才读取XDataMap
	// m_XDataMap.dwgInFields(pFiler);
	if(2 > m_nDwgVersion)
	{
		m_XDataMap.dwgInFields(pFiler);
	}
	ReCreateByXDataMap();
	return Acad::eOk;
}

Acad::ErrorStatus TDbImpPartBase::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	// Write version number.
	// change by hh 2013-9-2 TXDataMap改在底层中进行读写
	// m_XDataMap.dwgOutFields(pFiler);
	if (g_nSaveTArchVer <= 9)
	{
		m_XDataMap.dwgOutFields(pFiler);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbImpPartBase::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOutOfMemory;
}

Acad::ErrorStatus TDbImpPartBase::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOutOfMemory;
}

Acad::ErrorStatus TDbImpPartBase::explode(AcDbVoidPtrArray& entitySet) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->explode(entitySet);
	}
	return Acad::eOutOfMemory;
}

Acad::ErrorStatus TDbImpPartBase::extend(Adesk::Boolean extendStart,
                                     const AcGePoint3d& toPoint)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->extend(extendStart,toPoint);
	}
	return Acad::eOutOfMemory;
}

Acad::ErrorStatus TDbImpPartBase::extend(double newParam)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->extend(newParam);
	}
	return Acad::eOutOfMemory;
}

Acad::ErrorStatus TDbImpPartBase::getClassID(CLSID* pClsid) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->getClassID(pClsid);
	}
	return Acad::eOutOfMemory;
}

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

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

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

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

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

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

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

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

Acad::ErrorStatus TDbImpPartBase::getGeomExtents(AcDbExtents& extents) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->getGeomExtents(extents);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbImpPartBase::getGripPoints(AcGePoint3dArray& gripPoints,
                                            AcDbIntArray& osnapModes,
                                            AcDbIntArray& geomIds) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->getGripPoints(gripPoints,osnapModes,geomIds);
	}
	return Acad::eInvalidInput;
}

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

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

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

Acad::ErrorStatus TDbImpPartBase::getParamAtPoint(const AcGePoint3d& x0,
                                              double& x1)const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->getParamAtPoint(x0,x1);
	}
	return Acad::eInvalidInput;
}

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

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

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

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

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

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

Acad::ErrorStatus TDbImpPartBase::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->getStretchPoints(stretchPoints);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbImpPartBase::intersectWith(const AcDbEntity* pEnt,
                                            AcDb::Intersect intType,
                                            AcGePoint3dArray& points,
                                            INT_PTR thisGsMarker,
                                            INT_PTR otherGsMarker) const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
	}
	return Acad::eInvalidInput;
}

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

Acad::ErrorStatus TDbImpPartBase::moveGripPointsAt(const AcDbIntArray& indices,
                                               const AcGeVector3d& offset)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->moveGripPointsAt(indices,offset);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbImpPartBase::moveStretchPointsAt(const AcDbIntArray& indices,
                                                  const AcGeVector3d& offset)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->moveStretchPointsAt(indices,offset);
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus TDbImpPartBase::transformBy(const AcGeMatrix3d& xform)
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->transformBy(xform);
	}
	return Acad::eNotApplicable;
}

Acad::ErrorStatus TDbImpPartBase::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pSpecPart != NULL)
	{
		AcGeVector3d viewDir(0,0,1);
		GetActiveViewPortInfo(viewDir);

		if (viewDir.isParallelTo(AcGeVector3d::kZAxis))
		{
			if (m_pOwnerEnt->cloneMeForDragging())
			{
				m_pSpecPart->ExplodeOrDraw2d(mode);
			}
			else
			{
				//同时处理遮挡显示...


				m_pSpecPart->ExplodeOrDraw2d(mode);
			}
		}
		else
		{
			acedUpdateDisplay();
			return Acad::eNotImplementedYet;
		}
	}
	return Acad::eOk;
}

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

BOOL TDbImpPartBase::GetActiveViewPortInfo(AcGeVector3d& viewDir) const
{
	viewDir = AcGeVector3d::kZAxis;
	struct resbuf rb;
	memset (&rb, 0, sizeof (struct resbuf));
	acedGetVar (_T("VIEWDIR"), &rb);
	viewDir.set(rb.resval.rpoint[X], rb.resval.rpoint[Y], rb.resval.rpoint[Z]);
	viewDir.normalize();
	return TRUE;
}

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

AcDbPolyline* TDbImpPartBase::MakePolyCurve() const
{
	if (m_pSpecPart != NULL)
	{
		return m_pSpecPart->MakePolyCurve();
	}
	return NULL;
}