1820 lines
48 KiB
C++
1820 lines
48 KiB
C++
// TDbPipeMultDim.cpp: implementation of the TDbPipeMultDim class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "TDbPipeMultDim.h"
|
|
#include "dbtext.h"
|
|
#include "DbPipe.h"
|
|
#include "pipetools.h"
|
|
|
|
extern void FullExplode(const AcDbEntity *pEnt, AcDbVoidPtrArray &entitySet);
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
BOOL StringAnalysis(const TCHAR *src, XString &sPrefix, int *num, int *numWidth)
|
|
{
|
|
ASSERT(src && num && numWidth);
|
|
int nLen=(int)_tcslen(src);
|
|
if(!nLen)
|
|
return FALSE;
|
|
int iNumPos=nLen;
|
|
for(int iPos=nLen-1; iPos>=0; iPos--) {
|
|
if(!_istdigit(src[iPos]))
|
|
break;
|
|
else iNumPos=iPos;
|
|
}
|
|
if(iNumPos==nLen) {
|
|
*numWidth=0; //No digit
|
|
} else {
|
|
if(iNumPos>0) {
|
|
XString sTemp;
|
|
sTemp=src;
|
|
StrCpy(sTemp, src, src+iNumPos);
|
|
sPrefix=sTemp;
|
|
} else {
|
|
sPrefix=_T("");
|
|
}
|
|
if(iNumPos==nLen-1) {
|
|
*numWidth=-1;
|
|
} else {
|
|
if(src[iNumPos]==_T('0')) {
|
|
*numWidth=nLen-(int)_tcslen(sPrefix);
|
|
} else {
|
|
*numWidth=-1;
|
|
}
|
|
}
|
|
*num=_ttoi(src+iNumPos);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// 多线标注
|
|
// g_nVersion = 1 THvac6, g_nVersion = 2 THvac7, THvac8(B1), g_nVersion = 3 THvac8
|
|
// const Adesk::UInt8 TDbPipeMultDim::g_nVersion = 2; // ywb 2009-6-4
|
|
const Adesk::UInt8 TDbPipeMultDim::g_nVersion = 2;
|
|
|
|
#define MPIPE_DIM_TYPE _T("MPipeDimType") // 标注类型 0：默认 1：左侧
|
|
#define MPIPE_DIM_BULGE _T("MPipeDimBulge") // 多管标注 弧度
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSPipeMultDim, ATSSymbWithText, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_PIPEMULTDIM, "ATS_PIPEMULTDIM图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbPipeMultDim);
|
|
|
|
|
|
TDbPipeMultDim::TDbPipeMultDim()
|
|
{
|
|
m_nTextHeight=3.5;
|
|
m_iDimType = 0;
|
|
//m_iDimStyle = 2;
|
|
}
|
|
|
|
|
|
TDbPipeMultDim::~TDbPipeMultDim()
|
|
{
|
|
}
|
|
|
|
BOOL TDbPipeMultDim::IsValid() const
|
|
{
|
|
BOOL bRet=TDbSymbWithText::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
// bRet=(!!m_sText);
|
|
return bRet;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbPipeMultDim::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbPipeMultDim::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbSymbWithText::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbPipeMultDim *pSrc=TDbPipeMultDim::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nTextBaseLen=pSrc->m_nTextBaseLen; //左右由正负控制
|
|
}
|
|
}
|
|
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbPipeMultDim::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbSymbWithText::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;
|
|
}
|
|
////////////////////////////////
|
|
// 读入附件的ID
|
|
m_lstPipe.Reset();
|
|
Adesk::UInt8 nCount=0;
|
|
pFiler->readItem(&nCount);
|
|
for(Adesk::UInt8 i=0; i<nCount; i++) {
|
|
AcDbSoftPointerId id; // Debug Test Only
|
|
pFiler->readItem(&id);
|
|
m_lstPipe.Append(new AcDbSoftPointerId(id));
|
|
}
|
|
|
|
pFiler->readItem(&m_nTextBaseLen);
|
|
pFiler->readItem((AcGePoint2d *)&m_ptStart);
|
|
pFiler->readItem((AcGePoint2d *)&m_ptTurn);
|
|
if(nVer > 1){
|
|
pFiler->readItem(&m_iDimType);
|
|
ReadString(pFiler,m_sSpare);
|
|
}
|
|
// if (nVer > 2)
|
|
// pFiler->readItem(&m_iDimStyle);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeMultDim::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbSymbWithText::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
if(g_nSaveTArchVer==6)
|
|
pFiler->writeItem((Adesk::UInt8)1);
|
|
else if (g_nSaveTArchVer == 7)
|
|
pFiler->writeItem((Adesk::UInt8)2);
|
|
else
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
// 写出附件的ID
|
|
Adesk::UInt8 nCount=(Adesk::UInt8)m_lstPipe.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(Adesk::UInt8 i=0; i<nCount; i++) {
|
|
pFiler->writeItem(m_lstPipe[i]);
|
|
}
|
|
|
|
pFiler->writeItem(m_nTextBaseLen);
|
|
pFiler->writeItem((const AcGePoint2d &)m_ptStart);
|
|
pFiler->writeItem((const AcGePoint2d &)m_ptTurn);
|
|
if(g_nSaveTArchVer>6){
|
|
// cet 2016.7.19 modify 9.0之前编号样式打开崩溃，改为管径样式
|
|
// pFiler->writeItem(m_iDimType);
|
|
Adesk::UInt16 nDimType = m_iDimType;
|
|
if (g_nSaveTArchVer < 9 && m_iDimType == 1)
|
|
{
|
|
nDimType = 0;
|
|
}
|
|
pFiler->writeItem(nDimType);
|
|
pFiler->writeItem((const TCHAR *)m_sSpare);
|
|
}
|
|
|
|
// if (g_nSaveTArchVer > 7)
|
|
// pFiler->writeItem(m_iDimStyle);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeMultDim::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
double n = m_nTextHeight;
|
|
Acad::ErrorStatus es = TDbSymbWithText::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return pFiler->filerStatus();
|
|
if (!pFiler->atSubclassData(_T("TDbPipeMultDim"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
XPoint pt1, pt2;
|
|
double nBaseLen;
|
|
XString sText;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk))
|
|
{
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfXCoord:
|
|
pt1=rb.resval.rpoint;
|
|
break;
|
|
case AcDb::kDxfXCoord+1:
|
|
pt2=rb.resval.rpoint;
|
|
break;
|
|
case AcDb::kDxfText:
|
|
sText=rb.resval.rstring;
|
|
free(rb.resval.rstring);
|
|
break;
|
|
case AcDb::kDxfReal+1:
|
|
nBaseLen=rb.resval.rreal;
|
|
break;
|
|
default:
|
|
// An unrecognized group. Push it back so that
|
|
// the subclass can read it again.
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
if (es != Acad::eEndOfFile)
|
|
return Acad::eInvalidResBuf;
|
|
|
|
m_ptStart=pt1;
|
|
m_ptTurn=pt2;
|
|
if(fabs(m_nTextHeight - n) > 0.01)//如果是修改了字高，还需要调整文字下面的线长
|
|
m_nTextBaseLen = GetDefaultTextBaseLen()*1.5;
|
|
else
|
|
m_nTextBaseLen=nBaseLen;
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbPipeMultDim::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es=TDbSymbWithText::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPipeMultDim"));
|
|
assert(es == Acad::eOk);
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord, m_ptStart.AsAcGePoint2d());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord+1, m_ptTurn.AsAcGePoint2d());
|
|
pFiler->writeDouble(AcDb::kDxfReal+1, m_nTextBaseLen);
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Active when being rotated, scaled, moved, etc.
|
|
// Scale is disabled here
|
|
Acad::ErrorStatus
|
|
TDbPipeMultDim::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::subTransformBy(xform);
|
|
ads_matrix mat;
|
|
AsAdsMatrix(xform, mat);
|
|
|
|
m_ptStart.TransformBy(mat);
|
|
m_ptTurn.TransformBy(mat);
|
|
if(xform.isUniScaledOrtho())
|
|
m_nTextBaseLen *= xform(0,0);
|
|
if(IsMirrorMatrix(xform)) { //设备镜像 sr add 2005/6/7
|
|
XPoint ptOrg, ptX(1000, 0), ptY(0, 1000);
|
|
ptOrg.TransformBy(xform);
|
|
ptX.TransformBy(xform);
|
|
ptY.TransformBy(xform);
|
|
double nA1 = CT_std_angle(ads_angle(ptOrg, ptY));
|
|
double nA2 = CT_std_angle(ads_angle(ptOrg, ptX));
|
|
if(fabs(nA2 - PI) < _angSnap)//以Y轴镜像需要把标注翻转，而以X轴镜像则不需要
|
|
m_nTextBaseLen = m_nTextBaseLen*(-1);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// Overriden functions for edit
|
|
Acad::ErrorStatus TDbPipeMultDim::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
return subGetStretchPoints(gripPoints);
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus
|
|
TDbPipeMultDim::subGetStretchPoints(AcGePoint3dArray & gripPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_ptStart);
|
|
gripPoints.append(m_ptTurn);
|
|
XPoint ptTemp;
|
|
//modify yxx 2015-6-10 单管管径标注翻转
|
|
// ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
|
|
int iLabelType = GetLabelType();
|
|
if ( iLabelType == 1)
|
|
ads_polar(m_ptTurn, m_nLayoutRotation-PI, GetTextBaseLen(FALSE), ptTemp);
|
|
else
|
|
ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
|
|
//end yxx
|
|
gripPoints.append(ptTemp);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbPipeMultDim::subMoveGripPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset(offset[0], offset[1]);
|
|
for (int i = 0; i < indices.length(); i++) {
|
|
int idx = indices[i];
|
|
if(idx==0) { // Move vertex
|
|
m_ptStart += vtOffset;
|
|
} else if(idx==1) {
|
|
m_ptTurn += vtOffset;
|
|
} else if(idx==2) {
|
|
XPoint ptTemp;
|
|
//modify yxx 2015-6-10 单管管径标注翻转
|
|
// ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
|
|
int iLabelType = GetLabelType();
|
|
if ( iLabelType == 1)
|
|
ads_polar(m_ptTurn, m_nLayoutRotation - PI, GetTextBaseLen(FALSE), ptTemp);
|
|
else
|
|
ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
|
|
//end
|
|
XVector3D vt = ptTemp - m_ptTurn;
|
|
vt.Normalize();
|
|
//XVector3D vt(1.0, 0.0);
|
|
double nVal = (vtOffset&vt);
|
|
if(m_nTextBaseLen > 0)
|
|
m_nTextBaseLen += nVal/GetPScale();
|
|
else
|
|
m_nTextBaseLen -= nVal/GetPScale();
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbPipeMultDim::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
return subMoveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbPipeMultDim::GetGripText(int idx, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(idx==0)
|
|
cs=_T("移动标注点");
|
|
else if(idx==1)
|
|
cs=_T("移动转折点");
|
|
else
|
|
cs=_T("拉伸文字线");
|
|
|
|
return es;
|
|
}
|
|
|
|
void TDbPipeMultDim::Update()
|
|
{
|
|
assertWriteEnabled();
|
|
m_lstPipe.Reset();
|
|
struct resbuf *pointlist;
|
|
PickSet ss(SS_FREE);
|
|
XPoint ptUcsS, ptUcsE;
|
|
ptUcsS = Wcs2Ucs(m_ptStart);
|
|
ptUcsE = Wcs2Ucs(m_ptTurn);
|
|
|
|
pointlist = ads_buildlist(RTPOINT, &ptUcsS, RTPOINT, &ptUcsE, NULL);
|
|
ss.Get(_T("F"), pointlist, NULL, RBList(RTDXF0, _T("ATS_PIPE"), 0));
|
|
ads_relrb(pointlist);
|
|
if(ss.Length() < 1)
|
|
return;
|
|
for (long i=0;i<ss.Length(); i++){
|
|
Entity ent = ss[i];
|
|
AcDbObjectId id = NULL;
|
|
acdbGetObjectId(id, ent);
|
|
AddPipe(id);
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbPipeMultDim::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
|
|
AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
|
|
if (player.openStatus() == Acad::eOk && player->isOff())
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
double nShortLineLen = m_nTextHeight*GetPScale();
|
|
assertReadEnabled();
|
|
if(!IsValid())
|
|
return Acad::eInvalidInput;
|
|
XStringList lstTexts;
|
|
GetTexts(lstTexts);
|
|
|
|
dc << XLine(m_ptStart, m_ptTurn);
|
|
// double nLineSpace = (DocGetText2Base()*2+m_nTextHeight)*GetPScale();
|
|
double nLineSpace = (GetDimDist2Line()+m_nTextHeight)*GetPScale();
|
|
|
|
ads_matrix matRot;
|
|
m_ptStart.GetRotationMatrix(-m_nLayoutRotation, matRot);
|
|
XPoint ptTurn=m_ptTurn.TransformAs(matRot);
|
|
XPoint ptStart=m_ptStart.TransformAs(matRot);
|
|
if(ptTurn.y > ptStart.y + 1.0E-3)
|
|
lstTexts.Reverse();
|
|
else
|
|
nLineSpace = - nLineSpace;
|
|
|
|
double nTextBaseLen=GetTextBaseLen(FALSE);
|
|
// double nSpacer=DocGetText2Base()*GetPScale()/2;
|
|
double nSpacer=GetDimDist2Line()*GetPScale()/4;
|
|
|
|
XLine lineBase(m_ptStart, m_ptTurn, 1);
|
|
lineBase.StartPoint().z = 0;
|
|
lineBase.EndPoint().z = 0;
|
|
XPoint ptInt;
|
|
|
|
int iDimStyle = GetDimStyle();
|
|
if(m_lstPipe.Length() > 1)
|
|
{
|
|
double dBulge = GetBulge();
|
|
//绘制斜叉
|
|
for(int i=0;i<m_lstPipe.Length();i++)
|
|
{
|
|
switch (iDimStyle)
|
|
{
|
|
case 1: // 点样式
|
|
{
|
|
AcDbObjectId id = m_lstPipe[i];//const
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
|
|
if(pPipe && !pPipe->IsVertical())
|
|
{
|
|
//add by yxx 2015-6-12 多管标注
|
|
if ( fabs(dBulge) > g_fZero )
|
|
{
|
|
XArc arc(pPipe->GetStartPoint(), pPipe->GetEndPoint(), dBulge);
|
|
int ret = arc.Intersection(&lineBase, ptInt);
|
|
if(!!ptInt && ret == 1)
|
|
{
|
|
AcGeVector3d vt = lineBase.Direction3d();
|
|
vt.normalize();
|
|
AcGePoint3d ptS = AcGePoint3d::kOrigin;
|
|
ptS = ptInt + vt * GetPScale() / 100 * 20;
|
|
AcGePoint3d ptE = AcGePoint3d::kOrigin;
|
|
ptE = ptInt - vt * GetPScale() / 100 * 20;
|
|
AcDbPolyline PLine;
|
|
PLine.addVertexAt(0, AcGePoint2d(ptS.x, ptS.y), -1);
|
|
PLine.addVertexAt(1, AcGePoint2d(ptE.x, ptE.y), -1);
|
|
PLine.setConstantWidth(GetPScale() * 40 / 100);
|
|
PLine.setClosed(Adesk::kTrue);
|
|
dc.DrawEntity(PLine);
|
|
}
|
|
|
|
}//end yxx
|
|
else
|
|
{
|
|
XLine line(pPipe->GetStartPoint(), pPipe->GetEndPoint(), 1);
|
|
line.StartPoint().z = 0;
|
|
line.EndPoint().z = 0;
|
|
int ret = line.Intersection(&lineBase, ptInt);
|
|
if(!!ptInt)
|
|
{
|
|
AcGeVector3d vt = line.Direction3d();
|
|
vt.normalize();
|
|
AcGePoint3d ptS = AcGePoint3d::kOrigin;
|
|
ptS = ptInt + vt * GetPScale() / 100 * 20;
|
|
AcGePoint3d ptE = AcGePoint3d::kOrigin;
|
|
ptE = ptInt - vt * GetPScale() / 100 * 20;
|
|
AcDbPolyline PLine;
|
|
PLine.addVertexAt(0, AcGePoint2d(ptS.x, ptS.y), -1);
|
|
PLine.addVertexAt(1, AcGePoint2d(ptE.x, ptE.y), -1);
|
|
PLine.setConstantWidth(GetPScale() * 40 / 100);
|
|
PLine.setClosed(Adesk::kTrue);
|
|
dc.DrawEntity(PLine);
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
break;
|
|
case 2: // 斜线样式
|
|
{
|
|
CString csText;
|
|
AcDbObjectId id = m_lstPipe[i];//const
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
|
|
if(pPipe && !pPipe->IsVertical())
|
|
{
|
|
//add by yxx 2015-6-12 多管标注
|
|
if ( fabs(dBulge) > g_fZero )
|
|
{
|
|
XArc arc(pPipe->GetStartPoint(), pPipe->GetEndPoint(), dBulge);
|
|
int ret = arc.Intersection(&lineBase, ptInt);
|
|
if(!!ptInt && ret == 1)
|
|
{
|
|
double nAngPipe = lineBase.Direction();
|
|
double angTmp(0.0);
|
|
angTmp = nAngPipe + PI/4;
|
|
XPoint pt1, pt2;
|
|
ads_polar(ptInt, angTmp, nShortLineLen/2, pt1);
|
|
ads_polar(pt1, angTmp + PI, nShortLineLen, pt2);
|
|
dc << XLine(pt1, pt2);
|
|
}
|
|
}//end yxx
|
|
else
|
|
{
|
|
XLine line(pPipe->GetStartPoint(), pPipe->GetEndPoint(), 1);
|
|
line.StartPoint().z = 0;
|
|
line.EndPoint().z = 0;
|
|
int ret = line.Intersection(&lineBase, ptInt);
|
|
|
|
if(!!ptInt && ret == 1)
|
|
{
|
|
double nAngPipe = line.Direction();
|
|
double nAngBase = lineBase.Direction();
|
|
double ang = nAngPipe - nAngBase;
|
|
if(ang < 0)
|
|
ang += PI*2;
|
|
if(ang > PI)
|
|
ang -= PI;
|
|
double angTmp(0.0);
|
|
if(ang < (PI - 0.001) && ang < (PI/2 - 0.001))
|
|
angTmp = nAngPipe + PI/4;
|
|
else
|
|
angTmp = nAngPipe + PI/4 + PI/2;
|
|
XPoint pt1, pt2;
|
|
ads_polar(ptInt, angTmp, nShortLineLen/2, pt1);
|
|
ads_polar(pt1, angTmp + PI, nShortLineLen, pt2);
|
|
dc << XLine(pt1, pt2);
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
CString strText; // cet 2011.4.25 add 保存标高标注信息
|
|
double nDist2Turn=0.0;
|
|
for(int i=0; i<lstTexts.Length(); i++) {
|
|
// cet 2011.4.25 add 标高标注
|
|
if (m_iDimType == 3)
|
|
{
|
|
if (!strText.IsEmpty())
|
|
{
|
|
strText = _T("\n") + strText;
|
|
}
|
|
else// zxl 2013.04.23 add 标高标注对齐
|
|
{
|
|
strText = _T(" ");
|
|
}
|
|
strText = lstTexts[i] + strText;
|
|
continue;
|
|
}
|
|
|
|
double nAngleTurn = ads_angle(m_ptStart, m_ptTurn);
|
|
double nPlus(0); //sr modify 2005-6-10
|
|
if(fabs(m_nLayoutRotation) < 0.001){
|
|
if(nAngleTurn > 0 && nAngleTurn < PI)
|
|
nPlus = PI/2;
|
|
else
|
|
nPlus = -PI/2;
|
|
}
|
|
else if(fabs(m_nLayoutRotation - PI/2) < 0.001){
|
|
if(nAngleTurn > (PI/2 - 0.001) && nAngleTurn < PI/2*3)
|
|
nPlus = PI/2;
|
|
else
|
|
nPlus = -PI/2;
|
|
}
|
|
else if(m_nLayoutRotation < PI/2){
|
|
if(nAngleTurn > (PI/2 - 0.001) && nAngleTurn < PI/2*3)
|
|
nPlus = PI/2;
|
|
else
|
|
nPlus = -PI/2;
|
|
}
|
|
else if(m_nLayoutRotation > PI){
|
|
if(nAngleTurn > 0 && nAngleTurn < PI)
|
|
nPlus = PI/2;
|
|
else
|
|
nPlus = -PI/2;
|
|
}
|
|
|
|
XPoint ptTextBeg, ptTextEnd;
|
|
ptTextBeg = m_ptTurn;
|
|
ads_polar(XPoint(ptTextBeg), m_nLayoutRotation+nPlus, nDist2Turn, ptTextBeg);
|
|
ptTextEnd=ptTextBeg;
|
|
//modify yxx 2015-6-10 单管管径标注翻转
|
|
//ads_polar(XPoint(ptTextEnd), m_nLayoutRotation, nTextBaseLen, ptTextEnd);
|
|
int iLabelType = GetLabelType();
|
|
if ( iLabelType == 1)
|
|
ads_polar(XPoint(ptTextEnd), m_nLayoutRotation - PI, nTextBaseLen, ptTextEnd);
|
|
else
|
|
ads_polar(XPoint(ptTextEnd), m_nLayoutRotation, nTextBaseLen, ptTextEnd);
|
|
//end yxx
|
|
if(i==lstTexts.Length()-1) {
|
|
XPoint ptEnd;
|
|
ads_polar(m_ptTurn, m_nLayoutRotation+nPlus, nDist2Turn, ptEnd);
|
|
dc << XLine(m_ptTurn, ptEnd);
|
|
}
|
|
|
|
TDbMText text;
|
|
text.setPropertiesFrom(this);
|
|
CString sText;
|
|
if(nPlus > 0)
|
|
sText = lstTexts[i];
|
|
else
|
|
sText = lstTexts[lstTexts.Length()-i-1];
|
|
// cet 2014.5.23 del 由于一些特殊字符如"▽",无法正确显示，需特殊处理
|
|
// int nIndex = sText.Find(_T("▽"), 0);
|
|
// CString sBefore, sEnd;
|
|
// if (nIndex >= 0)
|
|
// {
|
|
// sBefore = sText.Left(nIndex);
|
|
// int nSize = 2;
|
|
// #if (ADS != 15)
|
|
// nSize = 1;
|
|
// #endif
|
|
// sEnd = sText.Right(sText.GetLength() - nIndex - nSize);
|
|
// sText = sBefore + _T(" ") + sEnd;
|
|
// }
|
|
|
|
text.SetText(sText);
|
|
text.SetStyleId(m_idTextStyle);
|
|
if(!!m_idTextLayer)
|
|
text.setColorIndex(GetTextColor());
|
|
// text.setLayer(m_idTextLayer);
|
|
text.SetHeight(m_nTextHeight);
|
|
XPoint ptText=ptTextEnd;
|
|
XPoint ptTempEnd=ptTextEnd.TransformAs(matRot);
|
|
XPoint ptTempBeg=ptTextBeg.TransformAs(matRot);
|
|
XExplodeDraw::TextAlignment align;
|
|
|
|
int nAlignType = GetDimAlignType();
|
|
if(ptTempEnd.x>ptTempBeg.x) {
|
|
// ads_polar(ptTextBeg, m_nLayoutRotation, 4*nSpacer, ptText); zxl 2013.01.21 modify
|
|
if (nAlignType == 0)// 左对齐时
|
|
{
|
|
ads_polar(ptTextBeg, m_nLayoutRotation, nSpacer, ptText);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTextBeg, m_nLayoutRotation, 0, ptText);
|
|
}
|
|
}
|
|
((TDbMText &)text).SetPageWidth(max(max(fabs(nTextBaseLen), fabs(nLineSpace)), GetDefaultTextBaseLen() * GetPScale()), FALSE);
|
|
((TDbMText &)text).SetLineSpace(nSpacer, FALSE);
|
|
ads_polar(XPoint(ptText), m_nLayoutRotation+PI/2, nSpacer, ptText);
|
|
// if(ptTempEnd.x>ptTempBeg.x)
|
|
// align = XExplodeDraw::kRight; //XExplodeDraw::kBottomRight;
|
|
// else
|
|
// align = XExplodeDraw::kLeft; //XExplodeDraw::kBottomLeft;
|
|
|
|
if (nAlignType == 0)
|
|
{
|
|
align = XExplodeDraw::kLeft;
|
|
}
|
|
else if (nAlignType == 1)
|
|
{
|
|
align = XExplodeDraw::kCenter;
|
|
}
|
|
else
|
|
{
|
|
align = XExplodeDraw::kRight;
|
|
}
|
|
// cet 2014.5.15 modify 当nPlus < 0时，计算间距错误
|
|
// XVector3D vtExt = text.GetExtents();
|
|
// nDist2Turn += vtExt.y + nSpacer*4.0;
|
|
XVector3D vtExt;
|
|
if (nPlus < 0)
|
|
{
|
|
if (lstTexts.Length() - i - 2 >= 0)
|
|
{
|
|
CString sText1 = lstTexts[lstTexts.Length() - i - 2];
|
|
text.SetText(sText1);
|
|
}
|
|
vtExt = text.GetExtents();
|
|
nDist2Turn += vtExt.y + nSpacer*4.0;
|
|
text.SetText(sText);
|
|
vtExt = text.GetExtents();
|
|
}
|
|
else
|
|
{
|
|
vtExt = text.GetExtents();
|
|
nDist2Turn += vtExt.y + nSpacer*4.0;
|
|
}
|
|
|
|
XPoint ptLoc = ptText;
|
|
ads_polar(XPoint(ptLoc), m_nLayoutRotation+PI/2, m_nTextHeight * GetPScale() + nSpacer, ptLoc);
|
|
ads_polar(XPoint(ptText), m_nLayoutRotation+PI/2, vtExt.y+nSpacer, ptText);
|
|
if(m_nTextBaseLen < 0){ //使左侧的文字离边界200
|
|
//ads_polar(ptText, m_nLayoutRotation, 200, ptText);
|
|
//text.SetAlignment(align);
|
|
}
|
|
// text.setLayer(m_idTextLayer);
|
|
text.setColorIndex(GetTextColor());
|
|
text.SetAlignment(align);
|
|
text.SetLocation(ptText);
|
|
// 绘制特殊字符
|
|
bool bFlag = false;
|
|
if (IsIncludeSpeicalChar(sText))
|
|
{
|
|
// cet 2017.9.11 modify 重新实现绘制包含特殊符号的字符串
|
|
// // 绘制特殊字符
|
|
// DrawSpecialCharForDnElevationType(dc, sText, ptTextBeg, ptTextEnd, ptLoc, text.GetLineSpace());
|
|
// // 替换特殊字符
|
|
// ReplaceSpecialChar(sText);
|
|
// text.SetText(sText);
|
|
bFlag = true;
|
|
DrawSpecialCharForDnElevationType(dc, sText, ptTextBeg, ptTextEnd, ptText, text.GetLineSpace());
|
|
}
|
|
if (!bFlag)
|
|
{
|
|
TPushProperty vProp(&text, dc);
|
|
if(dc.IsFullExplode())
|
|
text.ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(text);
|
|
}
|
|
|
|
dc << XLine(ptTextBeg, ptTextEnd);
|
|
}
|
|
|
|
// cet 2011.4.25 add
|
|
if (!strText.IsEmpty())
|
|
{
|
|
XPoint ptTemp;
|
|
ads_polar(XPoint(m_ptTurn), m_nLayoutRotation, nTextBaseLen, ptTemp);
|
|
dc << XLine(m_ptTurn, ptTemp);
|
|
AcGeVector3d vtOffset;
|
|
double dVtAngle = ads_angle(Wcs2Ucs(m_ptStart), Wcs2Ucs(m_ptTurn));
|
|
// zxl modify 2013.04.22
|
|
// if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
|
|
// {
|
|
// vtOffset = AcGeVector3d(0, 1, 0);
|
|
// }
|
|
// else
|
|
// {
|
|
// vtOffset = AcGeVector3d(0, -1, 0);
|
|
// }
|
|
if (nTextBaseLen > 0.0)
|
|
{
|
|
if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
|
|
{
|
|
vtOffset = AcGeVector3d(0, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
vtOffset = AcGeVector3d(0, -1, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
|
|
{
|
|
vtOffset = AcGeVector3d(-1, 1, 0);
|
|
}
|
|
else
|
|
{
|
|
vtOffset = AcGeVector3d(-1, -1, 0);
|
|
}
|
|
}
|
|
vtOffset = Ucs2Wcs(vtOffset, TRUE);
|
|
|
|
TDbSymbElevation text;
|
|
text.setPropertiesFrom(this); // cet 2011.12.19 add 标注文字大小随对象比例变化
|
|
ads_polar(XPoint(m_ptTurn), m_nLayoutRotation, nTextBaseLen * 0.5, ptTemp);
|
|
text.SetLocation(ptTemp);
|
|
text.SetText(strText);
|
|
text.SetBaseLine(FALSE);
|
|
text.setColorIndex(GetTextColor());
|
|
text.SetLeader(FALSE);
|
|
text.SetTextHeight(m_nTextHeight);
|
|
text.SetTextStyleId(m_idTextStyle);
|
|
text.SetLayoutRotation(Ucs2Wcs(0.0));
|
|
if (m_nTextBaseLen < 0.0)
|
|
{
|
|
text.SetAtLineSide(FALSE);
|
|
}
|
|
else
|
|
{
|
|
text.SetAtLineSide(TRUE);
|
|
}
|
|
|
|
AcDbIntArray indices;
|
|
indices.append(1);
|
|
if (vtOffset.length() > _DIST_SNAP*10)
|
|
{
|
|
vtOffset.normalize();
|
|
double dScale = (2*DocGetEleTriangleSize() + 0.5) * GetPScale();
|
|
vtOffset *= dScale;
|
|
text.moveGripPointsAt(indices, vtOffset);
|
|
}
|
|
|
|
double dAngle = ads_angle(Wcs2Ucs(m_ptTurn), Wcs2Ucs(ptTemp));
|
|
// zxl 2013.04.22 add
|
|
if (m_nTextBaseLen < 0.0)
|
|
{
|
|
dAngle += PI;
|
|
}
|
|
text.SetLayoutRotation(Ucs2Wcs(dAngle));
|
|
// 设置标高标注文字基线长度
|
|
text.SetTextBaseLen(GetDefaultTextBaseLen());
|
|
// 绘制特殊字符
|
|
if (IsIncludeSpeicalChar(strText))
|
|
{
|
|
// cet 2017.9.11 modify 重新实现绘制特殊符号的字符串
|
|
// // 绘制特殊字符
|
|
// DrawSpecialCharForElevationType(dc, strText, m_ptTurn, ptTemp, text.GetTextPoint(), text.GetText2BaseRatio(FALSE, TRUE));
|
|
// // 替换特殊字符
|
|
// ReplaceSpecialChar(strText);
|
|
// text.SetText(strText);
|
|
text.SetText(strText);
|
|
DrawSpecialCharForElevationType(dc, text);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if(dc.IsFullExplode())
|
|
{
|
|
text.ExplodeOrDraw2d(dc);
|
|
}
|
|
else
|
|
{
|
|
dc.DrawEntity(text);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
//读扩展数据
|
|
CString ReadXdata(Entity ent, const TCHAR*szName)
|
|
{
|
|
AcDbObjectId eId;
|
|
AcDbEntity *pEnt = NULL;
|
|
acdbGetObjectId(eId, ent);
|
|
acdbOpenObject(pEnt, eId, AcDb::kForRead);
|
|
if(!pEnt)
|
|
return _T("");
|
|
resbuf *pRb = pEnt->xData(szName);
|
|
|
|
CString csRet;
|
|
if (pRb != NULL) {
|
|
resbuf *pTemp = pRb;
|
|
if (pTemp->rbnext != NULL) {
|
|
pTemp = pTemp->rbnext;
|
|
if (pTemp->restype == 1000)
|
|
csRet = pTemp->resval.rstring;
|
|
}
|
|
}
|
|
ads_relrb(pRb);
|
|
pEnt->close();
|
|
return csRet;
|
|
}
|
|
|
|
//读扩展数据 cet 2014.6.4 add
|
|
CString ReadXdata(const AcDbEntity*pEnt, const TCHAR*szName)
|
|
{
|
|
if(!pEnt)
|
|
return _T("");
|
|
resbuf *pRb = pEnt->xData(szName);
|
|
|
|
CString csRet;
|
|
if (pRb != NULL) {
|
|
resbuf *pTemp = pRb;
|
|
if (pTemp->rbnext != NULL) {
|
|
pTemp = pTemp->rbnext;
|
|
if (pTemp->restype == 1000)
|
|
csRet = pTemp->resval.rstring;
|
|
}
|
|
}
|
|
ads_relrb(pRb);
|
|
return csRet;
|
|
}
|
|
|
|
// cet 2014.6.18 add 是否存在扩展数据
|
|
bool IncludeXdate(const AcDbEntity*pEnt, const TCHAR*szName)
|
|
{
|
|
if(!pEnt)
|
|
return false;
|
|
resbuf *pRb = pEnt->xData(szName);
|
|
CString csRet;
|
|
if (pRb == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
ads_relrb(pRb);
|
|
return true;
|
|
}
|
|
|
|
extern CString g_csPipeDim[35];
|
|
|
|
// 已知管线图层名称，返回管线类别INDEX cet 2016.6.7 del 不再直接使用图层宏
|
|
// int GetPipeLayerIdxByName(const TCHAR* szLayer)
|
|
// {
|
|
// CString csLayer;
|
|
// csLayer = (const TCHAR*)szLayer;
|
|
//
|
|
// int ret = 0;
|
|
// if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED)
|
|
// ret = 0;
|
|
// else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED)
|
|
// ret = 1;
|
|
// else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK)
|
|
// ret = 2;
|
|
// else if(csLayer == LAY_PIPE_DIRT || csLayer == LAY_VPIPE_DIRT)
|
|
// ret = 3;
|
|
// else if(csLayer == LAY_PIPE_USELESS || csLayer == LAY_VPIPE_USELESS)
|
|
// ret = 4;
|
|
// else if(csLayer == LAY_PIPE_RAIN || csLayer == LAY_VPIPE_RAIN)
|
|
// ret = 5;
|
|
// else if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED)
|
|
// ret = 6;
|
|
// else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE)
|
|
// ret = 7;
|
|
// else if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE)
|
|
// ret = 8;
|
|
// else if(csLayer == LAY_PIPE_COAGULATE || csLayer == LAY_VPIPE_COAGULATE)
|
|
// ret = 9;
|
|
// else if(csLayer == LAY_PIPE_DRINK || csLayer == LAY_VPIPE_DRINK)
|
|
// ret = 10;
|
|
// else if(csLayer == LAY_PIPE_PRESSDIRT || csLayer == LAY_VPIPE_PRESSDIRT)
|
|
// ret = 11;
|
|
// else if(csLayer == LAY_PIPE_PRESSUSELESS || csLayer == LAY_VPIPE_PRESSUSELESS)
|
|
// ret = 12;
|
|
// else if(csLayer == LAY_PIPE_PRESSRAIN || csLayer == LAY_VPIPE_PRESSRAIN)
|
|
// ret = 13;
|
|
// else if(csLayer == LAY_PIPE_OTHER || csLayer == LAY_VPIPE_OTHER)
|
|
// ret = 14;
|
|
// else if(csLayer == LAY_PIPE_USER1 || csLayer == LAY_VPIPE_USER1)
|
|
// ret = 15;
|
|
// else if(csLayer == LAY_PIPE_USER2 || csLayer == LAY_VPIPE_USER2)
|
|
// ret = 16;
|
|
// else if(csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2)
|
|
// ret = 17;
|
|
// else if(csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
|
|
// ret = 18;
|
|
// else if(csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2)
|
|
// ret = 19;
|
|
// else if(csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
|
|
// ret = 20;
|
|
// else if(csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2)
|
|
// ret = 21;
|
|
// else if(csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
|
|
// ret = 22;
|
|
// else if(csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2)
|
|
// ret = 23;
|
|
// else if(csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
|
|
// ret = 24;
|
|
// else if(csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2)
|
|
// ret = 25;
|
|
// else if(csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
|
|
// ret = 26;
|
|
// else if(csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2)
|
|
// ret = 27;
|
|
// else if(csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
|
|
// ret = 28;
|
|
// else if (csLayer == LAY_PIPE_USER3 || csLayer == LAY_VPIPE_USER3) // cet 2012.2.7 add user3-user8
|
|
// ret = 29;
|
|
// else if (csLayer == LAY_PIPE_USER4 || csLayer == LAY_VPIPE_USER4)
|
|
// ret = 30;
|
|
// else if (csLayer == LAY_PIPE_USER5 || csLayer == LAY_VPIPE_USER5)
|
|
// ret = 31;
|
|
// else if (csLayer == LAY_PIPE_USER6 || csLayer == LAY_VPIPE_USER6)
|
|
// ret = 32;
|
|
// else if (csLayer == LAY_PIPE_USER7 || csLayer == LAY_VPIPE_USER7)
|
|
// ret = 33;
|
|
// else if (csLayer == LAY_PIPE_USER8 || csLayer == LAY_VPIPE_USER8)
|
|
// ret = 34;
|
|
// else
|
|
// ret = -1;
|
|
// return ret;
|
|
// }
|
|
|
|
int GetPipeLayerIdxBySys(TPipeSys::SysType sys)
|
|
{
|
|
int ret = 0;
|
|
if(sys == TPipeSys::kFeedWater)
|
|
ret = 0;
|
|
else if(sys == TPipeSys::kHeatFeedWater)
|
|
ret = 1;
|
|
else if(sys == TPipeSys::kHeatBackWater)
|
|
ret = 2;
|
|
else if(sys == TPipeSys::kDirtWater)
|
|
ret = 3;
|
|
else if(sys == TPipeSys::kUselessWater)
|
|
ret = 4;
|
|
else if(sys == TPipeSys::kRainWater)
|
|
ret = 5;
|
|
else if(sys == TPipeSys::kUsedWater)
|
|
ret = 6;
|
|
else if(sys == TPipeSys::kFireFighting)
|
|
ret = 7;
|
|
else if(sys == TPipeSys::kSprinkle)
|
|
ret = 8;
|
|
else if(sys == TPipeSys::kCoagulate)
|
|
ret = 9;
|
|
else if(sys == TPipeSys::kDrink)
|
|
ret = 10;
|
|
else if(sys == TPipeSys::kPressDirt)
|
|
ret = 11;
|
|
else if(sys == TPipeSys::kPressUseless)
|
|
ret = 12;
|
|
else if(sys == TPipeSys::kPressRain)
|
|
ret = 13;
|
|
else if(sys == TPipeSys::kOther)
|
|
ret = 14;
|
|
else if(sys == TPipeSys::kCivilFeed)
|
|
ret = 15;
|
|
else if(sys == TPipeSys::kCycleFeed)
|
|
ret = 16;
|
|
else if(sys == TPipeSys::kFeedWater2)
|
|
ret = 17;
|
|
else if(sys == TPipeSys::kFeedWater3)
|
|
ret = 18;
|
|
else if(sys == TPipeSys::kHeatFeedWater2)
|
|
ret = 19;
|
|
else if(sys == TPipeSys::kHeatFeedWater3)
|
|
ret = 20;
|
|
else if(sys == TPipeSys::kHeatBackWater2)
|
|
ret = 21;
|
|
else if(sys == TPipeSys::kHeatBackWater3)
|
|
ret = 22;
|
|
else if(sys == TPipeSys::kFireFighting2)
|
|
ret = 23;
|
|
else if(sys == TPipeSys::kFireFighting3)
|
|
ret = 24;
|
|
else if(sys == TPipeSys::kSprinkle2)
|
|
ret = 25;
|
|
else if(sys == TPipeSys::kSprinkle3)
|
|
ret = 26;
|
|
else if(sys == TPipeSys::kUsedWater2)
|
|
ret = 27;
|
|
else if(sys == TPipeSys::kUsedWater3)
|
|
ret = 28;
|
|
else if (sys == TPipeSys::kUser3)
|
|
ret = 29;
|
|
else if (sys == TPipeSys::kUser4)
|
|
ret = 30;
|
|
else if (sys == TPipeSys::kUser5)
|
|
ret = 31;
|
|
else if (sys == TPipeSys::kUser6)
|
|
ret = 32;
|
|
else if (sys == TPipeSys::kUser7)
|
|
ret = 33;
|
|
else if (sys == TPipeSys::kUser8)
|
|
ret = 34;
|
|
else
|
|
ret = -1;
|
|
return ret;
|
|
}
|
|
|
|
extern CString I2Str(double i);
|
|
|
|
void TDbPipeMultDim::GetTexts(XStringList &lstTexts) const
|
|
{
|
|
int len = m_lstPipe.Length();
|
|
|
|
// 是否全为立管 cet 2012.10.12 add
|
|
bool bAllPipe = true;
|
|
for (int j = 0; j < len; j++)
|
|
{
|
|
OPENOBJ_BEGIN(m_lstPipe[j], AcDb::kForRead, TDbPipe, pPipe);
|
|
if (pPipe != NULL)
|
|
{
|
|
if (!pPipe->IsVertical())
|
|
{
|
|
bAllPipe = false;
|
|
break;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
for(int i=0;i<len;i++){
|
|
CString csText = _T("");
|
|
CString csSerial;
|
|
CString csFloorNum; // cet 2012.10.12 add 楼号
|
|
CString csMark; // cet 2014.6.12 add 代号
|
|
AcDbObjectId id = m_lstPipe[i];//const
|
|
ads_name ent;
|
|
acdbGetAdsName(ent, id);
|
|
if(m_iDimType == 1){
|
|
csSerial = ReadXdata(ent, _T("PIPE-SERIAL"));
|
|
csFloorNum = ReadXdata(ent, _T("BUILDING-SERIAL")); // cet 2012.10.12 add
|
|
}
|
|
// cet 2014.6.12 add 编号标注用到的代号
|
|
if (m_iDimType == 1)
|
|
{
|
|
csMark = ReadXdata(ent, _T("PIPE-MARK"));
|
|
}
|
|
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
|
|
if(pPipe){
|
|
// TPipeSys::SysType sys = pPipe->GetSysType();
|
|
CString csLable = pPipe->GetLabel();
|
|
// CString csLay = pPipe->GetLayer();
|
|
// csText.Format(_T("%s%.0f"), csLable, pPipe->GetDnDiameter());
|
|
if(m_iDimType == 1) // 编号标注
|
|
{
|
|
// cet 2014.6.12 modify 标注文字按编号样式显示
|
|
if (IsUseNewSerialNumberDimType()) // 新编号
|
|
{
|
|
int nType = GetSerialNumberDimType();
|
|
switch(nType)
|
|
{
|
|
case 0: // A-JL-1
|
|
{
|
|
if (csFloorNum.IsEmpty())
|
|
{
|
|
csText.Format(_T("%s-%s"), csMark, csSerial);
|
|
}
|
|
else
|
|
{
|
|
csText.Format(_T("%s-%s-%s"), csFloorNum, csMark, csSerial);
|
|
}
|
|
break;
|
|
}
|
|
case 1: // JL-A-1
|
|
{
|
|
if (csFloorNum.IsEmpty())
|
|
{
|
|
csText.Format(_T("%s-%s"), csMark, csSerial);
|
|
}
|
|
else
|
|
{
|
|
csText.Format(_T("%s-%s-%s"), csMark, csFloorNum, csSerial);
|
|
}
|
|
break;
|
|
}
|
|
case 2: // JL-A1
|
|
{
|
|
csText.Format(_T("%s-%s%s"), csMark, csFloorNum, csSerial);
|
|
break;
|
|
}
|
|
case 3: // AJL-1
|
|
{
|
|
csText.Format(_T("%s%s-%s"), csFloorNum, csMark, csSerial);
|
|
break;
|
|
}
|
|
case 4: // JLA-1
|
|
{
|
|
csText.Format(_T("%s%s-%s"), csMark, csFloorNum, csSerial);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else // 老编号
|
|
{
|
|
// int nIndex = GetPipeLayerIdxByName(csLay);
|
|
int nIndex = GetPipeLayerIdxBySys(pPipe->GetSysType());
|
|
CString sPipeAbbreviation;
|
|
if (nIndex != -1)
|
|
{
|
|
sPipeAbbreviation = g_csPipeDim[nIndex];
|
|
}
|
|
csText = sPipeAbbreviation + _T("L-") + csSerial;
|
|
// 全是立管时添楼号 cet 2012.10.12 add
|
|
if (bAllPipe)
|
|
{
|
|
csText = csFloorNum + (csFloorNum.IsEmpty() ? _T("") : _T("-"))+ csText;
|
|
}
|
|
}
|
|
}
|
|
else if (m_iDimType == 3) // cet 2011.4.25 add 标高标注
|
|
{
|
|
XLine lineBase(m_ptStart, m_ptTurn, 1);
|
|
lineBase.StartPoint().z = 0;
|
|
lineBase.EndPoint().z = 0;
|
|
XPoint ptInt;
|
|
|
|
XPoint ptS = pPipe->GetStartPoint(), ptE = pPipe->GetEndPoint();
|
|
XLine line(ptS, ptE, 1);
|
|
line.StartPoint().z = 0;
|
|
line.EndPoint().z = 0;
|
|
int ret = line.Intersection(&lineBase, ptInt); // 管线与标注线交点
|
|
if(!ptInt)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
line.StartPoint().z = ptS.z;
|
|
line.EndPoint().z = ptE.z;
|
|
pPipe->getClosestPointTo(ptInt, AcGeVector3d::kZAxis, ptInt); // 交点到管线中心线的z轴投影
|
|
double dEle = ptInt.z;
|
|
if(!DocGetMeterUnitDraw())
|
|
{
|
|
dEle *= 0.001;
|
|
}
|
|
csText.Format(_T("%.3f"), dEle);
|
|
// cet 2014.5.13 add 添加前缀
|
|
CString sPrefix = GetPipePrefix();
|
|
if (fabs(dEle) < 0.001)
|
|
{
|
|
csText.Insert(0, _T("±"));
|
|
}
|
|
else if (dEle > 0.001 && sPrefix.Find(_T("▽")) == -1 && !sPrefix.IsEmpty())
|
|
{
|
|
sPrefix += _T("+");
|
|
}
|
|
csText = sPrefix + csText;
|
|
}
|
|
else if (m_iDimType == 4) // cet 2012.6.28 add 管径标高样式
|
|
{
|
|
csText = pPipe->GetLabelText();
|
|
if (!pPipe->IsVertical())
|
|
{
|
|
XLine lineBase(m_ptStart, m_ptTurn, 1);
|
|
lineBase.StartPoint().z = 0;
|
|
lineBase.EndPoint().z = 0;
|
|
XPoint ptInt;
|
|
XPoint ptS = pPipe->GetStartPoint(), ptE = pPipe->GetEndPoint();
|
|
XLine line(ptS, ptE, 1);
|
|
line.StartPoint().z = 0;
|
|
line.EndPoint().z = 0;
|
|
int ret = line.Intersection(&lineBase, ptInt); // 管线与标注线交点
|
|
if(!ptInt)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
line.StartPoint().z = ptS.z;
|
|
line.EndPoint().z = ptE.z;
|
|
pPipe->getClosestPointTo(ptInt, AcGeVector3d::kZAxis, ptInt); // 交点到管线中心线的z轴投影
|
|
double dEle = ptInt.z;
|
|
if(!DocGetMeterUnitDraw())
|
|
{
|
|
dEle *= 0.001;
|
|
}
|
|
|
|
CString csTmp;
|
|
csTmp.Format(_T("%.3f"), dEle);
|
|
// zxl 2013.01.24 add
|
|
CString sText = GetPipePrefix();
|
|
if (dEle == 0.0)
|
|
{
|
|
sText += _T("±");
|
|
}
|
|
else if (dEle > 0.0 && sText.Find(_T("▽")) < 0)
|
|
{
|
|
if (!sText.IsEmpty())
|
|
{
|
|
sText += _T("+");
|
|
}
|
|
else
|
|
{
|
|
sText += _T(" ");
|
|
}
|
|
}
|
|
csTmp= sText + csTmp;
|
|
csText += _T(" ") + csTmp;
|
|
}
|
|
}
|
|
else if (m_iDimType == 5) // 管代号-管径标注 zxl 2013.02.21 add
|
|
{
|
|
// cet 2014.6.12 modify 代号保存在管线上
|
|
if (IncludeXdate(pPipe, _T("PIPE-MARK-DN")))
|
|
{
|
|
csText = ReadXdata(pPipe, _T("PIPE-MARK-DN"));
|
|
}
|
|
else
|
|
{
|
|
csText = GetOnePipeLabel(i);
|
|
}
|
|
if (!csText.IsEmpty())
|
|
{
|
|
csText += _T("-");
|
|
}
|
|
csText += pPipe->GetLabelText();
|
|
}
|
|
else{
|
|
csText = pPipe->GetLabelText();
|
|
// CString csGradient = I2Str(pPipe->GetPipeGradient()*1000);
|
|
// csText.Format(_T("%s%.0f i=%s L=%.2f"), csLable, pPipe->GetDnDiameter(), csGradient, pPipe->Length()/1000);
|
|
}
|
|
lstTexts.Append(tstrnew((const TCHAR*)csText));
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
lstTexts.Reverse();
|
|
}
|
|
// 获取管代号 zxl 2013.01.22 add
|
|
CString TDbPipeMultDim::GetOnePipeLabel(const int i) const
|
|
{
|
|
CString csText = GetPipeLabel();
|
|
int nNum = i;
|
|
while(nNum >= 0)
|
|
{
|
|
int nIndex = csText.Find(_T(","));
|
|
if (nIndex > 0 && nNum == 0)
|
|
{
|
|
csText = csText.Left(nIndex);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
csText = csText.Right(csText.GetLength() - nIndex - 1);
|
|
}
|
|
nNum--;
|
|
}
|
|
return csText;
|
|
}
|
|
|
|
XPoint TDbPipeMultDim::GetStartPoint() const
|
|
{
|
|
return m_ptStart;
|
|
}
|
|
|
|
XPoint TDbPipeMultDim::GetTurnPoint() const
|
|
{
|
|
return m_ptTurn;
|
|
}
|
|
|
|
XPoint TDbPipeMultDim::GetEndPoint() const
|
|
{
|
|
// double nLineSpace = (DocGetText2Base() * 2+ m_nTextHeight)*GetPScale();
|
|
double nLineSpace = (GetDimDist2Line() + m_nTextHeight)*GetPScale();
|
|
|
|
XStringList lstTexts;
|
|
GetTexts(lstTexts);
|
|
double nDist2End=(lstTexts.Length()-1)*nLineSpace;
|
|
XPoint ptEnd;
|
|
ads_polar(m_ptTurn, m_nLayoutRotation+PI/2.0, nDist2End, ptEnd);
|
|
return ptEnd;
|
|
}
|
|
|
|
double TDbPipeMultDim::GetTextBaseLen(BOOL bAsPaperUnit) const
|
|
{
|
|
double nVal=m_nTextBaseLen;
|
|
if(!bAsPaperUnit)
|
|
nVal *= GetPScale();
|
|
return nVal;
|
|
}
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbPipeMultDim::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("多管标注")));
|
|
XStringList lstTexts;
|
|
GetTexts(lstTexts);
|
|
for(int i=0; i<lstTexts.Length(); i++)
|
|
lstInfo.Append(new TObjInfoUnit(XString(_T("文字%d"), i), lstTexts[i]));
|
|
|
|
lstInfo.Append(new TObjInfoUnit(_T("文字高度"), XString(_T("%.1fP"), m_nTextHeight)));
|
|
XString sTextStyle=GetSymbolName(m_idTextStyle);
|
|
lstInfo.Append(new TObjInfoUnit(_T("文字样式"), sTextStyle));
|
|
}
|
|
|
|
double TDbPipeMultDim::GetMinTextBaseLen(BOOL bAsPaperUnit) const
|
|
{
|
|
TDbText text;
|
|
text.setPropertiesFrom(this);
|
|
text.SetHeight(m_nTextHeight);
|
|
text.SetStyleId(m_idTextStyle);
|
|
double nVal=0.0;
|
|
XStringList lstTexts;
|
|
GetTexts(lstTexts);
|
|
for(int i=0; i<lstTexts.Length(); i++) {
|
|
// cet 2014.5.13 modify 为保证计算的字符串长度与绘制的文字长度保持一致，统一处理
|
|
// 并更正多行文字时计算的长度值
|
|
CString sText = lstTexts[i];
|
|
ReplaceSpecialChar(sText);
|
|
if (sText.Find(_T('\n')) != -1)
|
|
{
|
|
std::vector<CString> vecText;
|
|
int nIndex = sText.Find(_T('\n'));
|
|
while(nIndex != -1)
|
|
{
|
|
vecText.push_back(sText.Left(nIndex));
|
|
if (sText.GetLength() - 1 == nIndex)
|
|
{
|
|
break;
|
|
}
|
|
sText = sText.Right(sText.GetLength() - nIndex - 1);
|
|
nIndex = sText.Find(_T('\n'));
|
|
}
|
|
|
|
if (!sText.IsEmpty())
|
|
{
|
|
vecText.push_back(sText);
|
|
}
|
|
|
|
int nSize = (int)vecText.size();
|
|
for (int j = 0; j < nSize; ++j)
|
|
{
|
|
text.SetText(vecText[j]);
|
|
XPoint ptExt=text.GetExtents();
|
|
nVal=max(nVal, ptExt.x);
|
|
}
|
|
continue;
|
|
}
|
|
text.SetText(sText);
|
|
XPoint ptExt=text.GetExtents();
|
|
nVal=max(nVal, ptExt.x);
|
|
}
|
|
// nVal += DocGetText2Base()*GetPScale()*2;
|
|
nVal += GetDimDist2Line()*GetPScale() / 4;
|
|
if(bAsPaperUnit)
|
|
nVal /= GetPScale();
|
|
return nVal;
|
|
}
|
|
|
|
double TDbPipeMultDim::GetDefaultTextBaseLen(BOOL bAsPaperUnit) const
|
|
{
|
|
double nVal=6.0;
|
|
if(!bAsPaperUnit)
|
|
nVal *= GetPScale();
|
|
// if(!m_bSideText)
|
|
nVal=max(nVal, GetMinTextBaseLen(bAsPaperUnit));
|
|
return nVal;
|
|
}
|
|
|
|
|
|
|
|
void TDbPipeMultDim::SetStartPoint(XPoint pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptStart=pt;
|
|
}
|
|
|
|
void TDbPipeMultDim::SetTurnPoint(XPoint pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptTurn = pt;
|
|
}
|
|
|
|
void TDbPipeMultDim::SetTextBaseLen(double val, BOOL bAsPaperUnit)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nTextBaseLen=val;
|
|
if(!bAsPaperUnit)
|
|
m_nTextBaseLen /= GetPScale();
|
|
}
|
|
|
|
|
|
|
|
void TDbPipeMultDim::AddPipe(AcDbObjectId id)
|
|
{
|
|
assertWriteEnabled();
|
|
BOOL bFind = m_lstPipe.FindNode(&id, CompareObjectId)!=NULL;
|
|
if(!bFind)
|
|
m_lstPipe.Append(new AcDbSoftPointerId(id));
|
|
}
|
|
|
|
void TDbPipeMultDim::GetPipes(DList<AcDbObjectId>& lstPipe) const
|
|
{
|
|
int nCount = m_lstPipe.Length();
|
|
for(int i=0; i<nCount; i++) {
|
|
lstPipe.Append(new AcDbObjectId(m_lstPipe[i]));
|
|
}
|
|
}
|
|
|
|
void TDbPipeMultDim::SetPipes(DList<AcDbObjectId> &lstPipe)
|
|
{
|
|
m_lstPipe.Reset();
|
|
int nCount = lstPipe.Length();
|
|
for(int i=0; i<nCount; i++) {
|
|
AcDbObjectId id = *lstPipe[i];
|
|
m_lstPipe.Append(new AcDbSoftPointerId(id));
|
|
}
|
|
}
|
|
|
|
void TDbPipeMultDim::ReplaceSpecialChar( CString &sText ) const
|
|
{
|
|
CString sReplaceString = GetReplaceSpecialCharString(_T("▽"));
|
|
sText.Replace(_T("▽"), sReplaceString);
|
|
}
|
|
|
|
void TDbPipeMultDim::GetSpecialCharIndexs( const CString &sText, std::map<int, CString> &mapIndex ) const
|
|
{
|
|
int nIndex = sText.Find(_T("▽"), 0);
|
|
while(nIndex != -1)
|
|
{
|
|
mapIndex.insert(std::make_pair(nIndex, _T("▽")));
|
|
if (nIndex == sText.GetLength() - 1)
|
|
{
|
|
break;
|
|
}
|
|
nIndex = sText.Find(_T("▽"), nIndex + 1);
|
|
}
|
|
}
|
|
|
|
void TDbPipeMultDim::DrawSpecialCharForDnElevationType(XExplodeDraw &dc, const CString &sText, XPoint ptTempBeg, XPoint ptTempEnd, XPoint ptLoc, double dLineSpace) const
|
|
{
|
|
// 支持多行文字
|
|
std::vector<CString> vecText;
|
|
int nLineIndex = sText.Find(_T('\n'), 0);
|
|
if (nLineIndex == -1)
|
|
{
|
|
vecText.push_back(sText);
|
|
}
|
|
else
|
|
{
|
|
CString sTemp = sText;
|
|
while(nLineIndex != -1)
|
|
{
|
|
vecText.push_back(sTemp.Left(nLineIndex));
|
|
if (sTemp.GetLength() - 1 == nLineIndex)
|
|
{
|
|
break;;
|
|
}
|
|
sTemp = sTemp.Right(sTemp.GetLength() - nLineIndex - 1);
|
|
nLineIndex = sTemp.Find(_T('\n'), 0);
|
|
}
|
|
|
|
if (!sTemp.IsEmpty())
|
|
{
|
|
vecText.push_back(sTemp);
|
|
}
|
|
}
|
|
// 绘制特殊字符
|
|
TDbText textTemp;
|
|
textTemp.setPropertiesFrom(this);
|
|
textTemp.setColorIndex(GetTextColor());
|
|
textTemp.SetStyleId(m_idTextStyle);
|
|
textTemp.SetHeight(m_nTextHeight);
|
|
textTemp.SetAlignment(XExplodeDraw::kTopLeft);
|
|
// 文字间距
|
|
textTemp.SetText(_T("EE"));
|
|
double dDist1 = textTemp.GetExtents().x;
|
|
textTemp.SetText(_T("E"));
|
|
double dDist2 = textTemp.GetExtents().x;
|
|
double dDist = dDist1 - dDist2 * 2;
|
|
// 对齐方式
|
|
std::map<int, CString> mapIndex;
|
|
std::map<int, CString>::const_iterator itBegin, itEnd, itTemp;
|
|
std::vector<CString>::reverse_iterator itTextBegin, itTextEnd = vecText.rend();
|
|
AcGeVector3d vtDir = ptTempEnd - ptTempBeg;
|
|
if (m_nTextBaseLen < 0)
|
|
{
|
|
vtDir *= -1;
|
|
}
|
|
vtDir.normalize();
|
|
AcGeVector3d vtDir2 = vtDir;
|
|
vtDir2.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
|
|
int nLineNum = 0;
|
|
for (itTextBegin = vecText.rbegin(); itTextBegin != itTextEnd; ++itTextBegin)
|
|
{
|
|
++nLineNum;
|
|
// 获得特殊字符位置
|
|
CString sTextTemp = *itTextBegin;
|
|
mapIndex.clear();
|
|
GetSpecialCharIndexs(sTextTemp, mapIndex);
|
|
if (mapIndex.empty())
|
|
{
|
|
textTemp.SetText(sTextTemp);
|
|
TPushProperty vProp(&textTemp, dc);
|
|
if(dc.IsFullExplode())
|
|
textTemp.ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(textTemp);
|
|
continue;
|
|
}
|
|
// 替换特殊字符
|
|
ReplaceSpecialChar(sTextTemp);
|
|
// 绘制非特殊字符
|
|
int nPreIndex = -1, nIndex = 0;
|
|
double dPreLen = 0.0;
|
|
std::map<int, double> mapDist; // 特殊符号前字符长度
|
|
XPoint pt = ptLoc + vtDir2 * (m_nTextHeight * GetPScale() + dLineSpace) * (nLineNum - 1);
|
|
textTemp.SetText(sTextTemp);
|
|
double dTextzLen = textTemp.GetExtents().x;
|
|
int nAlignType = GetDimAlignType();
|
|
if (nAlignType == 1) // 居中
|
|
{
|
|
double dLen = ptTempBeg.Distance(ptTempEnd) - dTextzLen;
|
|
pt += vtDir * dLen * 0.5;
|
|
}
|
|
else if (nAlignType == 2)// 右对齐
|
|
{
|
|
double dLen = ptTempBeg.Distance(ptTempEnd) - dTextzLen;
|
|
pt += vtDir * dLen;
|
|
}
|
|
bool bFlag = true;
|
|
for (itBegin = mapIndex.begin(), itEnd = mapIndex.end(); itBegin != itEnd; ++itBegin)
|
|
{
|
|
nIndex = itBegin->first;
|
|
// 绘制非特殊符号字符串
|
|
if (nIndex > nPreIndex && nIndex != 0)
|
|
{
|
|
END:
|
|
CString sTemp = sTextTemp.Left(nIndex);
|
|
if (nPreIndex > -1)
|
|
{
|
|
sTemp = sTemp.Right(bFlag ? nIndex + 1 - nPreIndex - 1 : nIndex - nPreIndex - 1);
|
|
}
|
|
textTemp.SetLocation(pt + vtDir * dPreLen);
|
|
textTemp.SetText(sTemp);
|
|
TPushProperty vProp(&textTemp, dc);
|
|
if(dc.IsFullExplode())
|
|
textTemp.ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(textTemp);
|
|
}
|
|
// 记录特殊符号位置
|
|
if (bFlag)
|
|
{
|
|
textTemp.SetLocation(AcGePoint3d::kOrigin);
|
|
textTemp.SetText(sTextTemp.Left(nIndex + 1));
|
|
mapDist[nIndex] = textTemp.GetExtents().x + dDist;
|
|
dPreLen = mapDist[nIndex];
|
|
nPreIndex = nIndex;
|
|
itTemp = itBegin;
|
|
++itTemp;
|
|
// 末尾字符串
|
|
if (itTemp == itEnd && nIndex < sTextTemp.GetLength() - 1)
|
|
{
|
|
nIndex = sTextTemp.GetLength();
|
|
bFlag = false;
|
|
goto END;
|
|
}
|
|
}
|
|
}
|
|
// 绘制特殊符号
|
|
Adesk::UInt16 color = dc.GetColor();
|
|
dc.SetColor(GetTextColor());
|
|
for (itBegin = mapIndex.begin(), itEnd = mapIndex.end(); itBegin != itEnd; ++itBegin)
|
|
{
|
|
double dLen = mapDist[itBegin->first];
|
|
if (itBegin->second == _T("▽")) // 绘制倒三角
|
|
{
|
|
CString sTemp = GetReplaceSpecialCharString(_T("▽"));
|
|
textTemp.SetLocation(AcGePoint3d::kOrigin);
|
|
textTemp.SetText(sTemp);
|
|
textTemp.SetAlignment(XExplodeDraw::kCenter);
|
|
double dWidth = textTemp.GetExtents().x;
|
|
double dHeight = textTemp.GetExtents().y;
|
|
double dPreLen = mapDist[itBegin->first];
|
|
if (itBegin->first == 0) // 首字符
|
|
{
|
|
dPreLen = 0.0;
|
|
}
|
|
else // 其他位置
|
|
{
|
|
dPreLen -= (dWidth + dDist);
|
|
}
|
|
XPoint ptLeft = pt + vtDir * dPreLen;
|
|
XPoint ptRight = ptLeft + vtDir * dWidth;
|
|
XPoint ptBottom = pt + vtDir * (dPreLen + dWidth * 0.5) - vtDir2 * dHeight;
|
|
AcDbExtents ext;
|
|
if (textTemp.getGeomExtents(ext) == Acad::eOk)
|
|
{
|
|
ptLeft -= vtDir2 * (dHeight - (ext.maxPoint().y - ext.minPoint().y ));
|
|
ptRight -= vtDir2 * (dHeight - (ext.maxPoint().y - ext.minPoint().y ));
|
|
}
|
|
dc << XLine(ptLeft, ptRight);
|
|
dc << XLine(ptLeft, ptBottom);
|
|
dc << XLine(ptRight, ptBottom);
|
|
}
|
|
}
|
|
dc.SetColor(color);
|
|
}
|
|
}
|
|
|
|
CString TDbPipeMultDim::GetReplaceSpecialCharString( const CString &sSpeicalChar ) const
|
|
{
|
|
CString sText;
|
|
if (sSpeicalChar == _T("▽"))
|
|
{
|
|
sText = _T("W");
|
|
}
|
|
return sText;
|
|
}
|
|
|
|
void TDbPipeMultDim::DrawSpecialCharForElevationType( XExplodeDraw &dc, TDbSymbElevation &text) const
|
|
{
|
|
CString sText = text.GetText();
|
|
ReplaceSpecialChar(sText);
|
|
text.SetText(sText);
|
|
AcDbVoidPtrArray arr;
|
|
FullExplode(&text, arr);
|
|
int nCount = arr.length();
|
|
CString sReplaceString = GetReplaceSpecialCharString(_T("▽"));
|
|
for (int i = 0; i < nCount; ++i)
|
|
{
|
|
AcDbEntity *pEntity = (AcDbEntity *)arr[i];
|
|
if (pEntity == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
if (pEntity->isKindOf(AcDbText::desc())) // 文字
|
|
{
|
|
AcDbText *pText = (AcDbText*)pEntity;
|
|
TCHAR *pszText = pText->textString();
|
|
sText = pszText;
|
|
delete pszText;
|
|
if (sText == sReplaceString) // 绘制特殊符号
|
|
{
|
|
double dAngle = pText->rotation();
|
|
pText->setRotation(0.0);
|
|
AcDbExtents ext;
|
|
if (pText->getGeomExtents(ext) == Acad::eOk)
|
|
{
|
|
double dWidth = ext.maxPoint().x - ext.minPoint().x;
|
|
double dHeight = ext.maxPoint().y - ext.minPoint().y;
|
|
AcGePoint3d pt = pText->position();
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis;
|
|
vtX = Ucs2Wcs(vtX, TRUE);
|
|
vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
XPoint pt1 = pt + vtX * dWidth * 0.5;
|
|
XPoint pt2 = pt;
|
|
XPoint pt3 = pt2 + vtX * dWidth;
|
|
vtX.rotateBy(PI / 2, AcGeVector3d::kZAxis);
|
|
pt2 += vtX * dHeight;
|
|
pt3 += vtX * dHeight;
|
|
Adesk::UInt16 color = dc.GetColor();
|
|
dc.SetColor(GetTextColor());
|
|
dc << XLine(pt1, pt2);
|
|
dc << XLine(pt1, pt3);
|
|
dc << XLine(pt2, pt3);
|
|
dc.SetColor(color);
|
|
}
|
|
}
|
|
else // 直接绘制文字
|
|
{
|
|
dc.DrawEntity(*pEntity);
|
|
}
|
|
}
|
|
else // 直线
|
|
{
|
|
pEntity->setColorIndex(dc.GetColor());
|
|
dc.DrawEntity(*pEntity);
|
|
}
|
|
}
|
|
ReleaseEntSet(arr);
|
|
}
|
|
|
|
bool TDbPipeMultDim::IsIncludeSpeicalChar( const CString &sText ) const
|
|
{
|
|
return sText.Find(_T("▽")) != -1;
|
|
}
|
|
|
|
void TDbPipeMultDim::SetSerialNumberDimType( int nType )
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(_T("SerialNumberDimType"), (Adesk::Int8)nType);
|
|
}
|
|
|
|
int TDbPipeMultDim::GetSerialNumberDimType() const
|
|
{
|
|
const TEntityFields &fd = GetFields();
|
|
Adesk::Int8 nType = -1;
|
|
fd.GFD(_T("SerialNumberDimType"), nType);
|
|
return (int)nType;
|
|
}
|
|
|
|
bool TDbPipeMultDim::IsUseNewSerialNumberDimType() const
|
|
{
|
|
const TEntityFields &fd = GetFields();
|
|
Adesk::Int8 nType = -1;
|
|
return fd.GFD(_T("SerialNumberDimType"), nType);
|
|
}
|
|
void TDbPipeMultDim::SetLabelType(int iType)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(MPIPE_DIM_TYPE, iType);
|
|
}
|
|
int TDbPipeMultDim::GetLabelType() const
|
|
{
|
|
assertReadEnabled();
|
|
const TEntityFields &fd = GetFields();
|
|
int iDimType;
|
|
if( !fd.GFD(MPIPE_DIM_TYPE, iDimType) )
|
|
{
|
|
iDimType = 0;
|
|
}
|
|
return iDimType;
|
|
}
|
|
void TDbPipeMultDim::SetBulge(double dBulge)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(MPIPE_DIM_BULGE, dBulge);
|
|
}
|
|
double TDbPipeMultDim::GetBulge() const
|
|
{
|
|
assertReadEnabled();
|
|
const TEntityFields &fd = GetFields();
|
|
double dBulge;
|
|
if( !fd.GFD(MPIPE_DIM_BULGE, dBulge) )
|
|
{
|
|
dBulge = .0;
|
|
}
|
|
return dBulge;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void InitDbPieMultDim(BOOL bTrue)
|
|
{
|
|
if(bTrue) {
|
|
TDbPipeMultDim::rxInit();
|
|
TDbPipeMultDim::InitMatchProtocol(TRUE);
|
|
} else {
|
|
TDbPipeMultDim::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbPipeMultDim::desc());
|
|
}
|
|
} |