1766 lines
43 KiB
C++
1766 lines
43 KiB
C++
#include "StdAfx.h"
|
|
#include "StdArx.h"
|
|
#include "TDbImpPipeBase.h"
|
|
#include "TDbFittingCreatorService.h"
|
|
#include "TDbExtentsEdge.h"
|
|
#include "TCoverBooleanOper.h"
|
|
#include "TDbInterfaceMsgWrite.h"
|
|
#include "TGripImp.h"
|
|
|
|
#include "dbproxy.h"
|
|
#include "geassign.h"
|
|
#include "acgi.h"
|
|
#include "math.h"
|
|
|
|
// #define VERSION_TDbPipeBase 1
|
|
#define VERSION_TDbPipeBase 2 // change by hh 2013-9-2 TXDataMap改在底层中进行读写 暖通图纸版本升级到2
|
|
|
|
TDb::GripAppData TDbPipeBase::s_gripAppData[GRIP_MAXNUM];
|
|
|
|
//{{AFX_ARX_MACRO
|
|
ACRX_DXF_DEFINE_MEMBERS( TDbPipeBase, TDbInterfacesObj,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kAllAllowedBits,
|
|
ATS_PIPEBASE, "图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
//}}AFX_ARX_MACRO
|
|
IMPLEMENT_TENTBASE(TDbPipeBase);
|
|
|
|
TDbPipeBase::TDbPipeBase()
|
|
{
|
|
//{{AFX_ARX_DATA_INIT(TDbPipeBase)
|
|
//}}AFX_ARX_DATA_INIT
|
|
m_pImpPipeBase = NULL;
|
|
m_XDataMap.SetAt(KEY_DXF,_T("ATS_PIPEBASE"));
|
|
}
|
|
|
|
TDbPipeBase::~TDbPipeBase()
|
|
{
|
|
}
|
|
|
|
void TDbPipeBase::SetStartPoint(const AcGePoint3d& ptSta)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
AcGePoint3d ptOld = m_pImpPipeBase->StartPoint();
|
|
m_pImpPipeBase->SetStartPoint(ptSta);
|
|
|
|
if (!objectId().isNull())
|
|
{
|
|
UpdateCoverDisplay();
|
|
}
|
|
recordGraphicsModified();
|
|
}
|
|
|
|
AcGePoint3d TDbPipeBase::StartPoint() const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->StartPoint();
|
|
}
|
|
|
|
void TDbPipeBase::SetEndPoint(const AcGePoint3d& ptEnd)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
|
|
AcGePoint3d ptOld = m_pImpPipeBase->EndPoint();
|
|
m_pImpPipeBase->SetEndPoint(ptEnd);
|
|
|
|
if (!objectId().isNull())
|
|
{
|
|
UpdateCoverDisplay();
|
|
}
|
|
recordGraphicsModified();
|
|
}
|
|
|
|
AcGePoint3d TDbPipeBase::EndPoint() const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->EndPoint();
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetInterface(int nIndex,TInterface& pipeInterface) const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->GetInterface(nIndex,pipeInterface);
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->GetInterface(ptCon,pipeInterface);
|
|
}
|
|
|
|
BOOL TDbPipeBase::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->HasInterface(ptCon,vtDir);
|
|
}
|
|
|
|
int TDbPipeBase::GetInterfaceCount() const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->GetInterfaceCount();
|
|
}
|
|
|
|
BOOL TDbPipeBase::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->SetInterfaceRelation(ptConnect,idConnect);
|
|
}
|
|
|
|
BOOL TDbPipeBase::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->RemoveInterfaceRelation(ptConnect,idConnect);
|
|
}
|
|
|
|
BOOL TDbPipeBase::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->NotifyInterfaceToModify(iModiMsg,iModiMsgs);
|
|
}
|
|
|
|
// TDbXDataMap* TDbPipeBase::GetSpecialtyData()
|
|
// {
|
|
// if (isWriteEnabled())
|
|
// {
|
|
// assertWriteEnabled();
|
|
// }
|
|
// else
|
|
// {
|
|
// assertReadEnabled();
|
|
// }
|
|
// return &m_XDataMap;
|
|
// }
|
|
//
|
|
// TDbXDataMap* TDbPipeBase::GetSpecialtyDataReadOnly() const
|
|
// {
|
|
// assertReadEnabled();
|
|
// return (TDbXDataMap*)&m_XDataMap;
|
|
// }
|
|
|
|
Acad::ErrorStatus TDbPipeBase::setNormal(const AcGeVector3d& vtNorm)
|
|
{
|
|
assertWriteEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->setNormal(vtNorm);
|
|
}
|
|
|
|
void TDbPipeBase::GetKindName(CString& sName)
|
|
{
|
|
assertReadEnabled();
|
|
m_XDataMap.GetAt(KEY_DXF,sName);
|
|
}
|
|
|
|
BOOL TDbPipeBase::MakeCurves(TComplexCurve& cplCurve) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->MakeCurves(cplCurve);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetCurvesInSide(TComplexCurve& compCurve) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->GetCurvesInSide(compCurve);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->MakePolyCurveFaces(arFaces);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
AcDbPolyline* TDbPipeBase::MakePolyCurve() const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->MakePolyCurve();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL TDbPipeBase::AddCoverEdge(AcDbObjectId& id,TComplexCurve& curEdge)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
TDbExtentsEdge edage;
|
|
edage.SetOwnerId(id);
|
|
edage.SetEdage(curEdge);
|
|
m_arDbExtEdgs.Add(edage);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::AddIdsCoverByMe(AcDbObjectId& id)
|
|
{
|
|
assertWriteEnabled();
|
|
int nFoundAt = -1;
|
|
if (!m_arIdCoverByMe.find(id,nFoundAt))
|
|
{
|
|
m_arIdCoverByMe.append(id);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetIdsCoverByMe(AcDbObjectIdArray& arByMeIds)
|
|
{
|
|
assertReadEnabled();
|
|
arByMeIds.append(m_arIdCoverByMe);
|
|
for (int j = 0; j < m_lstClippedId.Length(); j++)
|
|
{
|
|
arByMeIds.append(*m_lstClippedId[j]);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::RemoveCoverEdge(AcDbObjectId& id)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
if (id.isNull())
|
|
{
|
|
m_arDbExtEdgs.RemoveAll();
|
|
return TRUE;
|
|
}
|
|
|
|
// 加入的时候已经排序了;
|
|
for (int i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
if (m_arDbExtEdgs.GetAt(i).GetOwnerId() == id)
|
|
{
|
|
m_arDbExtEdgs.RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetCoverEdgeIds(AcDbObjectIdArray& arIds)
|
|
{
|
|
assertReadEnabled();
|
|
|
|
for (int i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
arIds.append(m_arDbExtEdgs.GetAt(i).GetOwnerId());
|
|
}
|
|
for (int j = 0; j < m_lstClipId.Length(); j++)
|
|
{
|
|
arIds.append(*m_lstClipId[j]);
|
|
}
|
|
|
|
return arIds.length() > 0;
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetGeomExtentsEdge(TComplexCurve& crLoop)
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbPolyline* pPl = MakePolyCurve();
|
|
if (pPl != NULL)
|
|
{
|
|
double dBulge = 0.0;
|
|
TDb::TCurveElement curel;
|
|
memset(&curel,0,sizeof(TDb::TCurveElement));
|
|
|
|
int nVerts = pPl->numVerts();
|
|
for (int i = 0;i < nVerts - 1;i++)
|
|
{
|
|
pPl->getPointAt(i,curel.ptGe[0]);
|
|
|
|
dBulge = 0.0;
|
|
pPl->getBulgeAt(i,dBulge);
|
|
|
|
if (fabs(dBulge) < 1.e-10) // 直线
|
|
{
|
|
pPl->getPointAt(i + 1,curel.ptGe[1]);
|
|
curel.ptGe[2] = curel.ptGe[1];
|
|
crLoop.append(curel);
|
|
}
|
|
else //圆弧
|
|
{
|
|
double dPar1 = 0.0,dPar2 = 0.0;
|
|
pPl->getParamAtPoint(curel.ptGe[0],dPar1);
|
|
|
|
pPl->getPointAt(i + 1,curel.ptGe[2]);
|
|
|
|
AcGeCircArc3d geArc;
|
|
pPl->getArcSegAt(i,geArc);
|
|
|
|
curel.ptGe[0] = geArc.startPoint();
|
|
curel.ptGe[2] = geArc.endPoint();
|
|
|
|
dPar1 = geArc.paramOf(curel.ptGe[0]);
|
|
dPar2 = geArc.paramOf(curel.ptGe[2]);
|
|
curel.ptGe[1] = geArc.evalPoint((dPar2 + dPar1) / 2.0);
|
|
|
|
crLoop.append(curel);
|
|
}
|
|
}
|
|
|
|
if (pPl->isClosed())
|
|
{
|
|
//最后一段
|
|
memset(&curel,0,sizeof(TDb::TCurveElement));
|
|
pPl->getPointAt(nVerts - 1,curel.ptGe[0]);
|
|
|
|
double dBulge = 0.0;
|
|
pPl->getBulgeAt(nVerts - 1,dBulge);
|
|
|
|
if (fabs(dBulge) > 1.e-6) //ARC
|
|
{
|
|
double dEndPa = 0.0;
|
|
pPl->getEndParam(dEndPa);
|
|
dEndPa -= 0.2;
|
|
pPl->getPointAtParam(dEndPa,curel.ptGe[1]);
|
|
pPl->getPointAt(0,curel.ptGe[2]);
|
|
}
|
|
else
|
|
{
|
|
pPl->getPointAt(0,curel.ptGe[1]);
|
|
curel.ptGe[2] = curel.ptGe[1];
|
|
}
|
|
//if (curel.ptGe[0].distanceTo(curel.ptGe[1]) > AcGeContext::gTol.equalPoint())
|
|
if (curel.ptGe[0].distanceTo(curel.ptGe[1]) > g_globalTol.equalPoint()) // modify by cq TFS8208
|
|
{
|
|
crLoop.append(curel);
|
|
}
|
|
}
|
|
delete pPl;
|
|
}
|
|
}
|
|
return crLoop.length() > 0;
|
|
}
|
|
|
|
AcGeVector3d TDbPipeBase::normal() const
|
|
{
|
|
assertReadEnabled();
|
|
ASSERT(m_pImpPipeBase != NULL);
|
|
return m_pImpPipeBase->normal();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::copyFrom(const AcRxObject* pSrc)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
if (pSrc != NULL)
|
|
{
|
|
TDbInterfacesObj::copyFrom(pSrc);
|
|
|
|
TDbPipeBase* pPipe = TDbPipeBase::cast(pSrc);
|
|
if (pPipe != NULL)
|
|
{
|
|
m_XDataMap.CopyFrom(&pPipe->m_XDataMap);
|
|
if (pPipe->database() != NULL)
|
|
setDatabaseDefaults(pPipe->database());
|
|
|
|
m_arDbExtEdgs.RemoveAll();
|
|
m_arDbExtEdgs.Add(pPipe->m_arDbExtEdgs);
|
|
m_arIdCoverByMe.setLogicalLength(0);
|
|
m_arIdCoverByMe.append(pPipe->m_arIdCoverByMe);
|
|
|
|
if (cloneMeForDragging())
|
|
m_XDataMap.SetAt(KEY_THISID,pPipe->objectId());
|
|
}
|
|
ReCreateByXDataMap();
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subHandOverTo(AcDbObject* newObject)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
TDbPipeBase* pNewObj = TDbPipeBase::cast(newObject);
|
|
if (pNewObj != NULL)
|
|
{
|
|
AcGePoint3d ptSta = StartPoint();
|
|
AcGePoint3d ptEnd = EndPoint();
|
|
|
|
AcGePoint3d ptStaNew = pNewObj->StartPoint();
|
|
AcGePoint3d ptEndNew = pNewObj->EndPoint();
|
|
|
|
UpdateInterfaceRec(ptSta,ptStaNew);
|
|
UpdateInterfaceRec(ptEnd,ptEndNew);
|
|
}
|
|
return AcDbObject::subHandOverTo(newObject);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getPlane(AcGePlane& plan,AcDb::Planarity& planvt) const
|
|
{
|
|
AcGeVector3d vt = normal();
|
|
AcGeVector3d vtDir = EndPoint() - StartPoint();
|
|
AcGeLine3d line(AcGePoint3d::kOrigin,vtDir);
|
|
|
|
planvt = AcDb::kPlanar;
|
|
if ( AcGePlane::kXYPlane.isParallelTo(line) )
|
|
{
|
|
plan.set(TAuxTools::Mid(StartPoint(),EndPoint()) ,vt);
|
|
}
|
|
else
|
|
{
|
|
plan.set(EndPoint(),AcGePoint3d::kOrigin,StartPoint());
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subDeepClone(AcDbObject* pOwnerObject,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbInterfacesObj::subDeepClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
|
if (pClonedObject != NULL)
|
|
{
|
|
TDbPipeBase* pPipeBase = TDbPipeBase::cast(pClonedObject);
|
|
if (pPipeBase != NULL)
|
|
{
|
|
pPipeBase->GetSpecialtyData()->SetAt(KEY_DEEPCLONEFLAG,1);
|
|
}
|
|
}
|
|
|
|
if (pClonedObject != NULL)
|
|
{
|
|
TDbPipeBase* pBase = TDbPipeBase::cast(pClonedObject);
|
|
if (pBase != NULL)
|
|
{
|
|
TDbXDataMap* pMapClone = NULL;
|
|
const TDbXDataMap* pMapThis = &m_XDataMap;
|
|
|
|
if ( pBase != NULL)
|
|
{
|
|
pMapClone = &pBase->m_XDataMap;
|
|
}
|
|
|
|
if ( pMapThis != NULL)
|
|
{
|
|
pMapThis->BeginCloneXlation(pMapClone,idMap);
|
|
}
|
|
}
|
|
}
|
|
return es;
|
|
}
|
|
Acad::ErrorStatus TDbPipeBase::subWblockClone( AcRxObject* pOwnerObject,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbInterfacesObj::subWblockClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
|
|
|
if (pClonedObject != NULL)
|
|
{
|
|
TDbPipeBase* pBase = TDbPipeBase::cast(pClonedObject);
|
|
if (pBase != NULL)
|
|
{
|
|
TDbXDataMap* pMapClone = NULL;
|
|
const TDbXDataMap* pMapThis = &m_XDataMap;
|
|
|
|
if ( pBase != NULL)
|
|
{
|
|
pMapClone = &pBase->m_XDataMap;
|
|
}
|
|
|
|
if ( pMapThis != NULL)
|
|
{
|
|
pMapThis->BeginCloneXlation(pMapClone,idMap);
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
Acad::ErrorStatus TDbPipeBase::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es;
|
|
|
|
// Call dwgInFields from TDbInterfacesObj
|
|
if ((es = TDbInterfacesObj::dwgInFields(pFiler)) != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
|
|
Adesk::UInt16 version;
|
|
pFiler->readItem(&version);
|
|
if (version > VERSION_TDbPipeBase)
|
|
return Acad::eMakeMeProxy;
|
|
|
|
AcDbSoftPointerId idSoft;
|
|
#if ADS > 20
|
|
int lLen = 0l;
|
|
#else
|
|
long lLen = 0l;
|
|
#endif
|
|
m_arDbExtEdgs.RemoveAll();
|
|
m_arIdCoverByMe.setLogicalLength(0);
|
|
TDbExtentsEdge edage;
|
|
int i = 0;
|
|
|
|
// change by hh 2013-9-2 TXDataMap 在基类中进行读取
|
|
/* switch (version)
|
|
{
|
|
case (1):
|
|
{
|
|
m_XDataMap.dwgInFields(pFiler);
|
|
m_XDataMap.SetAt(KEY_THISID,objectId());
|
|
|
|
pFiler->readInt32(&lLen);
|
|
for (i = 0;i < lLen;i++)
|
|
{
|
|
edage.dwgInFields(pFiler);
|
|
m_arDbExtEdgs.Add(edage);
|
|
}
|
|
|
|
pFiler->readInt32(&lLen);
|
|
for (i = 0;i < lLen;i++)
|
|
{
|
|
pFiler->readSoftPointerId(&idSoft);
|
|
m_arIdCoverByMe.append(idSoft);
|
|
}
|
|
|
|
ReCreateByXDataMap();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}*/
|
|
// 版本2之前的图纸 需读取XDataMap
|
|
if(2 > version)
|
|
{
|
|
m_XDataMap.dwgInFields(pFiler);
|
|
m_XDataMap.SetAt(KEY_THISID,objectId());
|
|
}
|
|
|
|
pFiler->readInt32(&lLen);
|
|
for (i = 0;i < lLen;i++)
|
|
{
|
|
edage.dwgInFields(pFiler);
|
|
m_arDbExtEdgs.Add(edage);
|
|
}
|
|
|
|
pFiler->readInt32(&lLen);
|
|
for (i = 0;i < lLen;i++)
|
|
{
|
|
pFiler->readSoftPointerId(&idSoft);
|
|
m_arIdCoverByMe.append(idSoft);
|
|
}
|
|
ReCreateByXDataMap();
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
BOOL TDbPipeBase::ReCreateByXDataMap()
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
CString sService;
|
|
m_XDataMap.GetAt(KEY_FITSRV,sService);
|
|
|
|
TDbFittingCreatorService* pFitCreatorService = NULL;
|
|
pFitCreatorService = (TDbFittingCreatorService*)acrxServiceDictionary->at(sService);
|
|
if (pFitCreatorService != NULL)
|
|
{
|
|
TDbImpPipeBase* pNewPipe = NULL;
|
|
pNewPipe = pFitCreatorService->CreateSpecialPipe(&m_XDataMap,this);
|
|
if (pNewPipe != NULL)
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
m_pImpPipeBase->Destroy();
|
|
m_pImpPipeBase = pNewPipe;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void TDbPipeBase::UpdateNormal(const AcGePoint3d& ptOld,const AcGePoint3d& ptNew)
|
|
{
|
|
assertWriteEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->UpdateNormal(ptOld,ptNew);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es;
|
|
|
|
// Call dwgOutFields from TDbInterfacesObj
|
|
if ((es = TDbInterfacesObj::dwgOutFields(pFiler)) != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
|
|
// change by hh 2013-9-2 TXDataMap改在底层中进行读写
|
|
// pFiler->writeItem((Adesk::UInt16) VERSION_TDbPipeBase);
|
|
// m_XDataMap.dwgOutFields(pFiler);
|
|
|
|
// 另存为9版以下的图纸时 TXDataMap仍需自行写入
|
|
if (g_nSaveTArchVer <= 9)
|
|
{
|
|
// 版本号置为1
|
|
pFiler->writeItem((Adesk::UInt16)1);
|
|
m_XDataMap.dwgOutFields(pFiler);
|
|
}
|
|
else
|
|
{
|
|
pFiler->writeItem((Adesk::UInt16) VERSION_TDbPipeBase);
|
|
}
|
|
|
|
// 边界存储
|
|
long lLen = m_arDbExtEdgs.GetCount();
|
|
pFiler->writeInt32(lLen);
|
|
for (int i = 0;i < lLen;i++)
|
|
{
|
|
m_arDbExtEdgs.GetAt(i).dwgOutFields(pFiler);
|
|
}
|
|
|
|
lLen = m_arIdCoverByMe.length();
|
|
pFiler->writeInt32(lLen);
|
|
|
|
for (i = 0;i < lLen;i++)
|
|
{
|
|
pFiler->writeSoftPointerId(AcDbSoftPointerId(m_arIdCoverByMe.at(i)));
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
struct resbuf rb;
|
|
|
|
if ((TDbInterfacesObj::dxfInFields(pFiler) != Acad::eOk) ||
|
|
!pFiler->atSubclassData(_T("TDbPipeBase")))
|
|
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_TDbPipeBase)
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::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("TDbPipeBase"));
|
|
|
|
// Write version number.
|
|
pFiler->writeItem(AcDb::kDxfInt16, (Adesk::UInt16) VERSION_TDbPipeBase);
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::extend(Adesk::Boolean extendStart,
|
|
const AcGePoint3d& toPoint)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->extend(extendStart,toPoint);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::extend(double newParam)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->extend(newParam);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getArea(double& x0) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getArea(x0);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getClassID(pClsid);
|
|
}
|
|
return eSta;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getClosestPointTo(const AcGePoint3d& givenPnt,
|
|
AcGePoint3d& pointOnCurve,
|
|
Adesk::Boolean extend) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getClosestPointTo(givenPnt,pointOnCurve,extend);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getClosestPointTo(const AcGePoint3d& givenPnt,
|
|
const AcGeVector3d& direction,
|
|
AcGePoint3d& pointOnCurve,
|
|
Adesk::Boolean extend) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getDistAtPoint(const AcGePoint3d& x0,
|
|
double& x1)const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getDistAtPoint(x0,x1);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getDistAtParam( double param, double& dist ) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getDistAtParam(param, dist);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getEndParam(double& x0) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getEndParam(x0);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getEndPoint(AcGePoint3d& x0) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getEndPoint(x0);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getFirstDeriv(const AcGePoint3d& x0,
|
|
AcGeVector3d& firstDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getFirstDeriv(x0,firstDeriv);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getFirstDeriv(double param,
|
|
AcGeVector3d& firstDeriv) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getFirstDeriv(param,firstDeriv);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetGeomExtents(AcDbExtents& extents) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getGeomExtents(extents);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
// mcl add.2010.11.09 忽略z标高差
|
|
AcGeVector3d vtOffset = offset;
|
|
if(TAuxTools::Is2DView())
|
|
vtOffset = offset.orthoProject(TAuxTools::GetUcsZvt());
|
|
|
|
eSta = m_pImpPipeBase->moveStretchPointsAt(indices, vtOffset);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getStretchPoints(stretchPoints);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
#if ADS>15
|
|
Acad::ErrorStatus TDbPipeBase::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double viewSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbIntArray osnapModes;
|
|
AcDbIntArray geomIds;
|
|
AcGePoint3dArray gripPoints;
|
|
Acad::ErrorStatus eSta = m_pImpPipeBase->getGripPoints(gripPoints,osnapModes,geomIds);
|
|
|
|
AcDbGripData* pGripData = NULL;
|
|
TDb::Position ePos;
|
|
|
|
CString sCmd = _T("");
|
|
GetGlobalContext(KEY_CABGRIPCMD,sCmd);
|
|
|
|
for (int i = 0;i < GRIP_MAXNUM && i < gripPoints.length();i++)
|
|
{
|
|
ePos = m_pImpPipeBase->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 TDbPipeBase::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_pImpPipeBase != NULL)
|
|
{
|
|
// mcl add.2010.11.08 忽略z标高差
|
|
AcGeVector3d vtOffset = offset;
|
|
if(TAuxTools::Is2DView())
|
|
vtOffset = offset.orthoProject(TAuxTools::GetUcsZvt());
|
|
|
|
//只能在本平面移动夹点
|
|
if (normal().isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtOffset = offset.orthoProject(normal());
|
|
}
|
|
else
|
|
{
|
|
AcGeLineSeg3d line(AcGePoint3d::kOrigin,AcGePoint3d::kOrigin + normal() * 100.0);
|
|
if (AcGePlane::kXYPlane.isParallelTo(line)) //立管
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
vtOffset = offset.orthoProject(normal());
|
|
}
|
|
}
|
|
eSta = m_pImpPipeBase->moveGripPointsAt(arIndex,vtOffset);
|
|
}
|
|
return eSta;
|
|
}
|
|
#endif
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
#if ADS==15
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getGripPoints(gripPoints,osnapModes,geomIds);
|
|
}
|
|
#endif
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
#if ADS==15
|
|
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
// mcl add.2010.11.08 忽略z标高差
|
|
AcGeVector3d vtOffset = offset;
|
|
if(TAuxTools::Is2DView())
|
|
vtOffset = offset.orthoProject(TAuxTools::GetUcsZvt());
|
|
|
|
//只能在本平面移动夹点
|
|
if (normal().isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtOffset = offset.orthoProject(normal());
|
|
}
|
|
else
|
|
{
|
|
AcGeLineSeg3d line(AcGePoint3d::kOrigin,AcGePoint3d::kOrigin + normal() * 100.0);
|
|
if (AcGePlane::kXYPlane.isParallelTo(line)) //立管
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
vtOffset = offset.orthoProject(normal());
|
|
}
|
|
}
|
|
|
|
eSta = m_pImpPipeBase->moveGripPointsAt(indices,vtOffset);
|
|
}
|
|
#endif
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getOffsetCurves(double offsetDist,
|
|
AcDbVoidPtrArray& offsetCurves) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbVoidPtrArray curvePtrs;
|
|
eSta = m_pImpPipeBase->getOffsetCurves(offsetDist,curvePtrs);
|
|
|
|
TDbPipeBase* pPipeBase = NULL;
|
|
AcDbLine* pLine = NULL;
|
|
for (int i = 0;i < curvePtrs.length();i++)
|
|
{
|
|
pLine = (AcDbLine*)curvePtrs.at(i);
|
|
if (pLine != NULL)
|
|
{
|
|
pPipeBase = (TDbPipeBase*)isA()->create();
|
|
if (pPipeBase != NULL)
|
|
{
|
|
pPipeBase->GetSpecialtyData()->CopyFrom(GetSpecialtyDataReadOnly());
|
|
pPipeBase->ReCreateByXDataMap();
|
|
pPipeBase->SetStartPoint(pLine->startPoint());
|
|
pPipeBase->SetEndPoint(pLine->endPoint());
|
|
pPipeBase->GetSpecialtyData()->SetAt(KEY_THISID,NULL);
|
|
offsetCurves.append(pPipeBase);
|
|
}
|
|
delete pLine;
|
|
}
|
|
}
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getOffsetCurvesGivenPlaneNormal(const AcGeVector3d& vtNorm,double offsetDist,
|
|
AcDbVoidPtrArray& offsetCurves) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbVoidPtrArray curvePtrs;
|
|
eSta = m_pImpPipeBase->getOffsetCurvesGivenPlaneNormal(vtNorm,offsetDist,curvePtrs);
|
|
|
|
TDbPipeBase* pPipeBase = NULL;
|
|
AcDbLine* pLine = NULL;
|
|
for (int i = 0;i < curvePtrs.length();i++)
|
|
{
|
|
pLine = (AcDbLine*)curvePtrs.at(i);
|
|
if (pLine != NULL)
|
|
{
|
|
pPipeBase = (TDbPipeBase*)isA()->create();
|
|
if (pPipeBase != NULL)
|
|
{
|
|
pPipeBase->GetSpecialtyData()->CopyFrom(GetSpecialtyDataReadOnly());
|
|
pPipeBase->ReCreateByXDataMap();
|
|
pPipeBase->SetStartPoint(pLine->startPoint());
|
|
pPipeBase->SetEndPoint(pLine->endPoint());
|
|
pPipeBase->GetSpecialtyData()->SetAt(KEY_THISID,NULL);
|
|
offsetCurves.append(pPipeBase);
|
|
}
|
|
delete pLine;
|
|
}
|
|
}
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getOsnapPoints( osnapMode,gsSelectionMark,
|
|
pickPoint,lastPoint,
|
|
viewXform,snapPoints,geomIds);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getParamAtDist(double dist,
|
|
double& param) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getParamAtDist(dist,param);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getParamAtPoint(const AcGePoint3d& x0,
|
|
double& x1)const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getParamAtPoint(x0,x1);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getPointAtDist(double x0,
|
|
AcGePoint3d& x1) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getPointAtDist(x0,x1);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getPointAtParam(double x0,
|
|
AcGePoint3d& x1) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getPointAtParam(x0,x1);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getSplitCurves(const AcGeDoubleArray& params,
|
|
AcDbVoidPtrArray& curveSegments) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbVoidPtrArray curvePtrs;
|
|
eSta = m_pImpPipeBase->getSplitCurves(params,curvePtrs);
|
|
|
|
TDbPipeBase* pPipeBase = NULL;
|
|
AcDbLine* pLine = NULL;
|
|
for (int i = 0;i < curvePtrs.length();i++)
|
|
{
|
|
pLine = (AcDbLine*)curvePtrs.at(i);
|
|
if (pLine != NULL)
|
|
{
|
|
pPipeBase = (TDbPipeBase*)isA()->create();
|
|
if (pPipeBase != NULL)
|
|
{
|
|
pPipeBase->GetSpecialtyData()->CopyFrom(GetSpecialtyDataReadOnly());
|
|
pPipeBase->ReCreateByXDataMap();
|
|
pPipeBase->SetStartPoint(pLine->startPoint());
|
|
pPipeBase->SetEndPoint(pLine->endPoint());
|
|
pPipeBase->GetSpecialtyData()->SetAt(KEY_THISID,NULL);
|
|
pPipeBase->setLayer(layerId());
|
|
pPipeBase->SetDashLayer(DashLayer());
|
|
pPipeBase->SetCenterLayer(CenterLayer());
|
|
curveSegments.append(pPipeBase);
|
|
}
|
|
delete pLine;
|
|
}
|
|
}
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getSplitCurves(const AcGePoint3dArray& points,
|
|
AcDbVoidPtrArray& curveSegments) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
AcDbVoidPtrArray curvePtrs;
|
|
eSta = m_pImpPipeBase->getSplitCurves(points,curvePtrs);
|
|
|
|
TDbPipeBase* pPipeBase = NULL;
|
|
AcDbLine* pLine = NULL;
|
|
for (int i = 0;i < curvePtrs.length();i++)
|
|
{
|
|
pLine = (AcDbLine*)curvePtrs.at(i);
|
|
if (pLine != NULL)
|
|
{
|
|
pPipeBase = (TDbPipeBase*)isA()->create();
|
|
if (pPipeBase != NULL)
|
|
{
|
|
pPipeBase->GetSpecialtyData()->CopyFrom(GetSpecialtyDataReadOnly());
|
|
pPipeBase->ReCreateByXDataMap();
|
|
pPipeBase->SetStartPoint(pLine->startPoint());
|
|
pPipeBase->SetEndPoint(pLine->endPoint());
|
|
pPipeBase->GetSpecialtyData()->SetAt(KEY_THISID,NULL);
|
|
pPipeBase->setLayer(layerId());
|
|
pPipeBase->SetDashLayer(DashLayer());
|
|
pPipeBase->SetCenterLayer(CenterLayer());
|
|
curveSegments.append(pPipeBase);
|
|
}
|
|
delete pLine;
|
|
}
|
|
}
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getStartParam(double& x0) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getStartParam(x0);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::getStartPoint(AcGePoint3d& x0) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->getStartPoint(x0);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subGetTransformedCopy(const AcGeMatrix3d& xform,
|
|
AcDbEntity*& pEnt) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
pEnt = new TDbPipeBase;
|
|
pEnt->copyFrom(this);
|
|
pEnt->transformBy(xform);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//bsl 2012.1.6 支持64位将int改为INT_PTR
|
|
Acad::ErrorStatus TDbPipeBase::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
return eSta;
|
|
}
|
|
//bsl 2012.1.6 支持64位将int改为INT_PTR
|
|
Acad::ErrorStatus TDbPipeBase::subIntersectWith(const AcDbEntity* pEnt,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
eSta = m_pImpPipeBase->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus eSta = Acad::eOk;
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->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_pImpPipeBase->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_pImpPipeBase->transformBy(mat);
|
|
//change end
|
|
}
|
|
else
|
|
return m_pImpPipeBase->transformBy(xform);
|
|
}
|
|
else
|
|
return m_pImpPipeBase->transformBy(xform);
|
|
|
|
// eSta = m_pImpPipeBase->transformBy(xform);
|
|
}
|
|
return eSta;
|
|
}
|
|
|
|
static void FreeBuffer(AcDbVoidPtrArray& arCurves)
|
|
{
|
|
for (int i = 0;i < arCurves.length();i++)
|
|
{
|
|
AcDbEntity* pEnt = (AcDbEntity*)arCurves.at(i);
|
|
if (pEnt != NULL)
|
|
{
|
|
delete pEnt;
|
|
}
|
|
}
|
|
arCurves.setLogicalLength(0);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::ExplodeOrDraw2d(XExplodeDraw &mode) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
double dPScale = GetPrintScale();
|
|
if (dPScale < 1.e-3) dPScale = 1.0;
|
|
|
|
BOOL bWeight = FALSE;
|
|
m_XDataMap.GetAt(KEY_EDAGEWEIGHT,bWeight);
|
|
|
|
BOOL bCenWeight = FALSE;
|
|
m_XDataMap.GetAt(KEY_CENLWEIGHT,bCenWeight);
|
|
|
|
//如果单线中心线显示;
|
|
BOOL nSingleLine = FALSE;
|
|
m_XDataMap.GetAt(KEY_SINGLE,nSingleLine);
|
|
if (nSingleLine)
|
|
{
|
|
// 获取实体自身原来的pl边界对象[源];
|
|
TComplexCurve compInside;
|
|
GetCurvesInSide(compInside);
|
|
compInside.setSubElementGsMark(0);
|
|
|
|
TDb::TCurveElement* pElTmpl = NULL;
|
|
if (!acrxServiceDictionary->has(KEY_FITCAB))
|
|
{
|
|
if (compInside.length() > 0)
|
|
pElTmpl = &compInside.first();
|
|
}
|
|
|
|
TDbExtentsEdge edage;
|
|
|
|
// 画被虚图元段.该部分由外部计算传入;
|
|
for (int i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
edage = m_arDbExtEdgs.GetAt(i);
|
|
|
|
// 然后[源]实边界对象减去虚图元段;]
|
|
if (TCoverBooleanOper::BoolSubtract(compInside,edage))
|
|
{
|
|
// 画虚图元部分[被遮挡]
|
|
m_arDbExtEdgs.GetAt(i).ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),pElTmpl,bWeight,bCenWeight,dPScale);
|
|
}
|
|
}
|
|
|
|
TDbExtentsEdge edge;
|
|
edge.SetEdage(compInside);
|
|
edge.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),NULL,bWeight,bCenWeight,dPScale);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if (m_arDbExtEdgs.GetCount() == 0)
|
|
{
|
|
TDbExtentsEdge edge;
|
|
|
|
// 获取实体自身原来的边界对象[源];
|
|
TComplexCurve compCurve;
|
|
MakeCurves(compCurve);
|
|
edge.SetEdage(compCurve);
|
|
edge.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),NULL,bWeight,bCenWeight,dPScale);
|
|
|
|
// 画减去虚段后剩下的实图元段;
|
|
TComplexCurve compInside;
|
|
GetCurvesInSide(compInside);
|
|
|
|
edge.SetEdage(compInside);
|
|
edge.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),NULL,bWeight,bCenWeight,dPScale);
|
|
}
|
|
else
|
|
{
|
|
// 获取实体自身原来的pl边界对象[源];
|
|
TComplexCurve compCurve,compInside;
|
|
MakeCurves(compCurve);
|
|
GetCurvesInSide(compInside);
|
|
|
|
TDb::TCurveElement* pElTmpl = NULL;
|
|
if (!acrxServiceDictionary->has(KEY_FITCAB))
|
|
{
|
|
if (compInside.length() > 0)
|
|
pElTmpl = &compInside.first();
|
|
}
|
|
|
|
// mcl add, 10.01.13,支持遮挡扩展区域
|
|
double dExtentLen(0.0);
|
|
if (this->isKindOf(TDbHvacDuct::desc()))
|
|
{
|
|
GetGlobalContext()->GetAt(HVAC_HIDEEXTENT, dExtentLen);
|
|
// add by hh 2011-01-05 从图纸中读取遮挡参数 避免全局参数对不同的图纸间的影响
|
|
TAuxTools::GetTHvacDataFromDwg(HVAC_HIDEEXTENT, dExtentLen);
|
|
|
|
// add by hh 2011-10-11 支持遮挡宽度随比例变化,并兼容旧版图纸(宽度小于10时认为是新版数据)
|
|
if(10 > dExtentLen && !EQUAL_ZERO(dExtentLen))
|
|
dExtentLen *= DocGetPScale();
|
|
}else
|
|
GetGlobalContext()->GetAt(KEY_CABLE_HIDEEXTENT, dExtentLen);
|
|
|
|
// add by hh 2014.8.7 确定是否要处理水管风管遮挡
|
|
BOOL bBreakPipe = FALSE;
|
|
if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEDUCTBREAK, bBreakPipe))
|
|
GetGlobalContext()->GetAt(HVAC_PIPEDUCTBREAK, bBreakPipe);
|
|
|
|
TDbExtentsEdge edage, edageExtent;
|
|
// 画被虚图元段.该部分由外部计算传入;
|
|
for (int i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
edage = m_arDbExtEdgs.GetAt(i);
|
|
edageExtent = edage;
|
|
|
|
// change by hh 2014.8.7
|
|
// if (dExtentLen > 1e-3)
|
|
// edageExtent.ExtendStartAndEnd(dExtentLen);
|
|
if(dExtentLen > 1e-3)
|
|
{
|
|
// 不处理水管时 m_arDbExtEdgs不会出现水管实体
|
|
if(!bBreakPipe)
|
|
{
|
|
edageExtent.ExtendStartAndEnd(dExtentLen);
|
|
}
|
|
// 处理水管时，要先判断是否水管，水管的打断间距在edageExtent中已经计算好了，不需要再进行扩展
|
|
else
|
|
{
|
|
OPENOBJ_BEGIN(edage.m_idOwner, AcDb::kForRead, AcDbEntity, pPipe);
|
|
if(NULL != pPipe)
|
|
{
|
|
if(0 != _tcscmp(_T("TDbPipe"), pPipe->isA()->name()))
|
|
{
|
|
// 如果不是水管 按遮挡间距扩展
|
|
edageExtent.ExtendStartAndEnd(dExtentLen);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
// change end
|
|
|
|
// 然后[源]实边界对象减去虚图元段;]
|
|
if (TCoverBooleanOper::BoolSubtract(compCurve, edageExtent))
|
|
{
|
|
edage.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),pElTmpl,bWeight,bCenWeight,dPScale);
|
|
}
|
|
|
|
// 内部的中心线等分布线减去被遮挡的部分
|
|
TCoverBooleanOper::BoolSubtract(compInside, edageExtent);
|
|
}
|
|
|
|
/* TDbExtentsEdge edage;
|
|
|
|
// 画被虚图元段.该部分由外部计算传入;
|
|
for (int i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
edage = m_arDbExtEdgs.GetAt(i);
|
|
|
|
// 然后[源]实边界对象减去虚图元段;]
|
|
if (TCoverBooleanOper::BoolSubtract(compCurve,edage))
|
|
{
|
|
// 画虚图元部分[被遮挡]
|
|
m_arDbExtEdgs.GetAt(i).ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),&elTmpl,bWeight,bCenWeight,dPScale);
|
|
}
|
|
|
|
// 内部的中心线等分布线减去被遮挡的部分
|
|
TCoverBooleanOper::BoolSubtract(compInside,m_arDbExtEdgs.at(i));
|
|
}
|
|
*/
|
|
//确保去掉重复的画线 [补漏]
|
|
for (i = 0;i < m_arDbExtEdgs.GetCount();i++)
|
|
{
|
|
// 然后[源]实边界对象减去虚图元段;]
|
|
TCoverBooleanOper::BoolSubtract(compCurve,m_arDbExtEdgs.GetAt(i));
|
|
}
|
|
|
|
// 画减去虚段后剩下的实图元段;
|
|
TDbExtentsEdge edge;
|
|
edge.SetEdage(compCurve);
|
|
edge.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),NULL,bWeight,bCenWeight,dPScale);
|
|
|
|
// 画内部的中心线等分布线
|
|
edge.SetEdage(compInside);
|
|
edge.ExplodeOrDraw2d(mode,layerId(),DashLayer(),CenterLayer(),NULL,bWeight,bCenWeight,dPScale);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
Acad::ErrorStatus TDbPipeBase::ExplodeOrDraw3d(XExplodeDraw &mode) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->ExplodeOrDraw3d(mode);
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
void TDbPipeBase::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
TDbInterfacesObj::subList();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->list();
|
|
}
|
|
}
|
|
|
|
BOOL TDbPipeBase::GetActiveViewPortInfo(AcGeVector3d& viewDir)
|
|
{
|
|
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;
|
|
}
|
|
|
|
void TDbPipeBase::GetTips(CMapStringToString& mapLable2Tip) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->GetTips(mapLable2Tip);
|
|
}
|
|
}
|
|
|
|
TDb::Position TDbPipeBase::ExplainGripIndex(int nIndex) const
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->ExplainGripIndex(nIndex);
|
|
}
|
|
return TDb::eStart;
|
|
}
|
|
|
|
void TDbPipeBase::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbInterfacesObj::CopyPropertiesFrom(pSrc,gMatchFlag);
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->CopyPropertiesFrom(pSrc,gMatchFlag);
|
|
}
|
|
}
|
|
|
|
void TDbPipeBase::CopyPropertiesTo(AcDbObjectId& idTgr,unsigned gMatchFlag)
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->CopyPropertiesTo(idTgr,gMatchFlag);
|
|
}
|
|
}
|
|
|
|
void TDbPipeBase::CopyPropertiesTo(AcDbObjectIdArray& arIds,unsigned gMatchFlag)
|
|
{
|
|
assertReadEnabled();
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
m_pImpPipeBase->CopyPropertiesTo(arIds,gMatchFlag);
|
|
}
|
|
}
|
|
|
|
BOOL TDbPipeBase::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
|
|
{
|
|
if (isWriteEnabled())
|
|
assertWriteEnabled();
|
|
else
|
|
assertReadEnabled();
|
|
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->OPMInfo(pszName, pInfo);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TDbPipeBase::IsValid(TDbXDataMap* pXMap)
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->IsValid(pXMap);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT TDbPipeBase::UserCall(long i,LPVOID pData)
|
|
{
|
|
return 0l;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::subHighlight(const AcDbFullSubentPath& subId, const Adesk::Boolean highlightAll ) const
|
|
{
|
|
AcDbObjectId id = objectId();
|
|
return TDbInterfacesObj::subHighlight(subId,highlightAll);
|
|
}
|
|
|
|
int TDbPipeBase::GetXBaseShell(TXShell& xShell)
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->GetXBaseShell(xShell);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TDbPipeBase::GetBodyBox(AcDbExtents& ext)
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->GetBodyBox(ext);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
CString TDbPipeBase::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
if (m_pImpPipeBase == NULL)
|
|
return _T("");
|
|
|
|
HvacModelType eType(TDb::eModel);
|
|
TDbXDataMap* pMap = GetSpecialtyDataReadOnly();
|
|
if (NULL == pMap)
|
|
return _T("");
|
|
|
|
pMap->GetAt(HVAC_ModeType, (int&)eType);
|
|
if (TDb::eSystem == eType)
|
|
return _T("");
|
|
|
|
CString csXml = m_pImpPipeBase->GetXml(mat);
|
|
CString csBase = TEntityBase::GetXml(mat);
|
|
int nIndex = csXml.Find(_T("</TCH_"));
|
|
if (nIndex > -1)
|
|
csXml.Insert(nIndex, csBase);
|
|
|
|
return csXml;
|
|
}
|
|
|
|
bool TDbPipeBase::GetSection( const AcDbFace &face, const AcGeVector3d &vtPlaneSecDir,
|
|
std::vector<TObjSectionRecord> §ionRecord, AcDbVoidPtrArray& arFillPtrs ) const
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
{
|
|
return m_pImpPipeBase->GetSection(face, vtPlaneSecDir, sectionRecord, arFillPtrs);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeBase::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
|
|
{
|
|
if (m_pImpPipeBase != NULL)
|
|
return m_pImpPipeBase->GetExtents(ptLow, ptUp);
|
|
|
|
return Acad::eNotImplementedYet;
|
|
} |