568 lines
14 KiB
C++
568 lines
14 KiB
C++
/********************************************************************
|
|
created: 2004/12/28
|
|
created: 28:12:2004 17:00
|
|
filename: f:\tg_dev\telecdev\twtkernal\jig.cpp
|
|
file path: f:\tg_dev\telecdev\twtkernal
|
|
file base: jig
|
|
file ext: cpp
|
|
author: 沈睿
|
|
|
|
purpose: 多管绘制
|
|
*********************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "jig.h"
|
|
|
|
extern XPoint GetNearPtByLst(XPoint pt, XPointList &lstPtIn);
|
|
|
|
|
|
TMultPipePreview::TMultPipePreview(XPointList &lstPt, double nAng, BOOL bFromVPipe)
|
|
{
|
|
m_lstOld = lstPt;
|
|
m_nAng = nAng;
|
|
m_bFromVPipe = bFromVPipe;
|
|
}
|
|
|
|
TMultPipePreview::~TMultPipePreview()
|
|
{
|
|
}
|
|
|
|
|
|
Adesk::Boolean TMultPipePreview::subWorldDraw(AcGiWorldDraw *pWd)
|
|
{
|
|
int len = m_lstOld.Length();
|
|
m_lstEnd.Reset();
|
|
m_lstStart.Reset();
|
|
// XPoint ptMid = GetNearPtByLst(m_ptEnd, m_lstOld); cet 2011.5.18 modify
|
|
XPoint ptMid = *m_lstOld[0];
|
|
ptMid.z = 0;
|
|
double nAngleStart = m_nAng;
|
|
|
|
XPoint ptTmpEnd, ptTmpStart;
|
|
double dAng = ads_angle(ptMid, m_ptEnd);
|
|
if(m_nAng < 0)
|
|
nAngleStart = dAng;
|
|
for(int i=0;i<len;i++){
|
|
XPoint ptTurn = *m_lstOld[i];
|
|
ptTurn.z = 0;
|
|
double nAngTmp = dAng;
|
|
double n = ads_distance(ptTurn, ptMid); //2管线距离
|
|
if(m_bFromVPipe){
|
|
XPoint ptTemp, ptTemp2;
|
|
ads_polar(ptMid, dAng, 100, ptTemp);
|
|
XLine line2(ptMid, ptTemp);
|
|
ptTurn.Project(&line2, ptTemp2);
|
|
nAngTmp = ads_angle(ptTemp2, ptTurn);
|
|
n = ads_distance(ptTemp2, ptTurn);
|
|
}
|
|
|
|
|
|
|
|
double nAn = ads_angle(ptMid, ptTurn);
|
|
if(fabs(nAn - PI*2) < 0.001 || nAn > PI*2)
|
|
nAn -= PI*2;
|
|
|
|
if(nAngleStart < PI/2 || nAngleStart > (PI/2*3 + 0.1) || fabs(nAngleStart - PI/2) < 0.001){
|
|
if(!m_bFromVPipe){
|
|
if(fabs(nAn) < 0.001)
|
|
nAngTmp -= PI/2;
|
|
else if(fabs(nAn - PI) < 0.001)
|
|
nAngTmp += PI/2;
|
|
else if(nAn < PI)
|
|
nAngTmp += PI/2;
|
|
else
|
|
nAngTmp -= PI/2;
|
|
}
|
|
}
|
|
else{
|
|
if(!m_bFromVPipe){
|
|
if(fabs(nAn) < 0.001)
|
|
nAngTmp += PI/2;
|
|
else if(fabs(nAn - PI) < 0.001)
|
|
nAngTmp -= PI/2;
|
|
else if(nAn < PI)
|
|
nAngTmp -= PI/2;
|
|
else
|
|
nAngTmp += PI/2;
|
|
}
|
|
}
|
|
|
|
if(nAngTmp > PI*2)
|
|
nAngTmp -= PI*2;
|
|
ads_polar(m_ptEnd, nAngTmp, n, ptTmpEnd);
|
|
ads_polar(ptMid, nAngTmp, n, ptTmpStart);
|
|
if(m_bFromVPipe){
|
|
ptTmpStart = ptTurn;
|
|
ads_polar(m_ptEnd, nAngTmp, n, ptTmpEnd);
|
|
}
|
|
m_lstEnd.NewAppend(ptTmpEnd);
|
|
m_lstStart.NewAppend(ptTmpStart);
|
|
AcDbLine line(ptTmpStart, ptTmpEnd);
|
|
line.worldDraw(pWd);
|
|
}
|
|
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
|
|
|
|
TMultPipeJig::TMultPipeJig(XPointList &lstPt, double nAng, BOOL bFromVPipe)
|
|
{
|
|
m_pDrawEnt = new TMultPipePreview(lstPt, nAng, bFromVPipe);
|
|
m_ptStart = *lstPt[0];
|
|
}
|
|
|
|
|
|
TMultPipeJig::~TMultPipeJig()
|
|
{
|
|
if(m_pDrawEnt)
|
|
delete m_pDrawEnt;
|
|
}
|
|
|
|
|
|
AcEdJig::DragStatus
|
|
TMultPipeJig::GetPoint(XPoint &pt)
|
|
{
|
|
return acquirePoint(pt, m_ptStart.AsAcGePoint3d());
|
|
}
|
|
|
|
|
|
int TMultPipeJig::DoIt(int *keyIndex)
|
|
{
|
|
int nRet = TSymbEdJig::DoIt(keyIndex);
|
|
return nRet;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean TMultPipeJig::update()
|
|
{
|
|
Adesk::Boolean bRet=Adesk::kTrue;
|
|
// m_ptStart = GetNearPtByLst(m_ptResult, m_pDrawEnt->m_lstOld); cet 2011.5.18 modify
|
|
m_ptStart = *m_pDrawEnt->m_lstOld[0];
|
|
|
|
m_pDrawEnt->m_ptEnd = m_ptResult;
|
|
return bRet;
|
|
}
|
|
|
|
AcDbEntity* TMultPipeJig::entity() const
|
|
{
|
|
return (AcDbEntity *)m_pDrawEnt;
|
|
}
|
|
|
|
//***************************************************************************************************
|
|
// 绘制双管
|
|
//***************************************************************************************************
|
|
|
|
TDoublePipeJig::TDoublePipeJig(XPoint pt1, BOOL bIsVPipe, double nWidth)
|
|
{
|
|
m_ptStart = pt1;
|
|
m_ptEnd = pt1;
|
|
m_nWidth = nWidth;
|
|
m_bIsVPipe = bIsVPipe;
|
|
m_pDrawEnt = new TDbDoubleLinePipe;
|
|
m_pDrawEnt->SetStartPoint(m_ptStart);
|
|
m_pDrawEnt->SetEndPoint(m_ptEnd);
|
|
m_pDrawEnt->SetWidth(nWidth);
|
|
m_pDrawEnt->SetDnDiameter(nWidth);
|
|
}
|
|
|
|
|
|
TDoublePipeJig::~TDoublePipeJig()
|
|
{
|
|
if(m_pDrawEnt)
|
|
delete m_pDrawEnt;
|
|
}
|
|
|
|
AcEdJig::DragStatus
|
|
TDoublePipeJig::GetPoint(XPoint &pt)
|
|
{
|
|
if(m_bIsVPipe)
|
|
return acquirePoint(pt);
|
|
|
|
return acquirePoint(pt, m_ptStart.AsAcGePoint3d());
|
|
}
|
|
|
|
|
|
int TDoublePipeJig::DoIt(int *keyIndex)
|
|
{
|
|
int nRet = TSymbEdJig::DoIt(keyIndex);
|
|
return nRet;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean TDoublePipeJig::update()
|
|
{
|
|
Adesk::Boolean bRet=Adesk::kTrue;
|
|
m_pDrawEnt->SetWidth(m_nWidth);
|
|
if(m_bIsVPipe){
|
|
XPoint ptEnd = m_ptResult;
|
|
m_pDrawEnt->SetStartPoint(m_ptResult);
|
|
ptEnd.z += 3000;
|
|
m_pDrawEnt->SetEndPoint(ptEnd);
|
|
}
|
|
else
|
|
m_pDrawEnt->SetEndPoint(m_ptResult);
|
|
|
|
m_pDrawEnt->SetDnDiameter(m_nWidth);
|
|
return bRet;
|
|
}
|
|
|
|
AcDbEntity* TDoublePipeJig::entity() const
|
|
{
|
|
return (AcDbEntity *)m_pDrawEnt;
|
|
}
|
|
|
|
|
|
void TDimensionEdJig::FindAndRemoveSeg(XPoint pt)
|
|
{
|
|
XCurveSegment seg=m_pDrawEnt->GetDimCurve();
|
|
XPoint ptOnSeg;
|
|
seg.ProjectToMe(pt, ptOnSeg);
|
|
double value=seg.StartPoint().Distance2d(ptOnSeg);
|
|
long i=-1;
|
|
if(value>_distSnap)
|
|
{
|
|
double curValue=0;
|
|
for(i=0;i<m_pDrawEnt->GetSegmentNum();i++)
|
|
{
|
|
curValue+=m_pDrawEnt->GetSegment(i);
|
|
if(fabs(curValue-value)<_distSnap)
|
|
break;
|
|
}
|
|
}
|
|
if(i>=m_pDrawEnt->GetSegmentNum())
|
|
return;//useful
|
|
|
|
if(i>=0)
|
|
{
|
|
double temp=m_pDrawEnt->GetSegment(i);
|
|
if(i<(m_pDrawEnt->GetSegmentNum()-1))//是中间段
|
|
m_pDrawEnt->SetSegment(i+1,temp+m_pDrawEnt->GetSegment(i+1));//后一段合并之
|
|
m_pDrawEnt->RemoveSegment(i);
|
|
}
|
|
else//第一个标注段的起点（不一定是DimContinue中提示的第一点）特殊处理
|
|
{
|
|
double temp=m_pDrawEnt->GetSegment(0);
|
|
m_pDrawEnt->RemoveSegment(0);
|
|
XVector3D vt=seg.EndPoint()-seg.StartPoint();
|
|
vt.Scale(temp/vt.Length());
|
|
m_pDrawEnt->SetLocation(m_pDrawEnt->GetLocation()+vt);
|
|
}
|
|
}
|
|
//void TDimensionEdJig::Step()
|
|
//{
|
|
// ptStack.Push(m_ptDim);
|
|
//}
|
|
//bool TDimensionEdJig::CanUndo()
|
|
//{
|
|
// return ptStack.GetDepth()>1;
|
|
//}
|
|
//void TDimensionEdJig::Undo()
|
|
//{
|
|
// XPoint pt;
|
|
// ptStack.GetTopData(pt);
|
|
// ptStack.GoBack();
|
|
// if(CanUndo())
|
|
// m_pDrawEnt->FindAndRemoveSegment(pt);
|
|
//}
|
|
//XPoint TDimensionEdJig::GetLastPoint()
|
|
//{
|
|
// XPoint pt;
|
|
// ptStack.GetTopData(pt);
|
|
// return pt;
|
|
|
|
//end
|
|
|
|
void TDimensionEdJig::Swap()
|
|
{
|
|
if(m_pTemp) {
|
|
AcDbDeepCloneFiler filer;
|
|
if(m_pTemp->dwgOut(&filer)==Acad::eOk) {
|
|
filer.seek(0L,0);
|
|
VERIFY(m_pDrawEnt->dwgIn(&filer)==Acad::eOk);
|
|
}
|
|
ASSERT(m_pTemp && m_pTemp->IsValid());
|
|
} else {
|
|
m_pTemp = (TDbDimension2 *)m_pDrawEnt->clone();
|
|
ASSERT(m_pTemp && m_pTemp->IsValid());
|
|
}
|
|
}
|
|
|
|
// 转换成ADS代码
|
|
int TDimensionEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if(ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret <= 0)
|
|
ret = RTNORM;
|
|
else {
|
|
if(kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
TDimensionEdJig::TDimensionEdJig(TDbDimension2 *pDim, const TCHAR *pszPrompt, const TCHAR *pszKeyword)
|
|
:m_pDrawEnt(pDim), m_pszPrompt(pszPrompt), m_pszKeyword(pszKeyword), m_nRetCode(0)
|
|
{
|
|
m_pTemp=NULL;
|
|
m_nFlag=0;
|
|
m_ptDim=pDim->GetLocation();
|
|
}
|
|
|
|
TDimensionEdJig::~TDimensionEdJig()
|
|
{
|
|
if(m_pTemp)
|
|
delete m_pTemp;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
int TDimensionEdJig::doIt()
|
|
{
|
|
setDispPrompt(m_pszPrompt);
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
return GetRetCode();
|
|
}
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus TDimensionEdJig::sampler()
|
|
{
|
|
DragStatus stat;
|
|
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kAccept3dCoordinates|AcEdJig::kNullResponseAccepted));
|
|
|
|
if (m_pszKeyword) setKeywordList(m_pszKeyword);
|
|
XPoint ptTemp;
|
|
if(m_nFlag==0) stat=acquirePoint(ptTemp, m_pDrawEnt->GetLocation().AsAcGePoint3d());
|
|
else if(m_nFlag==1 || m_nFlag==2) stat = acquirePoint(ptTemp);
|
|
// else if(m_nFlag==3) {//modidfied by whl on 03/08/08
|
|
// XPoint ptLast=GetLastPoint();
|
|
// stat=acquirePoint(ptTemp, ptLast);
|
|
// } else if(m_nFlag==4) {
|
|
// XPoint ptLast;
|
|
// xg_getvar("LASTPOINT", ptLast);
|
|
// ptLast = Ucs2Wcs(ptLast);
|
|
// stat=acquirePoint(ptTemp, ptLast);
|
|
// }
|
|
|
|
if(stat == AcEdJig::kNormal) {
|
|
if (ptTemp.Distance2d(m_ptDim)>_distSnap) {
|
|
double nDist=m_ptDim.Distance2d(ptTemp);
|
|
m_ptDim=ptTemp;
|
|
} else
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean TDimensionEdJig::update()
|
|
{
|
|
if(m_nFlag==0) {
|
|
m_pDrawEnt->SetRotation(ads_angle(m_ptDim, m_pDrawEnt->GetLocation())+PI);
|
|
double nVal=m_ptDim.Distance2d(m_pDrawEnt->GetLocation());
|
|
if(m_pDrawEnt->IsValidSegment(nVal))
|
|
m_pDrawEnt->SetSegment(0, nVal);
|
|
} else if(m_nFlag==1) {
|
|
XCurveSegment seg=m_pDrawEnt->GetDimCurve();
|
|
XPoint ptOnSeg;
|
|
if(seg.ProjectToMe(m_ptDim, ptOnSeg)==RTNORM) {
|
|
double nDistMove=m_ptDim.Distance2d(ptOnSeg);
|
|
int nSideLoc=seg.OnWhichSide(m_pDrawEnt->GetLocation());
|
|
int nSide=seg.OnWhichSide(m_ptDim);
|
|
double nDist2Dim=m_pDrawEnt->GetDist2DimLine(FALSE);
|
|
|
|
if(fabs(nDist2Dim)>1.0E-6) {
|
|
double nFactor=nDist2Dim/fabs(nDist2Dim);
|
|
if(nSide!=nSideLoc)
|
|
nDistMove *= nFactor;
|
|
else
|
|
nDistMove *= -nFactor;
|
|
} else {
|
|
if(nSideLoc=OFFSET_LEFT) nDistMove=-nDistMove;
|
|
//else nDist2Dim=nDistMove;
|
|
}
|
|
|
|
if(m_pDrawEnt->IsAngular()) { //弧墙有错，不知道原因
|
|
nDist2Dim += nDistMove;
|
|
double nDistRad= m_pDrawEnt->GetDimRadius();
|
|
//seg.GetArc().center.Distance(m_ptDim);
|
|
nDistRad -= nDistMove;
|
|
if(nDistRad>_distSnap) {
|
|
m_pDrawEnt->SetDimRadius(nDistRad);
|
|
m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
|
|
}
|
|
} else {
|
|
nDist2Dim += nDistMove;
|
|
m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
|
|
}
|
|
|
|
}
|
|
} else if(m_nFlag==2) { //修改标注位置
|
|
AcDbIntArray indices;
|
|
indices.append(3);
|
|
AcGePoint3dArray ptArray;
|
|
m_pDrawEnt->getStretchPoints(ptArray);
|
|
ASSERT(ptArray.length()>3);
|
|
AcGeVector3d vtOffset=m_ptDim.AsAcGePoint3d()-ptArray[3];
|
|
m_pDrawEnt->moveGripPointsAt(indices, vtOffset);
|
|
}
|
|
// else if(m_nFlag==3) {//modified by whl on 03/08/08
|
|
// ASSERT(m_pTemp);
|
|
// CopyObject(*m_pDrawEnt, *m_pTemp);
|
|
// if(CanUndo()){
|
|
// if(!m_pTemp->AddSegment(m_ptDim))
|
|
// return Adesk::kFalse;
|
|
// }else{
|
|
// m_pTemp->SetRotation(ads_angle(m_ptDim, m_pTemp->GetLocation())+PI);
|
|
// double nVal=m_ptDim.Distance2d(m_pTemp->GetLocation());
|
|
// if(m_pTemp->IsValidSegment(nVal))
|
|
// m_pTemp->SetSegment(0, nVal);
|
|
// }
|
|
// ASSERT(m_pTemp && m_pTemp->IsValid());
|
|
// } else if(m_nFlag==4) {
|
|
// ASSERT(m_pTemp);
|
|
// CopyObject(*m_pDrawEnt, *m_pTemp);
|
|
// m_pTemp->AddSegment(m_ptDim);
|
|
// }
|
|
ASSERT(m_pDrawEnt && m_pDrawEnt->IsValid());
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* TDimensionEdJig::entity() const
|
|
{
|
|
if((m_nFlag==3 || m_nFlag==4) && m_pTemp)
|
|
return m_pTemp;
|
|
else
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
TLeaderEdJig::TLeaderEdJig(TDbSymbMultiLeader *pElev)
|
|
{
|
|
m_nOperCode=TLeaderEdJig::kNone;
|
|
m_pDrawEnt=pElev;
|
|
}
|
|
|
|
XPoint TLeaderEdJig::GetDragPoint() const
|
|
{
|
|
XPoint ptDrag=m_ptResult;
|
|
if(m_nOperCode==TLeaderEdJig::kLeader)
|
|
ptDrag=m_pDrawEnt->GetLeaderPoint();
|
|
else if(m_nOperCode==TLeaderEdJig::kTextLine)
|
|
ptDrag=m_pDrawEnt->GetTextBasePoint();
|
|
return ptDrag;
|
|
}
|
|
|
|
XPoint TLeaderEdJig::GetBasePoint() const
|
|
{
|
|
XPoint ptDrag=m_ptResult;
|
|
if(m_nOperCode==TLeaderEdJig::kLeader) {
|
|
XPointList pts;
|
|
m_pDrawEnt->GetLeaderVertexes(pts);
|
|
if(pts.Length())
|
|
ptDrag=*pts[0];
|
|
} else {
|
|
ptDrag=m_pDrawEnt->GetLeaderPoint();
|
|
}
|
|
return ptDrag;
|
|
}
|
|
|
|
|
|
// 开始执行拖动
|
|
int TLeaderEdJig::DoIt(int *keyIndex)
|
|
{
|
|
m_ptResult=GetDragPoint();
|
|
|
|
XPushVar<int> osmode(_T("OSMODE"), 0);//add by whl
|
|
return TSymbEdJig::DoIt(keyIndex);
|
|
}
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus
|
|
TLeaderEdJig::GetPoint(XPoint &pt)
|
|
{
|
|
DragStatus stat;
|
|
if(m_nOperCode==kTextLine)
|
|
stat=acquirePoint(pt);
|
|
else
|
|
stat = acquirePoint(pt, GetBasePoint().AsAcGePoint3d());
|
|
return stat;
|
|
}
|
|
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean TLeaderEdJig::update()
|
|
{
|
|
Adesk::Boolean bRet=Adesk::kTrue;
|
|
if(m_nOperCode==TLeaderEdJig::kLeader) {
|
|
XVector3D vtOffset=m_ptResult-GetBasePoint();
|
|
vtOffset.Rotate(-Ucs2Wcs(0.0));// zxl 2013.07.23 add
|
|
m_pDrawEnt->SetLeaderPoint(m_ptResult);
|
|
if(vtOffset.x<0.0)
|
|
m_pDrawEnt->SetTextBaseLen(-fabs(m_pDrawEnt->GetTextBaseLen()));
|
|
else
|
|
m_pDrawEnt->SetTextBaseLen(fabs(m_pDrawEnt->GetTextBaseLen()));
|
|
} else if(m_nOperCode==TLeaderEdJig::kVertex) {
|
|
} else if(m_nOperCode==TLeaderEdJig::kTextLine) {
|
|
XPoint ptLeader=m_pDrawEnt->GetLeaderPoint();
|
|
m_pDrawEnt->SetTextBaseLen(m_ptResult.x - ptLeader.x, FALSE);
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
AcDbEntity* TLeaderEdJig::entity() const
|
|
{
|
|
return (AcDbEntity *)m_pDrawEnt;
|
|
}
|
|
|
|
TDrawingIdxEdJig::TDrawingIdxEdJig(TDbSymbDrawingIndex *pIdx)
|
|
{
|
|
m_pDrawEnt = pIdx;
|
|
}
|
|
|
|
AcEdJig::DragStatus
|
|
TDrawingIdxEdJig::GetPoint(XPoint &pt)
|
|
{
|
|
if(!m_ptRef)
|
|
return acquirePoint(pt);
|
|
else
|
|
return acquirePoint(pt, m_ptRef);
|
|
}
|
|
|
|
// 开始执行拖动
|
|
int TDrawingIdxEdJig::DoIt(int *keyIndex)
|
|
{
|
|
int nRet = TSymbEdJig::DoIt(keyIndex);
|
|
return nRet;
|
|
}
|
|
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean TDrawingIdxEdJig::update()
|
|
{
|
|
Adesk::Boolean bRet=Adesk::kTrue;
|
|
m_pDrawEnt->SetCenter(m_ptResult);
|
|
return bRet;
|
|
}
|
|
|
|
AcDbEntity* TDrawingIdxEdJig::entity() const
|
|
{
|
|
|
|
return (AcDbEntity *)m_pDrawEnt;
|
|
}
|