3947 lines
98 KiB
C++
3947 lines
98 KiB
C++
// DrawStandPipeDlg.cpp : implementation file
|
||
//
|
||
|
||
#include "stdafx.h"
|
||
//#include <dbwall.h>
|
||
#include <xwall.h>
|
||
#include <DbEquipment.h>
|
||
#include <PipeWireMonitor.h>
|
||
#include <dbPipeValve.h>
|
||
#include <DbPipeLabel.h>
|
||
#include <xblock.h>
|
||
#include <DbDoubleLinePipe.h>
|
||
|
||
#include "DrawStandPipeDlg.h"
|
||
#include "PipeSettingDlg.h"
|
||
#include "InsBlockDlg.h"
|
||
#include "PipeSettingFrameDlg.h"
|
||
#include "dbxutil.h"
|
||
#include <list>
|
||
|
||
#ifdef _DEBUG
|
||
#define new DEBUG_NEW
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[] = __FILE__;
|
||
#endif
|
||
|
||
const UINT PipeMenuID = 9410;
|
||
|
||
|
||
extern void DoDimStandPipe(AcDbObjectId idPipe, const TCHAR* szName, const TCHAR* szSerial);
|
||
//extern TDbPipe * ClonePipe(TDbPipe *pOldPipe);
|
||
|
||
|
||
|
||
//***************************************************************************************************
|
||
// 上下扣弯
|
||
//***************************************************************************************************
|
||
|
||
void GetAllPipeByPipe(AcDbObjectId pipeId, PickSet &ss, XPoint ptStart)
|
||
{
|
||
|
||
OPENOBJ_BEGIN(pipeId, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
XPoint ptTmp = pPipe->StartPoint();
|
||
AcDbObjectId nodeId(NULL);
|
||
if(ptStart == pPipe->StartPoint())
|
||
nodeId = pPipe->GetNode(0);
|
||
else if(ptStart == pPipe->EndPoint())
|
||
nodeId = pPipe->GetNode(1);
|
||
if(!IsEquipment(nodeId)){
|
||
OPENOBJ_BEGIN(nodeId, AcDb::kForRead, TDbPipeNode, pNode);
|
||
if(pNode){
|
||
int num = pNode->GetInterfaceNum();
|
||
if(num == 2){
|
||
TPipeInterface face;
|
||
pNode->GetInterface(0, face);
|
||
AcDbObjectId nextPipeId = face.m_idPipe;
|
||
if(pipeId == face.m_idPipe){
|
||
pNode->GetInterface(1, face);
|
||
nextPipeId = face.m_idPipe;
|
||
}
|
||
XPoint nextPt;
|
||
OPENOBJ_BEGIN(nextPipeId, AcDb::kForRead, TDbPipe, pPipe2);
|
||
if(pPipe2){
|
||
nextPt = pPipe2->StartPoint() == ptStart ? pPipe2->EndPoint() : pPipe2->StartPoint();
|
||
}
|
||
OPENOBJ_END();
|
||
GetAllPipeByPipe(nextPipeId, ss, nextPt);
|
||
ss+=nextPipeId;
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
return;
|
||
}
|
||
|
||
void CheckStandPipe(Entity ent, XPoint ptPick, double nOldElevation)
|
||
{
|
||
RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
|
||
XPoint ptPipeS, ptPipeE, ptTmp;
|
||
GetPipePoint(ent, ptPipeS, ptPipeE);
|
||
CString csLay = GetPipeLayer(ent);
|
||
TPipeSys::SysType sys = GetPipeSys(ent);
|
||
|
||
if(ptPipeS == ptPick)
|
||
ptTmp = ptPipeE;
|
||
else
|
||
ptTmp = ptPipeS;
|
||
|
||
PickSet ss(SS_FREE);
|
||
GetPointPickSet(ptTmp, ss, rbMask, (int)g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);
|
||
if(ss.Length() != 2 && ss.Length() != 3)
|
||
return;
|
||
Entity entDel;
|
||
for(long i=0;i<ss.Length();i++){
|
||
Entity entTmp = ss[i];
|
||
XPoint pt1, pt2;
|
||
OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
if(sys != pPipe->GetSysType() || !pPipe->IsVertical())
|
||
continue;
|
||
pt1 = pPipe->StartPoint();
|
||
pt2 = pPipe->EndPoint();
|
||
if(fabs(pt1.z - nOldElevation) < 0.001 || fabs(pt2.z - nOldElevation) < 0.01){
|
||
|
||
if(pPipe->upgradeOpen()==Acad::eOk) {
|
||
pPipe->assertWriteEnabled();
|
||
if(fabs(pt1.z - nOldElevation) < 0.001)
|
||
pPipe->StartPoint().z = ptPipeS.z;
|
||
else if(fabs(pt2.z - nOldElevation) < 0.001)
|
||
pPipe->EndPoint().z = ptPipeS.z;
|
||
pPipe->downgradeOpen();
|
||
if(pPipe->StartPoint() == pPipe->EndPoint()){//2段管线同标高，删除扣弯
|
||
entDel = entTmp;
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
entDel.Erase();
|
||
}
|
||
|
||
BOOL DoModifyPipeEle(Entity entSel, XPoint ptPick, double &nElevation, BOOL bNeed)
|
||
{
|
||
double dMeter(1);
|
||
if(!DocGetMeterUnitDraw())
|
||
dMeter = 1000;
|
||
|
||
Adesk::UInt16 iCol(1), iCol2(1);
|
||
TCHAR szLay[256];
|
||
entSel.GetData(8, szLay);
|
||
|
||
AcDbLayerTable *pLayertable = NULL;
|
||
AcDbLayerTableRecord *pLayerRec = NULL;
|
||
acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
|
||
if(!pLayertable)
|
||
return FALSE;
|
||
if((pLayertable->getAt(szLay, pLayerRec, AcDb::kForWrite)) == Acad::eOk) {
|
||
AcCmColor col = pLayerRec->color();
|
||
iCol2 = col.colorIndex();
|
||
if(iCol2 == 1)
|
||
iCol2 = 2;
|
||
else
|
||
iCol2 = 1;
|
||
pLayerRec->close();
|
||
pLayertable->close();
|
||
}
|
||
else
|
||
pLayertable->close();
|
||
|
||
|
||
OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe->assertWriteEnabled();
|
||
iCol = pPipe->colorIndex();
|
||
XPoint ptTmp = pPipe->StartPoint();
|
||
nElevation = ptTmp.z/dMeter;
|
||
pPipe->setColorIndex(iCol2);
|
||
if(pPipe->isKindOf(TDbDoubleLinePipe::desc()) && dMeter < 10)
|
||
dMeter = 1000;
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
double nOldElevation = nElevation;
|
||
CString csTmp;
|
||
int iRet;
|
||
if(bNeed){
|
||
csTmp.Format(_T("\n请输入管线的标高(米)<%.3f>"), nElevation);
|
||
INITGET_BEG(0, _T("A"));
|
||
iRet = ads_getdist(ptPick, csTmp, &nElevation);
|
||
INITGET_END();
|
||
}
|
||
else{
|
||
csTmp.Format(_T("\n请输入管线的标高(米)<%.3f>"), nElevation);
|
||
iRet = ads_getdist(ptPick, csTmp, &nElevation);
|
||
}
|
||
|
||
if(iRet == RTNORM && nElevation < 100){
|
||
OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
|
||
// pPipe->assertWriteEnabled();
|
||
|
||
XPoint ptTmp = pPipe->StartPoint();
|
||
XPoint ptTmp2 = pPipe->EndPoint();
|
||
ptTmp.z = nElevation*dMeter;
|
||
ptTmp2.z = nElevation*dMeter;
|
||
|
||
pPipe->SetStartPoint(ptTmp);
|
||
pPipe->SetEndPoint(ptTmp2);
|
||
pPipe->setColorIndex(iCol);
|
||
|
||
DList<AcDbObjectId> lstAttachment;
|
||
pPipe->GetAttachments(lstAttachment);
|
||
int len = lstAttachment.Length();
|
||
for(int m=0;m<len;m++){
|
||
AcDbObjectId idTmp = *lstAttachment[m];
|
||
OPENOBJ_BEGIN(idTmp, AcDb::kForWrite, TDbPipeAttachment, pValve);
|
||
if(pValve){
|
||
XPoint ptLoc = pValve->GetLocation();
|
||
ptLoc.z = nElevation*dMeter;
|
||
pValve->SetLocation(ptLoc);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
}
|
||
else{
|
||
OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe->setColorIndex(iCol);
|
||
}
|
||
OPENOBJ_END();
|
||
// if(iRet == RTKWORD)
|
||
// return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void DynamicDrawStandPipe(Entity ent1, Entity ent2, XPoint ptPick)
|
||
{
|
||
XPoint ptTurn, ptStart, ptEnd, ptStart2, ptEnd2;
|
||
GetPipePoint(ent1, ptStart, ptEnd);
|
||
Entity entTmp;
|
||
CString csDwb = g_csDwbPath + _T("TwtSys");
|
||
XString xsTmp;
|
||
if(LoadDwbBlock(csDwb, _T("00000146"), xsTmp) != RTNORM) //扣弯
|
||
return;
|
||
double nElevation(0);
|
||
nElevation = ptStart.z;
|
||
|
||
AcGeVector3d vectBase(ptEnd.x - ptStart.x, ptEnd.y - ptStart.y, 0);
|
||
double nAng = ads_angle(ptStart, ptEnd);
|
||
g_nInsBlkRotate = vectBase.angleTo(AcGeVector3d(1,0,0));
|
||
g_nInsBlkRotate = nAng;
|
||
TBlockEdJig jig((const TCHAR*)xsTmp, ptPick, 50, vectBase);
|
||
jig.SetPrompt(_T("\n请指定扣弯方向<完成>:"));
|
||
if(jig.DoIt() == RTNORM){
|
||
int iQuadrant = jig.m_iQuadrant;
|
||
if(iQuadrant == 0 || iQuadrant == 3){
|
||
entTmp = ent1;
|
||
}
|
||
else if(iQuadrant == 1 || iQuadrant == 2){
|
||
entTmp = ent2;
|
||
}
|
||
TDbPipe *pPipe2 = new TDbPipe;
|
||
OPENOBJ_BEGIN(entTmp, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe2 = (TDbPipe *)pPipe->clone();
|
||
|
||
pPipe->assertWriteEnabled();
|
||
XPoint pt1, pt2;
|
||
pt1 = pPipe->StartPoint();
|
||
pt2 = pPipe->EndPoint();
|
||
pt1.z -= 1000;
|
||
pt2.z -= 1000;
|
||
pPipe->SetStartPoint(pt1);
|
||
pPipe->SetEndPoint(pt2);
|
||
}
|
||
OPENOBJ_END();
|
||
ptPick.z = nElevation;
|
||
pPipe2->SetStartPoint(ptPick);
|
||
ptPick.z = nElevation - 1000;
|
||
pPipe2->SetEndPoint(ptPick);
|
||
pPipe2->SetModelType(TPipeSys::kModel);
|
||
AddToCurrentSpace(pPipe2, Adesk::kTrue);
|
||
// CheckStandPipe(entTmp, ptPick, nElevation);
|
||
}
|
||
SHads_command(RTNONE);
|
||
g_nInsBlkRotate = 0;
|
||
}
|
||
|
||
|
||
extern CString GetVPipeLayerByIdx(int iLayer);
|
||
|
||
CString GetVPipeLayByPipe(Entity entRef)
|
||
{
|
||
CString csRet;
|
||
OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && !pPipe->IsVertical()){
|
||
TCHAR* szLay = pPipe->layer();
|
||
int idx = GetPipeLayerIdxByName(szLay);
|
||
csRet = szLay;//sr 2010.1.6 改正，把扣弯图层直接改为管线图层，不影响立管排序
|
||
// csRet = GetVPipeLayerByIdx(idx);
|
||
if(pPipe->isKindOf(TDbDoubleLinePipe::desc()))
|
||
csRet = szLay;
|
||
delete [] szLay;
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
return csRet;
|
||
}
|
||
|
||
AcDbObjectId DoDrawStandPipe(Entity entRef, double nEle1, double nEle2, XPoint ptPick)
|
||
{
|
||
if(fabs(nEle1 - nEle2) < 0.01){
|
||
adsout << _T("\n立管顶标高等于底标高！");
|
||
return NULL;
|
||
}
|
||
TDbPipe *pPipe2 = new TDbPipe;
|
||
OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe2 = (TDbPipe *)pPipe->clone();
|
||
}
|
||
OPENOBJ_END();
|
||
pPipe2->setLinetype(_T("CONTINUOUS"));
|
||
CString csLay = GetVPipeLayByPipe(entRef);
|
||
InitPipeLayer(csLay);
|
||
ptPick.z = nEle1;
|
||
pPipe2->SetStartPoint(ptPick);
|
||
ptPick.z = nEle2;
|
||
pPipe2->SetEndPoint(ptPick);
|
||
pPipe2->SetBulge(0.0); // 清除弧度，以免克隆实体来自弧管，造成错误 cet 2013.3.15 add
|
||
|
||
pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);
|
||
if(!g_bStandPipeArc)//传统扣弯
|
||
pPipe2->SetRadiusIn(-2);
|
||
if(csLay != _T("")) //双线水管没有立管图层
|
||
pPipe2->setLayer(csLay);
|
||
pPipe2->SetModelType(TPipeSys::kModel);
|
||
AcDbObjectId id = AddToCurrentSpace(pPipe2, Adesk::kTrue);
|
||
return id;
|
||
}
|
||
|
||
//判断1个点，是否在管线上。 不考虑斜管，只要投影在管线上就算
|
||
BOOL IsPtOnPipe(XPoint pt, Entity ent)
|
||
{
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pt.z = 0;
|
||
AcGePoint3d p1 = pt;
|
||
AcGePoint3d p2;
|
||
TDbPipe *pNewPipe = ClonePipe(pPipe);
|
||
pNewPipe->StartPoint().z = 0;
|
||
pNewPipe->EndPoint().z = 0;
|
||
//把管线放平
|
||
AcDbCurve *pCurve = pNewPipe->AsAcDbCurve();
|
||
delete pNewPipe;
|
||
pCurve->getClosestPointTo(p1,p2);
|
||
delete pCurve;
|
||
|
||
double dDist = ads_distance(XPoint(p1), XPoint(p2));
|
||
if(dDist < 0.001){
|
||
pt = p2;
|
||
return TRUE;
|
||
}
|
||
else
|
||
return FALSE;
|
||
}
|
||
OPENOBJ_END();
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
void GetPipeByPt(XPoint ptPick, PickSet &ss)
|
||
{
|
||
RBList rbMask = ads_buildlist( -4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
|
||
//因为考虑到搜索遮挡管线，所以把选择框放大，有可能多选不必要的管线，例如：2平行管线, 不同系统的管线
|
||
GetPointPickSet(ptPick, ss, rbMask, int(g_nBreakPipeWidth*DocGetPScale()));
|
||
int len = ss.Length();
|
||
if(ss.Length() > 1){
|
||
long len = ss.Length();
|
||
BOOL bEqualHeight = TRUE;
|
||
BOOL bDiffentSys = FALSE;
|
||
double nEleTmp = -9999;
|
||
PickSet ssDel(SS_FREE);
|
||
TPipeSys::SysType sys0=TPipeSys::kUnknownSys;
|
||
for(long j=0;j<len;j++){
|
||
Entity entTmp = ss[j];
|
||
TPipeSys::SysType sys = GetPipeSys(entTmp);
|
||
if(sys != sys0 && sys0 != TPipeSys::kUnknownSys){
|
||
bDiffentSys = TRUE;
|
||
break;
|
||
}
|
||
sys0 = sys;
|
||
if(IsPipeVertical(entTmp)){
|
||
ssDel += entTmp;
|
||
continue;
|
||
}
|
||
XPoint ptS, ptE;
|
||
GetPipePoint(entTmp, ptS, ptE);
|
||
if(nEleTmp < -9998)
|
||
nEleTmp = ptS.z;
|
||
if(fabs(nEleTmp - ptS.z) > 0.01){
|
||
bEqualHeight = FALSE;
|
||
continue;
|
||
}
|
||
}
|
||
if(bDiffentSys){//搜索出不同系统的管线
|
||
GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
|
||
len = ss.Length();
|
||
return;
|
||
}
|
||
ss -= ssDel;
|
||
if(bEqualHeight){//如果所有被选管线等高，缩小框选范围
|
||
GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
|
||
if(ss.Length() > 1){
|
||
double nDist(-1);
|
||
Entity ent2;
|
||
for(j=0;j<len;j++){
|
||
Entity entTmp = ss[j];
|
||
XPoint ptS, ptE, ptTmp;
|
||
GetPipePoint(entTmp, ptS, ptE);
|
||
XLine line(ptS, ptE);
|
||
ptPick.Project(&line, ptTmp);
|
||
double nTmp = ads_distance(ptTmp, ptPick);
|
||
if(nTmp > 0.001 && (nDist < 0 || nTmp < nDist)){
|
||
nDist = nTmp;
|
||
ent2 = entTmp;
|
||
}
|
||
}
|
||
if(!!ent2){
|
||
ss.Free();
|
||
ss+=ent2;
|
||
}
|
||
}
|
||
}
|
||
else{
|
||
len = ss.Length();
|
||
if(len == 2){//如果选择有2个，且平行， 缩小框选范围
|
||
Entity ent1 = ss[0L];
|
||
Entity ent2 = ss[1L];
|
||
if(Is2PipeParallel(ent1, ent2))
|
||
GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
|
||
}
|
||
else if(len == 3){//如果选择有3个，且平行， 缩小框选范围
|
||
Entity ent1 = ss[0L];
|
||
Entity ent2 = ss[1L];
|
||
Entity ent3 = ss[2L];
|
||
if(Is2PipeParallel(ent1, ent2) && Is2PipeParallel(ent1, ent3))
|
||
GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//选择2管线交叉处插入扣弯
|
||
void DrawStandPipeBy2PipeInter()
|
||
{
|
||
RBList rbMask = ads_buildlist( -4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
Entity ent1, ent2;
|
||
if(SelectEntity(_T("\n请选择1根管线:<退出>"), ent1, rbMask) != RTNORM)
|
||
return;
|
||
if(SelectEntity(_T("\n请选择另1根管线:<退出>"), ent2, rbMask) != RTNORM)
|
||
return;
|
||
|
||
|
||
TPipeSys::SysType sys1, sys2;
|
||
XPoint ptStart1, ptStart2;
|
||
XLine line1, line2;
|
||
OPENOBJ_BEGIN(ent1, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && !pPipe->IsVertical()){
|
||
ptStart1 = pPipe->StartPoint();
|
||
sys1 = pPipe->GetSysType();
|
||
line1 = pPipe->GetLine();
|
||
}
|
||
OPENOBJ_END();
|
||
OPENOBJ_BEGIN(ent2, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && !pPipe->IsVertical()){
|
||
ptStart2 = pPipe->StartPoint();
|
||
sys2 = pPipe->GetSysType();
|
||
line2 = pPipe->GetLine();
|
||
}
|
||
OPENOBJ_END();
|
||
if(fabs(ptStart1.z - ptStart2.z) < 0.001){
|
||
adsout << _T("\n2根管线高度相同，无法插入扣弯");
|
||
return;
|
||
}
|
||
if(sys1 != sys2){
|
||
adsout << _T("\n2根管线系统不一致，无法插入扣弯");
|
||
return;
|
||
}
|
||
line1.EndPoint().z = 0;
|
||
line1.StartPoint().z = 0;
|
||
line2.EndPoint().z = 0;
|
||
line2.StartPoint().z = 0;
|
||
|
||
XPoint ptInt;
|
||
int ret = line1.Intersection(&line2, ptInt);
|
||
if(ret == 1)
|
||
DoDrawStandPipe(ent1, ptStart1.z, ptStart2.z, ptInt);
|
||
}
|
||
|
||
void DrawStandPipeBy2Pipe()
|
||
{
|
||
RBList rbMask = ads_buildlist( -4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
|
||
Entity entSel, entLast;
|
||
XPoint ptPick, ptPipeS, ptPipeE;
|
||
int nOsMode=0;
|
||
xg_getvar(_T("OSMODE"), &nOsMode);
|
||
nOsMode &= ~0x4000;
|
||
nOsMode |= OS_INT|OS_NEA|OS_END|OS_INS;
|
||
XPushVar<int> vOsMode2(_T("OSMODE"), nOsMode);
|
||
if(ads_getpoint(NULL, _T("\n请点取插入扣弯的位置<选择2管线交叉处插入扣弯>:"), ptPick) != RTNORM){
|
||
DrawStandPipeBy2PipeInter();
|
||
return;
|
||
}
|
||
double dMeter(1);
|
||
if(!DocGetMeterUnitDraw())
|
||
dMeter = 1000;
|
||
|
||
PickSet ss(SS_FREE);
|
||
GetPipeByPt(ptPick, ss);
|
||
|
||
// cet 2013.3.15 add 过滤掉不经过ptPick的管线
|
||
PickSet ssDel(SS_FREE);
|
||
int nNum = ss.Length();
|
||
XPoint ptTemp = Ucs2Wcs(ptPick);
|
||
ptTemp.z = 0.0;
|
||
XCurveSegment seg;
|
||
XPoint ptPrj;
|
||
for (long i = 0; i < nNum; ++i)
|
||
{
|
||
OPENOBJ_BEGIN(ss[i], AcDb::kForRead, TDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
seg = pPipe->GetCurve();
|
||
seg.SetElevation(0.0);
|
||
seg.ProjectToMe(ptTemp, ptPrj);
|
||
if (ptTemp.Distance(ptPrj) > 0.001)
|
||
{
|
||
ssDel += ss[i];
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
ss -= ssDel;
|
||
|
||
int len1 = ss.Length();
|
||
//ptPick = Ucs2Wcs(ptPick);
|
||
|
||
|
||
if(ss.Length() == 1){
|
||
entSel = ss[0L];
|
||
if(IsPipeVertical(entSel))
|
||
return;
|
||
XPoint ptWcsPick = Ucs2Wcs(ptPick);
|
||
if(!IsPtOnPipe(ptWcsPick, entSel))
|
||
return;
|
||
GetPipePoint(entSel, ptPipeS, ptPipeE);//打断管线
|
||
if(ads_distance(ptWcsPick, ptPipeS) < 0.1 || ads_distance(ptWcsPick, ptPipeE) < 0.1 ){
|
||
CString csTmp;
|
||
double nElevation = ptPipeS.z;
|
||
csTmp.Format(_T("\n请输入竖管线的另一标高(米)，当前标高＝%.3f<退出>"), nElevation/dMeter);
|
||
ads_getdist(ptPick, csTmp, &nElevation);
|
||
if(ptPick.z == nElevation)
|
||
return;
|
||
DoDrawStandPipe(entSel, nElevation*dMeter, ptWcsPick.z, ptWcsPick);
|
||
return;
|
||
}
|
||
BreakEntity(entSel, ptPick, ptPick);
|
||
entLast.GetLast();
|
||
|
||
//以下目的是让新管线更新节点，而又不重新连接到一起
|
||
OPENOBJ_BEGIN(entLast, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe->assertWriteEnabled();
|
||
pPipe->SetDnDiameter(pPipe->GetDnDiameter()+1);//把管径＋1，2断管就不会连接
|
||
if(pPipe->isKindOf(TDbDoubleLinePipe::desc()) && dMeter < 10)
|
||
dMeter = 1000;
|
||
}
|
||
else
|
||
{
|
||
adsout << _T("距离太短，无法打断！");
|
||
return;
|
||
}
|
||
OPENOBJ_END();
|
||
TPipePerDocData *pData = GetCurPipeDocData();
|
||
pData->ApplyUpdates();
|
||
|
||
double nElevation(0), nElevation2(0);
|
||
DoModifyPipeEle(entSel, ptPick, nElevation, TRUE);
|
||
|
||
//把管径恢复
|
||
OPENOBJ_BEGIN(entLast, AcDb::kForWrite, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe->assertWriteEnabled();
|
||
pPipe->SetDnDiameter(pPipe->GetDnDiameter()-1);
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
DoModifyPipeEle(entLast, ptPick, nElevation2, FALSE);
|
||
|
||
|
||
ptPick = Ucs2Wcs(ptPick);
|
||
if(fabs(nElevation - nElevation2) > 0.001){
|
||
TDbPipe *pPipe2 = new TDbPipe;
|
||
OPENOBJ_BEGIN(entLast, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe){
|
||
pPipe2 = (TDbPipe *)pPipe->clone();
|
||
}
|
||
OPENOBJ_END();
|
||
CString csLay = GetVPipeLayByPipe(entLast);
|
||
InitPipeLayer(csLay);
|
||
|
||
pPipe2->assertWriteEnabled();
|
||
pPipe2->setLinetype(_T("CONTINUOUS"));
|
||
ptPick.z = nElevation*dMeter;
|
||
pPipe2->SetStartPoint(ptPick);
|
||
ptPick.z = nElevation2*dMeter;
|
||
pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);
|
||
|
||
//pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxBySys(pPipe2->GetSysType())]);
|
||
pPipe2->SetEndPoint(ptPick);
|
||
pPipe2->setLayer(csLay);
|
||
pPipe2->SetModelType(TPipeSys::kModel);
|
||
if(!g_bStandPipeArc)//传统扣弯
|
||
pPipe2->SetRadiusIn(-2);
|
||
AddToCurrentSpace(pPipe2, Adesk::kTrue);
|
||
}
|
||
}
|
||
else if(ss.Length() == 2){ //处理遮挡扣弯的问题
|
||
XPoint p1, p2, p3, p4, p5;
|
||
GetPipePoint(ss[0L], p1, p2);
|
||
GetPipePoint(ss[1L], p3, p4);
|
||
if(fabs(p1.z - p3.z) < 0.01){ //2管线等高
|
||
double nElevation(0), nElevation2(0);
|
||
DoModifyPipeEle(ss[0L], ptPick, nElevation, FALSE);
|
||
p1.z = nElevation*dMeter;
|
||
DoModifyPipeEle(ss[1L], ptPick, nElevation2, FALSE);
|
||
p3.z = nElevation2*dMeter;
|
||
}
|
||
// cet 2011.5.17 modify 未考虑弧管
|
||
// XLine l1(p1, p2);
|
||
// XLine l2(p3, p4);
|
||
// l1.EndPoint().z = 0;
|
||
// l1.StartPoint().z = 0;
|
||
// l2.EndPoint().z = 0;
|
||
// l2.StartPoint().z = 0;
|
||
// l1.Intersection(&l2, p5);
|
||
// if(!p5 && Is2LineOnLine(l1, l2)){
|
||
// if(l1.StartPoint() == l2.StartPoint())
|
||
// p5 = l1.StartPoint();
|
||
// else if(l1.EndPoint() == l2.StartPoint())
|
||
// p5 = l1.EndPoint();
|
||
// else if(l1.StartPoint() == l2.EndPoint())
|
||
// p5 = l1.StartPoint();
|
||
// else if(l1.EndPoint() == l2.EndPoint())
|
||
// p5 = l1.EndPoint();
|
||
// }
|
||
double dBulge1 = 0.0, dBulge2 = 0.0;
|
||
OPENOBJ_BEGIN(ss[0L], AcDb::kForRead, TDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
dBulge1 = pPipe->GetBulge();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
OPENOBJ_BEGIN(ss[1L], AcDb::kForRead, TDbPipe, pPipe);
|
||
if (pPipe != NULL)
|
||
{
|
||
dBulge2 = pPipe->GetBulge();
|
||
}
|
||
OPENOBJ_END();
|
||
XCurveSegment seg1(p1, p2, dBulge1), seg2(p3, p4, dBulge2);
|
||
seg1.StartPoint().z = 0;
|
||
seg1.EndPoint().z = 0;
|
||
seg2.StartPoint().z = 0;
|
||
seg2.EndPoint().z = 0;
|
||
seg1.Intersection(seg2, p5, XPoint());
|
||
if (!p5)
|
||
{
|
||
if(seg1.StartPoint() == seg2.StartPoint())
|
||
{
|
||
p5 = seg1.StartPoint();
|
||
}
|
||
else if(seg1.EndPoint() == seg2.StartPoint())
|
||
{
|
||
p5 = seg1.EndPoint();
|
||
}
|
||
else if(seg1.StartPoint() == seg2.EndPoint())
|
||
{
|
||
p5 = seg1.StartPoint();
|
||
}
|
||
else if(seg1.EndPoint() == seg2.EndPoint())
|
||
{
|
||
p5 = seg1.EndPoint();
|
||
}
|
||
}
|
||
|
||
if(!!p5 && fabs(p1.z - p3.z) > 0.01){
|
||
DoDrawStandPipe(ss[0L], p1.z, p3.z, p5);
|
||
}
|
||
}
|
||
else if(ss.Length() > 2){
|
||
double nHigh(0), nLow(0);
|
||
XPoint ptInt;
|
||
for(long j=0;j<ss.Length();j++){
|
||
XPoint p1, p2, ptInt2;
|
||
Entity entTmp = ss[j];
|
||
if(IsPipeVertical(entTmp)){
|
||
ptInt = XPoint();
|
||
break;
|
||
}
|
||
GetPipePoint(entTmp, p1, p2);
|
||
if(nHigh < p1.z || fabs(nHigh) < 0.01)
|
||
nHigh = p1.z;
|
||
if(nLow > p1.z || fabs(nLow) < 0.01)
|
||
nLow = p1.z;
|
||
p1.z = 0;
|
||
p2.z = 0;
|
||
ptPick.z = 0;
|
||
double nDist2 = ads_distance(ptPick, p1);
|
||
double nDist3 = ads_distance(ptPick, p2);
|
||
if(nDist2 < 0.01)
|
||
ptInt2 = p1;
|
||
if(nDist3 < 0.01)
|
||
ptInt2 = p2;
|
||
if(!ptInt)
|
||
ptInt = ptInt2;
|
||
// else if(ptInt2 != ptInt){
|
||
// ptInt = XPoint();
|
||
// break;
|
||
// }
|
||
}
|
||
if(!!ptInt){
|
||
DoDrawStandPipe(ss[0L], nHigh, nLow, ptInt);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
//***************************************************************************************************
|
||
// 立管布置
|
||
//***************************************************************************************************
|
||
bool IsNumberic(const CString &sText);
|
||
//cet 2013.1.9 add 考虑楼号
|
||
//int GetCurSerial(const TCHAR* szLay)
|
||
int GetCurSerial(const TCHAR* szLay, const CString &sFloorNum, PickSet &ss)
|
||
{
|
||
long len = ss.Length();
|
||
int iRet(0);
|
||
for(long i=0;i<len;i++){
|
||
Entity ent = ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && pPipe->IsVertical()){
|
||
// cet 2013.1.9 add 考虑楼号
|
||
CString sBuildingSerial = ReadXdata(ent, _T("BUILDING-SERIAL"));
|
||
if (sBuildingSerial.Compare(sFloorNum) != 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
CString csSerial = ReadXdata(ent, _T("PIPE-SERIAL"));
|
||
// cet 2013.3.13 add 排除非纯数字
|
||
if (!IsNumberic(csSerial))
|
||
{
|
||
continue;
|
||
}
|
||
if(_ttoi(csSerial) > iRet)
|
||
iRet = _ttoi(csSerial);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
return iRet;
|
||
}
|
||
|
||
// cet 2013.3.12 add 是否为数字字符串
|
||
bool IsNumberic(const CString &sText)
|
||
{
|
||
// 空串
|
||
if (sText.IsEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 依次检查字符
|
||
int nNum = sText.GetLength();
|
||
for(int i = 0; i < nNum; ++i)
|
||
{
|
||
int nCh = sText.GetAt(i);
|
||
// 非数字(0-9)
|
||
if (!_istdigit(nCh))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// cet 2013.3.12 add 分解字符串
|
||
void SplitString(const CString &sText, std::list<CString> &lstStrs)
|
||
{
|
||
lstStrs.clear();
|
||
// 空串
|
||
if (sText.IsEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 只有一个字符
|
||
int nLen = sText.GetLength();
|
||
if (nLen == 1)
|
||
{
|
||
lstStrs.push_back(sText);
|
||
return;
|
||
}
|
||
|
||
CString sTemp = sText.GetAt(nLen - 1);
|
||
for (int i = nLen - 2; i >= 0; --i)
|
||
{
|
||
TCHAR nCh = sText.GetAt(i);
|
||
if (_istdigit(nCh)) // 数字
|
||
{
|
||
TCHAR nPreCh = sText.GetAt(i + 1);
|
||
if (_istdigit(nPreCh)) // 上一个字符为数字
|
||
{
|
||
sTemp.Insert(0, nCh);
|
||
}
|
||
else
|
||
{
|
||
lstStrs.push_back(sTemp);
|
||
sTemp = nCh;
|
||
}
|
||
}
|
||
else if (_istalpha(nCh)) // 字母
|
||
{
|
||
TCHAR nPreCh = sText.GetAt(i + 1);
|
||
if (_istalpha(nPreCh)) // 上一个字符为字母
|
||
{
|
||
sTemp.Insert(0, nCh);
|
||
}
|
||
else
|
||
{
|
||
lstStrs.push_back(sTemp);
|
||
sTemp = nCh;
|
||
}
|
||
}
|
||
else // 非数字字母
|
||
{
|
||
TCHAR nPreCh = sText.GetAt(i + 1);
|
||
if (!_istalpha(nPreCh) && !_istdigit(nPreCh)) // 上一个字符为非数字字母
|
||
{
|
||
sTemp.Insert(0, nCh);
|
||
}
|
||
else
|
||
{
|
||
lstStrs.push_back(sTemp);
|
||
sTemp = nCh;
|
||
}
|
||
}
|
||
}
|
||
lstStrs.push_back(sTemp);
|
||
}
|
||
|
||
// cet 2013.3.12 add 纯字母递增, 返回值表示是否进位, sSerial完全有字母组成
|
||
bool IncreaseAlpha(CString &sSerial)
|
||
{
|
||
CString sTemp = sSerial;
|
||
bool bCarry = false;
|
||
int nLen = sSerial.GetLength();
|
||
for (int i = nLen - 1; i >= 0; --i)
|
||
{
|
||
TCHAR ch = sSerial.GetAt(i);
|
||
if (_istupper(ch)) // 大写字母
|
||
{
|
||
if (ch + 1 <= _T('Z'))
|
||
{
|
||
sTemp.SetAt(i, ch + 1);
|
||
bCarry = false;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
int nDiff = ch - _T('Z');
|
||
sTemp.SetAt(i, _T('A') + nDiff);
|
||
bCarry = true;
|
||
}
|
||
}
|
||
else // 小写字母
|
||
{
|
||
if (ch + 1 <= _T('z'))
|
||
{
|
||
sTemp.SetAt(i, ch + 1);
|
||
bCarry = false;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
int nDiff = ch - _T('z');
|
||
sTemp.SetAt(i, _T('a') + nDiff);
|
||
bCarry = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
sSerial = sTemp;
|
||
return bCarry;
|
||
}
|
||
|
||
// cet 2013.3.13 add 区间内是否存在数字或字母
|
||
bool IsExistDigitOrLetter(std::list<CString>::iterator itBegin, std::list<CString>::iterator itEnd)
|
||
{
|
||
CString sTemp;
|
||
while(itBegin != itEnd)
|
||
{
|
||
sTemp = *itBegin;
|
||
++itBegin;
|
||
if (sTemp.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TCHAR ch = sTemp.GetAt(0);
|
||
// 数字或字母
|
||
if (_istdigit(ch) || _istalpha(ch))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// cet 2013.3.12 add 递增编号
|
||
CString IncreaseSerial(const CString &sSerial)
|
||
{
|
||
CString sRet;
|
||
if (IsNumberic(sSerial)) // 纯数字
|
||
{
|
||
int nNum = _ttoi(sRet);
|
||
sRet.Format(_T("%d"), nNum + 1);
|
||
}
|
||
else
|
||
{
|
||
// 拆分字符串
|
||
std::list<CString> lstStrs;
|
||
SplitString(sSerial, lstStrs);
|
||
// 递增字符串
|
||
std::list<CString>::iterator it, itTemp, itEnd = lstStrs.end();
|
||
CString sTemp;
|
||
for (it = lstStrs.begin(); it != itEnd; ++it)
|
||
{
|
||
sTemp = *it;
|
||
TCHAR ch = sTemp.GetAt(0);
|
||
if (_istdigit(ch)) // 数字
|
||
{
|
||
int nNum = _ttoi(sTemp);
|
||
sTemp.Format(_T("%d"), nNum + 1);
|
||
*it = sTemp;
|
||
break;
|
||
}
|
||
else if (_istalpha(ch)) // 字符
|
||
{
|
||
bool bCarry = IncreaseAlpha(sTemp);
|
||
if (!bCarry) // 不需要进位，计算到此为止
|
||
{
|
||
*it = sTemp;
|
||
break;
|
||
}
|
||
|
||
itTemp = it;
|
||
++itTemp;
|
||
if (IsExistDigitOrLetter(itTemp, itEnd)) // 后续字符串可处理进位
|
||
{
|
||
*it = sTemp;
|
||
continue;;
|
||
}
|
||
|
||
// 在本字符串中处理进位
|
||
if (_istupper(ch)) // 大小字母
|
||
{
|
||
sTemp.Insert(0, _T("A"));
|
||
}
|
||
else // 小写字母
|
||
{
|
||
sTemp.Insert(0, _T("a"));
|
||
}
|
||
*it = sTemp;
|
||
}
|
||
}
|
||
|
||
std::list<CString>::reverse_iterator itR, itREnd = lstStrs.rend();
|
||
for (itR = lstStrs.rbegin(); itR != itREnd; ++itR)
|
||
{
|
||
sRet += *itR;
|
||
}
|
||
}
|
||
return sRet;
|
||
}
|
||
|
||
// cet 2013.3.12 add 递增字符串,sText表示递增的格式字符串
|
||
CString GetCurSerial(const CString &sLayerName, const CString &sFloorNum, const CString &sText, PickSet &ss)
|
||
{
|
||
CString sRet = sText;
|
||
if (IsNumberic(sText)) // 纯数字字符串
|
||
{
|
||
int nNum = GetCurSerial(sLayerName, sFloorNum, ss);
|
||
sRet.Format(_T("%d"), nNum + 1);
|
||
}
|
||
else
|
||
{
|
||
// 获得同图层立管的编号
|
||
std::vector<CString> vecSerials;
|
||
long nLen = ss.Length();
|
||
CString sTemp;
|
||
for(long i = 0; i < nLen; i++)
|
||
{
|
||
Entity ent = ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
|
||
if(pPipe && pPipe->IsVertical())
|
||
{
|
||
// 考虑楼号
|
||
CString sBuildingSerial = ReadXdata(ent, _T("BUILDING-SERIAL"));
|
||
if (sBuildingSerial.Compare(sFloorNum) != 0)
|
||
{
|
||
continue;
|
||
}
|
||
sTemp = ReadXdata(ent, _T("PIPE-SERIAL"));
|
||
vecSerials.push_back(sTemp);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
std::vector<CString>::iterator itBegin = vecSerials.begin(), itEnd = vecSerials.end();
|
||
std::vector<CString>::iterator it;
|
||
while(true)
|
||
{
|
||
it = std::find(itBegin, itEnd, sRet);
|
||
if (it == itEnd)
|
||
{
|
||
break;
|
||
}
|
||
sRet = IncreaseSerial(sRet);
|
||
}
|
||
}
|
||
return sRet;
|
||
}
|
||
|
||
void GetExternalBlockWallSeg(Entity entBlk, XCurveSegment &lCurve, XCurveSegment &rCurve, XPoint &ptResult)
|
||
{
|
||
XBlock myBlock(entBlk);
|
||
if(!myBlock.m_bInitSuccess)
|
||
return;
|
||
|
||
XCurveSegment seg;
|
||
// ads_point ptResult;
|
||
ads_name ent;
|
||
ads_matrix xformres;
|
||
resbuf* refstkres;
|
||
while (1) {
|
||
refstkres = NULL;
|
||
//直接选择子实体
|
||
int result = acedNEntSelP(_T("\n外部参照！请继续选择外部参照上墙线<退出>: "), ent, ptResult, 0, xformres, &refstkres);
|
||
if (refstkres != NULL)
|
||
acutRelRb(refstkres);
|
||
if (result == RTNORM) {
|
||
Entity entTemp = ent;
|
||
if(entTemp.Is(_T("ATS_WALL"))){
|
||
OPENOBJ_BEGIN(entTemp, AcDb::kForRead, TDbWall, pWall);
|
||
|
||
XPoint ptNew1, ptNew2;
|
||
if(pWall) {
|
||
pWall->GetSideCurve(lCurve, rCurve);
|
||
AcGePoint3d ptStart = lCurve.StartPoint();
|
||
ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
|
||
AcGePoint3d ptEnd = lCurve.EndPoint();
|
||
ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
|
||
XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
|
||
lCurve = line;
|
||
|
||
|
||
ptStart = rCurve.StartPoint();
|
||
ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
|
||
ptEnd = rCurve.EndPoint();
|
||
ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
|
||
XLine line2(asDblArray(ptStart), asDblArray(ptEnd), 1);
|
||
rCurve = line2;
|
||
return;
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else{
|
||
if(entTemp.Is(_T("LINE"))){
|
||
XCurveSegment seg1(entTemp);
|
||
lCurve = seg1;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
void DrawStandPipeCmd()
|
||
{
|
||
RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
|
||
|
||
CDrawStandPipeDlg dlg(1, acedGetAcadFrame());
|
||
{
|
||
CTemporaryResourceOverride vTemp;
|
||
dlg.Create(IDD_STAND_PIPE, acedGetAcadFrame());
|
||
}
|
||
dlg.ShowWindow(SW_SHOW);
|
||
acedGetAcadDwgView()->SetFocus();
|
||
XPoint ptOld;
|
||
|
||
int nOsMode=0;
|
||
xg_getvar(_T("OSMODE"), &nOsMode);
|
||
nOsMode &= ~0x4000;
|
||
nOsMode |= OS_INT|OS_END;
|
||
XPushVar<int> vOsMode2(_T("OSMODE"), nOsMode);
|
||
double dMeter(1);
|
||
if(!DocGetMeterUnitDraw())
|
||
dMeter = 1000;
|
||
|
||
while(1){
|
||
dlg.UpdateData(TRUE);
|
||
/* cet 2013.3.12 modify 支持非纯数字编号
|
||
// cet 2013.1.9 modify 考虑楼号
|
||
// int idx = GetCurSerial(dlg.GetLayer());
|
||
int idx = GetCurSerial(dlg.GetLayer(), dlg.m_csFloorName);
|
||
dlg.m_csName.Format(_T("%d"), idx+1);
|
||
*/
|
||
PickSet ssPipe(SS_FREE);
|
||
RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, dlg.GetLayer(), NULL);
|
||
ssPipe.Get(_T("X"), NULL, NULL, rbMask);
|
||
dlg.m_csName = GetCurSerial(dlg.GetLayer(), dlg.m_csFloorName, dlg.GetCurSerialFormat(), ssPipe);
|
||
dlg.SetPickset(ssPipe);
|
||
dlg.UpdateData(FALSE);
|
||
XPoint ptIns;
|
||
if(dlg.m_iPlace == 0){
|
||
xg_getvar(_T("VIEWCTR"), ptIns);
|
||
ptIns = Ucs2Wcs(ptIns);
|
||
TPipeEdJig jig(ptIns, g_nPipeRadius[dlg.m_iPipeType]);
|
||
jig.SetPrompt(_T("\n请指定立管的插入点[输入参考点(R)]<退出>:"));
|
||
jig.SetKeyword(_T("R V"));
|
||
int nKeyIdx;
|
||
if(!!ptOld)
|
||
jig.m_ptRef = ptOld;
|
||
int nRetCode=jig.DoIt(&nKeyIdx);
|
||
if(nRetCode==RTNORM) {
|
||
ptIns = jig.GetPickPoint();
|
||
ptOld = ptIns;
|
||
}
|
||
else if(nRetCode==RTKWORD){
|
||
if(nKeyIdx == 0){
|
||
if(ads_getpoint(NULL,_T("\n请输入参考点:"), ptIns) != RTNORM)
|
||
continue;
|
||
double nXDist(0), nYDist(0);
|
||
ptIns = Ucs2Wcs(ptIns);
|
||
ads_getdist(ptIns, _T("\n请输入X方向距参考点的距离(注意：反方向用负号)<0>:"), &nXDist);
|
||
ads_polar(ptIns, 0, nXDist, ptIns);
|
||
ads_getdist(ptIns, _T("\n请输入Y方向距参考点的距离(注意：反方向用负号)<0>:"), &nYDist);
|
||
ads_polar(ptIns, PI/2, nYDist, ptIns);
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
else{
|
||
dlg.DestroyWindow();
|
||
return;
|
||
}
|
||
}
|
||
else if(dlg.m_iPlace == 1 || dlg.m_iPlace == 2){
|
||
RBList rbMask = ads_buildlist( -4, _T("<or"),
|
||
-4, _T("<and"), RTDXF0, _T("LINE"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("ATS_WALL"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("<and"), RTDXF0, _T("INSERT"), 8, _T("*"), -4, _T("and>"),
|
||
-4, _T("or>"), NULL);
|
||
XPoint ptPick;
|
||
Entity entWall;
|
||
int ret(0);
|
||
INITGET_BEG(0, _T("R V"));
|
||
ret = SelectEntity1(_T("\n请拾取靠近立管的墙线<退出>"), entWall, ptPick, rbMask);
|
||
INITGET_END();
|
||
if(ret == RTNONE || ret == RTCAN || ret == RTERROR)
|
||
break;
|
||
else if(ret != RTNORM)
|
||
continue;
|
||
if(entWall.Is(_T("ATS_WALL")) || entWall.Is(_T("INSERT"))){
|
||
XCurveSegment lCurve, rCurve, SelCurve, TmpCurve;
|
||
BOOL bIsLeft = TRUE;
|
||
XPoint ptNew1, ptNew2;
|
||
if(entWall.Is(_T("ATS_WALL"))){
|
||
OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
|
||
if(pWall) {
|
||
pWall->GetSideCurve(lCurve, rCurve);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else{
|
||
GetExternalBlockWallSeg(entWall, lCurve, rCurve, ptPick);
|
||
}
|
||
|
||
lCurve.ProjectToMe(ptPick, ptNew1);
|
||
rCurve.ProjectToMe(ptPick, ptNew2);
|
||
if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2)){
|
||
SelCurve = lCurve;
|
||
TmpCurve = rCurve;
|
||
bIsLeft = TRUE;
|
||
}
|
||
else{
|
||
SelCurve = rCurve;
|
||
TmpCurve = lCurve;
|
||
bIsLeft = FALSE;
|
||
}
|
||
|
||
double nRotate(0), nRotate2(0);
|
||
if(!SelCurve.Is(CURVE_LINE)){
|
||
ads_prompt(_T("不能选择弧墙！请重新选择墙线"));
|
||
continue;
|
||
}
|
||
XPoint ptS = SelCurve.GetLine().StartPoint();
|
||
XPoint ptE = SelCurve.GetLine().EndPoint();
|
||
|
||
if(dlg.m_iPlace == 1){
|
||
XPoint ptOther;
|
||
//与哪边墙角近
|
||
if(ads_distance(ptPick, ptS) < ads_distance(ptPick, ptE)){
|
||
ptIns = ptS;
|
||
ptOther = TmpCurve.GetLine().StartPoint();
|
||
nRotate2 = ads_angle(ptS, ptE);
|
||
}
|
||
else{
|
||
ptIns = ptE;
|
||
ptOther = TmpCurve.GetLine().EndPoint();
|
||
nRotate2 = ads_angle(ptS, ptE) + PI;
|
||
}
|
||
AcGeVector2d v1(AcGePoint2d(ptPick[0],ptPick[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
|
||
AcGeVector2d v2(AcGePoint2d(ptOther[0],ptOther[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
|
||
v1.normalize();
|
||
v2.normalize();
|
||
if(v1.dotProduct(v2) > 0.0000001){
|
||
ads_prompt(_T("请重新选择墙线"));
|
||
continue;
|
||
}
|
||
if(bIsLeft)
|
||
nRotate = ads_angle(ptS, ptE);
|
||
else
|
||
nRotate = ads_angle(ptS, ptE) + PI;
|
||
|
||
ads_polar(ptIns, nRotate+(PI/2), g_nStandPipe2Wall, ptIns);
|
||
ads_polar(ptIns, nRotate2, g_nStandPipe2Wall, ptIns);
|
||
ptOld = ptIns;
|
||
}
|
||
else if(dlg.m_iPlace == 2){
|
||
if(rCurve.GetLength() < 0.01){//沿线布置
|
||
AcGeVector3d vectBase(lCurve.EndPoint().x - lCurve.StartPoint().x, lCurve.EndPoint().y - lCurve.StartPoint().y, 0);
|
||
TPipeEdJig jig(ptPick, g_nPipeRadius[dlg.m_iPipeType], vectBase);
|
||
jig.m_nLockAng = g_nStandPipe2Wall;
|
||
jig.SetKeyword(_T("D"));
|
||
jig.SetPrompt(_T("\n请指定立管的插入方向[距墙距离(D)]<退出>:"));
|
||
while(1){
|
||
int nKeyIdx;
|
||
int nRetCode=jig.DoIt(&nKeyIdx);
|
||
if(nRetCode==RTNORM){
|
||
ptIns = jig.m_ptPick;
|
||
break;
|
||
}
|
||
else if(nRetCode == RTKWORD){
|
||
ads_getdist(ptPick, _T("\n请输入立管距墙的距离:"), &g_nStandPipe2Wall);
|
||
jig.m_nLockAng = g_nStandPipe2Wall;
|
||
continue;
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
else{//沿墙布置
|
||
ptIns = ptPick;
|
||
if(bIsLeft)
|
||
nRotate = ads_angle(ptS, ptE);
|
||
else
|
||
nRotate = ads_angle(ptS, ptE) + PI;
|
||
ads_polar(ptIns, nRotate+(PI/2), g_nStandPipe2Wall, ptIns);
|
||
ptOld = ptIns;
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else{ //3.x版墙体
|
||
XWall myWall(entWall);
|
||
Entity entOther = myWall.GetNextWallLine(ptPick);
|
||
if(!entOther){//单线
|
||
XCurveSegment seg(entWall);
|
||
AcGeVector3d vectBase(seg.EndPoint().x - seg.StartPoint().x, seg.EndPoint().y - seg.StartPoint().y, 0);
|
||
TPipeEdJig jig(ptPick, g_nPipeRadius[dlg.m_iPipeType], vectBase);
|
||
jig.m_nLockAng = g_nStandPipe2Wall;
|
||
jig.SetKeyword(_T("D"));
|
||
jig.SetPrompt(_T("\n请指定立管的插入方向[距墙距离(D)]<退出>:"));
|
||
while(1){
|
||
int nKeyIdx;
|
||
int nRetCode=jig.DoIt(&nKeyIdx);
|
||
if(nRetCode==RTNORM){
|
||
ptIns = jig.m_ptPick;
|
||
break;
|
||
}
|
||
else if(nRetCode == RTKWORD){
|
||
ads_getdist(ptPick, _T("\n请输入立管距墙的距离:"), &g_nStandPipe2Wall);
|
||
jig.m_nLockAng = g_nStandPipe2Wall;
|
||
continue;
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
else{//3.x版墙体
|
||
XCurveSegment SelCurve(entWall);
|
||
XCurveSegment TmpCurve(entOther);
|
||
double angleWall = ads_angle(SelCurve.GetStartPoint(), SelCurve.GetEndPoint());
|
||
double angleWall1 = angleWall;
|
||
double angleWall2 = ads_angle(TmpCurve.GetStartPoint(), TmpCurve.GetEndPoint());
|
||
double dn = fabs(angleWall2 - angleWall1);
|
||
if(fabs(dn - PI) < 0.0001){ //逆向平行
|
||
XLine line(TmpCurve.EndPoint(), TmpCurve.StartPoint(), 1);
|
||
TmpCurve = line; //纠正过来
|
||
}
|
||
if(TmpCurve.OnWhichSide(ptPick) == OFFSET_RIGHT)
|
||
angleWall = angleWall + PI;
|
||
double nRotate2(0);
|
||
XPoint ptS = SelCurve.GetLine().StartPoint();
|
||
XPoint ptE = SelCurve.GetLine().EndPoint();
|
||
if(dlg.m_iPlace == 1){
|
||
XPoint ptOther;
|
||
if(ads_distance(ptPick, ptS) < ads_distance(ptPick, ptE)){
|
||
ptIns = ptS;
|
||
ptOther = TmpCurve.GetLine().StartPoint();
|
||
nRotate2 = ads_angle(ptS, ptE);
|
||
}
|
||
else{
|
||
ptIns = ptE;
|
||
ptOther = TmpCurve.GetLine().EndPoint();
|
||
nRotate2 = ads_angle(ptS, ptE) + PI;
|
||
}
|
||
AcGeVector2d v1(AcGePoint2d(ptPick[0],ptPick[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
|
||
AcGeVector2d v2(AcGePoint2d(ptOther[0],ptOther[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
|
||
v1.normalize();
|
||
v2.normalize();
|
||
if(v1.dotProduct(v2) > 0.0000001){
|
||
ads_prompt(_T("请重新选择墙线"));
|
||
continue;
|
||
}
|
||
ads_polar(ptIns, angleWall+(PI/2), g_nStandPipe2Wall, ptIns);
|
||
ads_polar(ptIns, nRotate2, g_nStandPipe2Wall, ptIns);
|
||
}
|
||
else if(dlg.m_iPlace == 2){
|
||
ptIns = ptPick;
|
||
ads_polar(ptIns, angleWall+(PI/2), g_nStandPipe2Wall, ptIns);
|
||
ptOld = ptIns;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
InitPipeLayer(dlg.GetLayer());
|
||
int iPipeIdx = GetPipeLayerIdxByName(dlg.GetLayer());
|
||
CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
|
||
CString csDnHead = GetDnByMat(csMat);
|
||
|
||
TDbPipe *pPipe=new TDbPipe;
|
||
|
||
PickSet ss(SS_FREE);
|
||
GetPointPickSet(ptIns, ss, rbMaskPipe, 50);
|
||
double len = ss.Length();
|
||
|
||
ptIns.z = dlg.m_nEleDown*dMeter;
|
||
pPipe->SetStartPoint(ptIns);
|
||
ptIns.z = dlg.m_nEleUp*dMeter;
|
||
pPipe->SetEndPoint(ptIns);
|
||
pPipe->setLinetype(_T("CONTINUOUS"));
|
||
pPipe->setLayer(dlg.GetLayer());
|
||
pPipe->SetSysType(dlg.GetPipeSysType());
|
||
pPipe->SetDnDiameter(_ttoi(dlg.m_csDn));
|
||
pPipe->SetModelType(TPipeSys::kModel);
|
||
pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
|
||
// pPipe->SetPipeWeight(dlg.GetPipeWeight());
|
||
pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
|
||
pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
|
||
pPipe->SetLabel(csDnHead);
|
||
if(g_bPipeDouble[iPipeIdx])
|
||
pPipe->SetRadiusIn(g_nPipeRadius[iPipeIdx] / 2);
|
||
else
|
||
{
|
||
if(!g_bStandPipeArc)//传统扣弯
|
||
pPipe->SetRadiusIn(-2);
|
||
}
|
||
pPipe->setColor(AcCmColor()); //随层
|
||
AcDbObjectId id = AddToCurrentSpace(pPipe, Adesk::kTrue);
|
||
|
||
CString csDim = g_csPipeDim[iPipeIdx] + _T("L");
|
||
|
||
if(!g_bIsPipeDimCir || g_bIsPipeDimCir == 3)
|
||
csDim += _T("-");
|
||
Entity entLast;
|
||
entLast.GetLast();
|
||
WriteXdata(entLast, _T("PIPE-SERIAL"), dlg.m_csName);
|
||
if(_tcsicmp(dlg.m_csFloorName, _T("")) != 0)
|
||
WriteXdata(entLast,_T("BUILDING-SERIAL"),dlg.m_csFloorName);
|
||
|
||
DoDimStandPipe(id, csDim, dlg.m_csName);
|
||
dlg.UpdateData(TRUE);
|
||
// cet 2013.3.12 modify 递增编号支持非纯数字
|
||
// dlg.m_csName.Format(_T("%d"), _ttoi(dlg.m_csName) + 1);
|
||
dlg.UpdateSerial();
|
||
dlg.UpdateData(FALSE);
|
||
}
|
||
|
||
dlg.DestroyWindow();
|
||
SHads_command(RTSTR, _T(".REDRAW"), RTNONE);
|
||
}
|
||
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CDrawStandPipeDlg dialog
|
||
|
||
extern BOOL GetLayerReMark(const TCHAR *szLayer, CString &sRemark);
|
||
|
||
IMPLEMENT_DYNAMIC(CDrawStandPipeDlg, CModelessDialog)
|
||
int CDrawStandPipeDlg::m_iPipeType = 0;
|
||
int CDrawStandPipeDlg::m_iPipeType2 = 0; // cet 2011.12.1 add
|
||
int CDrawStandPipeDlg::m_iPipeType3 = 9; // cet 2011.12.1 add
|
||
int CDrawStandPipeDlg::m_iPlace = 0;
|
||
int CDrawStandPipeDlg::m_iPos = 0;
|
||
CString CDrawStandPipeDlg::m_csDn = _T("-1");
|
||
CString CDrawStandPipeDlg::m_csName = _T("1");
|
||
CString CDrawStandPipeDlg::m_csEle = _T("0");
|
||
CString CDrawStandPipeDlg::m_csFloorName = _T("");
|
||
std::map<double, bool> CDrawStandPipeDlg::m_mapAngle; // cet 2012.3.15 add
|
||
DWORD CDrawStandPipeDlg::m_nSelSerialID = WM_USER + 1; // cet 2013.3.13 编号菜单默认选项
|
||
std::map<int, std::map<CString, CString> > CDrawStandPipeDlg::m_mapPipeSerial;
|
||
|
||
CDrawStandPipeDlg::CDrawStandPipeDlg(int iType, CWnd* pParent /*=NULL*/)
|
||
: CModelessDialog(CDrawStandPipeDlg::IDD, pParent)
|
||
{
|
||
//{{AFX_DATA_INIT(CDrawStandPipeDlg)
|
||
m_csDim1 = _T("J");
|
||
m_csDim2 = _T("RJ");
|
||
m_csDim3 = _T("RH");
|
||
m_csDim4 = _T("W");
|
||
m_csDim5 = _T("F");
|
||
m_csDim6 = _T("Y");
|
||
m_csDim7 = _T("Z");
|
||
m_csDim8 = _T("X");
|
||
m_csDim9 = _T("H");
|
||
m_nEleDown = 0;
|
||
m_nEleUp = 3;
|
||
m_csDim10 = _T("");
|
||
m_bLockAngle = FALSE;
|
||
//}}AFX_DATA_INIT
|
||
m_spinName.SetBase(1);
|
||
|
||
if(m_csDn == _T("-1"))
|
||
m_csDn = Itoa(g_iDefaultPipeDn);
|
||
m_iPipeMode = iType;
|
||
m_pMenu = NULL;
|
||
m_pMenuEle = NULL; // cet 2010.6.23 add
|
||
m_bEle = false; // cet 2010.6.23 add
|
||
m_pMenuAngle = NULL; // cet 2012.3.15 add
|
||
m_bSendCmdKeyToCAD = FALSE; // cet 2012.3.16 add
|
||
m_pMenuSerial = NULL; // cet 2013.3.13 add
|
||
m_bOpeningMenuSerial = false; // cet 2013.3.18 add
|
||
m_bInitDlg = false; // zxl 2013.10.17 add
|
||
}
|
||
|
||
CDrawStandPipeDlg::~CDrawStandPipeDlg()
|
||
{
|
||
if(::IsWindow(m_hWnd))
|
||
DestroyWindow();
|
||
|
||
if(m_pMenu != NULL) {
|
||
m_pMenu->DestroyMenu();
|
||
delete m_pMenu;
|
||
}
|
||
|
||
// 清除角度菜单 cet 2012.3.16 add
|
||
if (m_pMenuAngle != NULL)
|
||
{
|
||
m_pMenuAngle->DestroyMenu();
|
||
delete m_pMenuAngle;
|
||
}
|
||
|
||
// cet 2012.10.18 add
|
||
if (m_pMenuEle != NULL)
|
||
{
|
||
m_pMenuEle->DestroyMenu();
|
||
delete m_pMenuEle;
|
||
}
|
||
|
||
// cet 2013.3.13 add
|
||
if (m_pMenuSerial != NULL)
|
||
{
|
||
m_pMenuSerial->DestroyMenu();
|
||
delete m_pMenuSerial;
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::DoDataExchange(CDataExchange* pDX)
|
||
{
|
||
CModelessDialog::DoDataExchange(pDX);
|
||
//{{AFX_DATA_MAP(CDrawStandPipeDlg)
|
||
DDX_Control(pDX, IDC_COMBO_DN, m_comboDn);
|
||
DDX_Control(pDX, IDC_SPIN_NAME, m_spinName);
|
||
DDX_Text(pDX, IDC_STATIC_1, m_csDim1);
|
||
DDX_Text(pDX, IDC_STATIC_2, m_csDim2);
|
||
DDX_Text(pDX, IDC_STATIC_3, m_csDim3);
|
||
DDX_Text(pDX, IDC_STATIC_4, m_csDim4);
|
||
DDX_Text(pDX, IDC_STATIC_5, m_csDim5);
|
||
DDX_Text(pDX, IDC_STATIC_6, m_csDim6);
|
||
DDX_Text(pDX, IDC_STATIC_7, m_csDim7);
|
||
DDX_Text(pDX, IDC_STATIC_8, m_csDim8);
|
||
DDX_Text(pDX, IDC_STATIC_9, m_csDim9);
|
||
DDX_Text(pDX, IDC_EDIT_ELE_DOWN, m_nEleDown);
|
||
DDX_Text(pDX, IDC_EDIT_ELE_UP, m_nEleUp);
|
||
DDX_Text(pDX, IDC_STATIC_10, m_csDim10);
|
||
DDX_Text(pDX, IDC_EDIT_NAME, m_csName);
|
||
DDX_Radio(pDX, IDC_RADIO_PIPETYPE1, m_iPipeType2); // cet 2011.12.1 modify
|
||
DDX_Radio(pDX, IDC_RADIO_PLACE1, m_iPlace);
|
||
//DDX_CBString(pDX, IDC_COMBO_DN, m_csDn); cet 2012.8.30 del
|
||
DDX_Text(pDX, IDC_EDIT_ELEVATION, m_csEle);
|
||
DDX_Text(pDX, IDC_EDIT_FLOOR_NAME, m_csFloorName);
|
||
DDX_Radio(pDX, IDC_RADIO_POS1, m_iPos);
|
||
DDX_Check(pDX, IDC_CHECK_LOCKANGLE, m_bLockAngle);
|
||
//}}AFX_DATA_MAP
|
||
}
|
||
|
||
|
||
BEGIN_MESSAGE_MAP(CDrawStandPipeDlg, CModelessDialog)
|
||
//{{AFX_MSG_MAP(CDrawStandPipeDlg)
|
||
ON_WM_CLOSE()
|
||
ON_BN_CLICKED(IDC_RADIO_PLACE1, OnRadioPlace1)
|
||
ON_BN_CLICKED(IDC_RADIO_PLACE2, OnRadioPlace2)
|
||
ON_BN_CLICKED(IDC_RADIO_PLACE3, OnRadioPlace3)
|
||
ON_BN_CLICKED(IDC_BUTTON_SETTING, OnButtonSetting)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE1, OnRadioPipetype1)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE2, OnRadioPipetype2)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE3, OnRadioPipetype3)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE4, OnRadioPipetype4)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE5, OnRadioPipetype5)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE6, OnRadioPipetype6)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE7, OnRadioPipetype7)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE8, OnRadioPipetype8)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE9, OnRadioPipetype9)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE10, OnRadioPipetype10)
|
||
/* cet 2011.12.1 del
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE11, OnRadioPipetype11)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE12, OnRadioPipetype12)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE13, OnRadioPipetype13)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE14, OnRadioPipetype14)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE15, OnRadioPipetype15)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE16, OnRadioPipetype16)
|
||
ON_BN_CLICKED(IDC_RADIO_PIPETYPE17, OnRadioPipetype17)
|
||
*/
|
||
ON_BN_CLICKED(IDC_BUTTON_MENU, OnButtonMenu)
|
||
ON_BN_CLICKED(IDC_BTN_SERIAL, OnButtonSerial)
|
||
ON_BN_CLICKED(IDC_BUTTON_ANGLEMENU, OnButtonAngleMenu)
|
||
ON_WM_DESTROY()
|
||
ON_BN_CLICKED(IDC_CHECK_LOCKANGLE, OnCheckLockangle)
|
||
ON_BN_CLICKED(IDC_RADIO_POS1, OnRadioPos1)
|
||
ON_BN_CLICKED(IDC_RADIO_POS2, OnRadioPos2)
|
||
ON_BN_CLICKED(IDC_RADIO_POS3, OnRadioPos3)
|
||
ON_CBN_EDITCHANGE(IDC_COMBO_DN, OnEditChangeComboDn)
|
||
ON_CBN_SELCHANGE(IDC_COMBO_DN, OnSelchangeComboDn)
|
||
ON_EN_CHANGE(IDC_EDIT_FLOOR_NAME, OnEditChangeFloorName)
|
||
ON_MESSAGE(WM_ACAD_KEEPFOCUS, onAcadKeepFocus)
|
||
//}}AFX_MSG_MAP
|
||
END_MESSAGE_MAP()
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// CDrawStandPipeDlg message handlers
|
||
|
||
LONG_PTR CDrawStandPipeDlg::onAcadKeepFocus(UINT_PTR, LONG_PTR)
|
||
{
|
||
CWnd *pFoucsWnd = CDrawStandPipeDlg::GetFocus();
|
||
if (pFoucsWnd != NULL && (pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELEVATION || pFoucsWnd->GetDlgCtrlID() == 1001
|
||
|| pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_NAME || pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELE_DOWN
|
||
|| pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELE_UP || pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_FLOOR_NAME))
|
||
{
|
||
return TRUE;
|
||
}
|
||
CPoint pt;
|
||
GetCursorPos(&pt);
|
||
CRect rc;
|
||
GetWindowRect(&rc);
|
||
return (rc.PtInRect(pt) ? TRUE : FALSE);
|
||
}
|
||
|
||
BOOL CDrawStandPipeDlg::OnInitDialog()
|
||
{
|
||
CModelessDialog::OnInitDialog();
|
||
m_spinName.SetRange(1, 100);
|
||
CWnd *pWnd5 = GetDlgItem(IDC_STATIC_SET);
|
||
CWnd *pWnd6 = GetDlgItem(IDC_RADIO_PLACE1);
|
||
CWnd *pWnd3 = GetDlgItem(IDC_RADIO_PLACE2);
|
||
CWnd *pWnd4 = GetDlgItem(IDC_RADIO_PLACE3);
|
||
CWnd *pWnd9 = GetDlgItem(IDC_STATIC_NAME);
|
||
CWnd *pWnd12 = GetDlgItem(IDC_SPIN_NAME);
|
||
CWnd *pWnd10 = GetDlgItem(IDC_EDIT_ELEVATION);
|
||
CWnd *pWnd11 = GetDlgItem(IDC_EDIT_NAME);
|
||
CWnd *pWndM = GetDlgItem(IDC_BUTTON_MENU); // cet 2010.6.23 add
|
||
CWnd *pWnd13 = GetDlgItem(IDC_CHECK_LOCKANGLE); // cet 2011.7.27 add
|
||
CWnd *pWnd14 = GetDlgItem(IDC_STATIC_BOTTOMELE); // cet 2011.7.27 add
|
||
CWnd *pWnd15 = GetDlgItem(IDC_EDIT_ELE_DOWN); // cet 2011.7.27 add
|
||
CWnd *pWnd16 = GetDlgItem(IDC_BUTTON_ANGLEMENU); // cet 2012.3.15 add
|
||
CWnd *pWnd17 = GetDlgItem(IDC_BTN_SERIAL); // cet 2013.3.13 add
|
||
if(m_iPipeMode == 1){
|
||
SetWindowText(_T("立管"));
|
||
pWnd5->SetWindowText(_T("布置方式"));
|
||
pWnd6->SetWindowText(_T("任意布置"));
|
||
pWnd3->SetWindowText(_T("墙角布置"));
|
||
pWnd4->SetWindowText(_T("沿墙布置"));
|
||
m_iPlace = 0;
|
||
pWnd10->ShowWindow(SW_HIDE);
|
||
pWndM->ShowWindow(SW_HIDE); // cet 2010.6.23 add
|
||
pWnd13->ShowWindow(SW_HIDE); // cet 2011.7.27 add
|
||
pWnd16->ShowWindow(SW_HIDE); // cet 2012.3.15 add
|
||
InitMenuSerial(); // cet 2013.3.13 add
|
||
UpdateSpinVisible(); // cet 2013.3.13 add
|
||
}
|
||
else if(m_iPipeMode == 0){
|
||
CRegProperty regProp(GetRegLocation(), _T("TWT7"));
|
||
regProp.SetTopRootKey(HKEY_CURRENT_USER);
|
||
CString csMenu;
|
||
regProp.GetValue(_T("menu"), csMenu);
|
||
|
||
if(csMenu.Find(_T("OUT")) > -1 || csMenu.Find(_T("out")) > -1){
|
||
m_comboDn.ResetContent();
|
||
m_csDn = _T("200");
|
||
m_comboDn.AddString(_T("200"));
|
||
m_comboDn.AddString(_T("300"));
|
||
m_comboDn.AddString(_T("350"));
|
||
m_comboDn.AddString(_T("400"));
|
||
m_comboDn.AddString(_T("500"));
|
||
m_comboDn.AddString(_T("600"));
|
||
m_comboDn.AddString(_T("700"));
|
||
m_comboDn.AddString(_T("800"));
|
||
m_comboDn.AddString(_T("900"));
|
||
m_comboDn.AddString(_T("1000"));
|
||
}
|
||
SetWindowText(_T("管线"));
|
||
pWnd5->SetWindowText(_T("等标高管线交叉"));
|
||
pWnd6->SetWindowText(_T("生成四通"));
|
||
pWnd3->SetWindowText(_T("管线置上"));
|
||
pWnd4->SetWindowText(_T("管线置下"));
|
||
CWnd *pWnd1 = GetDlgItem(IDC_STATIC_NAME);
|
||
CWnd *pWnd2 = GetDlgItem(IDC_SPIN_NAME);
|
||
pWnd9->SetWindowText(_T("标高(m)："));
|
||
|
||
// cet 2010.6.23 add 修改标高编辑框的大小
|
||
int nWidth = 0, nHeight = 0;
|
||
CRect rec;
|
||
pWnd10->GetWindowRect(&rec);
|
||
pWnd10->GetParent()->ScreenToClient(&rec);
|
||
nWidth = rec.Width();
|
||
nHeight = rec.Height();
|
||
CPoint ptL = rec.TopLeft();
|
||
pWnd10->MoveWindow(ptL.x, ptL.y, nWidth * 2 / 3, nHeight);
|
||
|
||
pWnd10->ShowWindow(SW_SHOW);
|
||
pWnd11->ShowWindow(SW_HIDE);
|
||
pWnd12->ShowWindow(SW_HIDE);
|
||
pWnd14->ShowWindow(SW_HIDE); // cet 2011.7.27 add
|
||
pWnd15->ShowWindow(SW_HIDE); // cet 2011.7.27 add
|
||
pWnd17->ShowWindow(SW_HIDE); // cet 2013.3.13 add
|
||
m_spinName.SetBase(10);
|
||
CRect rect;
|
||
this->GetWindowRect(&rect);
|
||
// rect.bottom -= 78; cet 2011.7.27 modify
|
||
rect.bottom -= 52;
|
||
this->MoveWindow(&rect);
|
||
if(fabs(_tstof(m_csEle)) < 0.01)
|
||
m_csEle = _T("0");
|
||
InitAngleData(); // cet 2012.3.15 add
|
||
|
||
}
|
||
ResetShowRadio();
|
||
ResetRegion();
|
||
|
||
m_csDim1 = g_csPipeDim[0];
|
||
m_csDim2 = g_csPipeDim[1];
|
||
m_csDim3 = g_csPipeDim[2];
|
||
m_csDim4 = g_csPipeDim[3];
|
||
m_csDim5 = g_csPipeDim[4];
|
||
m_csDim6 = g_csPipeDim[5];
|
||
m_csDim7 = g_csPipeDim[6];
|
||
m_csDim8 = g_csPipeDim[7];
|
||
m_csDim9 = g_csPipeDim[8];
|
||
m_csDim10 = g_csPipeDim[m_iPipeType3];
|
||
UpdateData(FALSE);
|
||
// cet 2010.6.23 add
|
||
ReadWriteData();
|
||
UpdateData(FALSE);
|
||
// cet 2011.12.14 add 根据管线当前选择的低中高区设置标注文字
|
||
UpdateDimText();
|
||
// cet 2012.3.15 add 根据是否使用角度盘更新角度菜单可用性
|
||
if (m_iPipeMode == 0)
|
||
{
|
||
EnableAngleMenu(m_bLockAngle);
|
||
}
|
||
// 更新管径 cet 2012.8.30
|
||
UpdatePipeDn(FALSE);
|
||
m_bInitDlg = true; // zxl 2013.10.17 add
|
||
return TRUE;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::ResetShowRadio()
|
||
{
|
||
/* cet 2011.12.1 modify
|
||
//其他
|
||
CWnd *pWnd10 = GetDlgItem(IDC_RADIO_PIPETYPE10);
|
||
CWnd *pWnd11 = GetDlgItem(IDC_RADIO_PIPETYPE11);
|
||
CWnd *pWnd12 = GetDlgItem(IDC_RADIO_PIPETYPE12);
|
||
CWnd *pWnd13 = GetDlgItem(IDC_RADIO_PIPETYPE13);
|
||
CWnd *pWnd14 = GetDlgItem(IDC_RADIO_PIPETYPE14);
|
||
CWnd *pWnd15 = GetDlgItem(IDC_RADIO_PIPETYPE15);//其它
|
||
CWnd *pWnd16 = GetDlgItem(IDC_RADIO_PIPETYPE16);
|
||
CWnd *pWnd17 = GetDlgItem(IDC_RADIO_PIPETYPE17);
|
||
|
||
pWnd10->ShowWindow(SW_HIDE);
|
||
pWnd11->ShowWindow(SW_HIDE);
|
||
pWnd12->ShowWindow(SW_HIDE);
|
||
pWnd13->ShowWindow(SW_HIDE);
|
||
pWnd14->ShowWindow(SW_HIDE);
|
||
pWnd15->ShowWindow(SW_HIDE);
|
||
pWnd16->ShowWindow(SW_HIDE);
|
||
pWnd17->ShowWindow(SW_HIDE);
|
||
|
||
pWnd10->EnableWindow(FALSE);
|
||
pWnd11->EnableWindow(FALSE);
|
||
pWnd12->EnableWindow(FALSE);
|
||
pWnd13->EnableWindow(FALSE);
|
||
pWnd14->EnableWindow(FALSE);
|
||
pWnd15->EnableWindow(FALSE);
|
||
pWnd16->EnableWindow(FALSE);
|
||
pWnd17->EnableWindow(FALSE);
|
||
|
||
pWnd10->SetWindowText(g_csPipeName[0]);
|
||
pWnd11->SetWindowText(g_csPipeName[1]);
|
||
pWnd12->SetWindowText(g_csPipeName[2]);
|
||
pWnd13->SetWindowText(g_csPipeName[3]);
|
||
pWnd14->SetWindowText(g_csPipeName[4]);
|
||
pWnd16->SetWindowText(g_csPipeName[5]);
|
||
pWnd17->SetWindowText(g_csPipeName[6]);
|
||
|
||
if(m_iPipeType == 9)
|
||
{
|
||
pWnd10->EnableWindow(TRUE);
|
||
pWnd10->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 10)
|
||
{
|
||
pWnd11->EnableWindow(TRUE);
|
||
pWnd11->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 11)
|
||
{
|
||
pWnd12->EnableWindow(TRUE);
|
||
pWnd12->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 12)
|
||
{
|
||
pWnd13->EnableWindow(TRUE);
|
||
pWnd13->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 13)
|
||
{
|
||
pWnd14->EnableWindow(TRUE);
|
||
pWnd14->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 15)
|
||
{
|
||
pWnd16->EnableWindow(TRUE);
|
||
pWnd16->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(m_iPipeType == 16)
|
||
{
|
||
pWnd17->EnableWindow(TRUE);
|
||
pWnd17->ShowWindow(SW_SHOW);
|
||
}
|
||
else
|
||
{
|
||
pWnd15->EnableWindow(TRUE);
|
||
pWnd15->ShowWindow(SW_SHOW);
|
||
}
|
||
*/
|
||
CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10);
|
||
if (pWnd == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
std::vector<CString> vecPipeName;
|
||
GetPipeName(vecPipeName);
|
||
if (m_iPipeType3 == 9)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[0]);
|
||
}
|
||
else if (m_iPipeType3 == 10)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[1]);
|
||
}
|
||
else if (m_iPipeType3 == 11)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[2]);
|
||
}
|
||
else if (m_iPipeType3 == 12)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[3]);
|
||
}
|
||
else if (m_iPipeType3 == 13)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[4]);
|
||
}
|
||
else if (m_iPipeType3 == 14)
|
||
{
|
||
pWnd->SetWindowText(_T("其它管"));
|
||
}
|
||
else if (m_iPipeType3 == 15)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[5]);
|
||
}
|
||
else if (m_iPipeType3 == 16)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[6]);
|
||
}
|
||
else if (m_iPipeType3 == 29)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[7]);
|
||
}
|
||
else if (m_iPipeType3 == 30)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[8]);
|
||
}
|
||
else if (m_iPipeType3 == 31)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[9]);
|
||
}
|
||
else if (m_iPipeType3 == 32)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[10]);
|
||
}
|
||
else if (m_iPipeType3 == 33)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[11]);
|
||
}
|
||
else if (m_iPipeType3 == 34)
|
||
{
|
||
pWnd->SetWindowText(vecPipeName[12]);
|
||
}
|
||
|
||
CString sText;
|
||
pWnd->GetWindowText(sText);
|
||
if (sText.Find(_T("↓")) == -1)
|
||
{
|
||
sText+=_T("↓");
|
||
pWnd->SetWindowText(sText);
|
||
}
|
||
m_csDim10 = g_csPipeDim[m_iPipeType3]; // 更新下拉菜单当前项对应的标注文字
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnClose()
|
||
{
|
||
CModelessDialog::OnClose();
|
||
acedPostCommand(_T("\33\33"));
|
||
}
|
||
|
||
TPipeSys::SysType CDrawStandPipeDlg::GetPipeSysType()
|
||
{
|
||
UpdateData();
|
||
if(m_iPipeType == 0)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kFeedWater;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kFeedWater;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kFeedWater2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kFeedWater3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 1)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kHeatFeedWater;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kHeatFeedWater;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kHeatFeedWater2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kHeatFeedWater3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 2)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kHeatBackWater;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kHeatBackWater;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kHeatBackWater2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kHeatBackWater3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 3)
|
||
return TPipeSys::kDirtWater;
|
||
else if(m_iPipeType == 4)
|
||
return TPipeSys::kUselessWater;
|
||
else if(m_iPipeType == 5)
|
||
return TPipeSys::kRainWater;
|
||
else if(m_iPipeType == 6)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kUsedWater;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kUsedWater;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kUsedWater2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kUsedWater3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 7)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kFireFighting;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kFireFighting;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kFireFighting2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kFireFighting3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 8)
|
||
{
|
||
//cet 2011.12.6 modify
|
||
//return TPipeSys::kSprinkle;
|
||
if (m_iPos == 0)
|
||
{
|
||
return TPipeSys::kSprinkle;
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
return TPipeSys::kSprinkle2;
|
||
}
|
||
else
|
||
{
|
||
return TPipeSys::kSprinkle3;
|
||
}
|
||
}
|
||
else if(m_iPipeType == 9)
|
||
return TPipeSys::kCoagulate;
|
||
else if(m_iPipeType == 10)
|
||
return TPipeSys::kDrink;
|
||
else if(m_iPipeType == 11)
|
||
return TPipeSys::kPressDirt;
|
||
else if(m_iPipeType == 12)
|
||
return TPipeSys::kPressUseless;
|
||
else if(m_iPipeType == 13)
|
||
return TPipeSys::kPressRain;
|
||
else if(m_iPipeType == 14)
|
||
return TPipeSys::kOther;
|
||
else if(m_iPipeType == 15)
|
||
return TPipeSys::kCivilFeed;
|
||
else if(m_iPipeType == 16)
|
||
return TPipeSys::kCycleFeed;
|
||
else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
|
||
{
|
||
return TPipeSys::kUser3;
|
||
}
|
||
else if (m_iPipeType == 30)
|
||
{
|
||
return TPipeSys::kUser4;
|
||
}
|
||
else if (m_iPipeType == 31)
|
||
{
|
||
return TPipeSys::kUser5;
|
||
}
|
||
else if (m_iPipeType == 32)
|
||
{
|
||
return TPipeSys::kUser6;
|
||
}
|
||
else if (m_iPipeType == 33)
|
||
{
|
||
return TPipeSys::kUser7;
|
||
}
|
||
else if (m_iPipeType == 34)
|
||
{
|
||
return TPipeSys::kUser8;
|
||
}
|
||
else
|
||
return TPipeSys::kUnknownSys;
|
||
}
|
||
|
||
const TCHAR* CDrawStandPipeDlg::GetLayer()
|
||
{
|
||
UpdateData();
|
||
if(m_iPipeMode == 1){
|
||
if(m_iPipeType == 0)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_FEED;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_FEED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_FEED3;
|
||
}
|
||
else if(m_iPipeType == 1)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_HEADFEED;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_HEADFEED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_HEADFEED3;
|
||
}
|
||
else if(m_iPipeType == 2)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_HEADBACK;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_HEADBACK2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_HEADBACK3;
|
||
}
|
||
else if(m_iPipeType == 3)
|
||
return LAY_VPIPE_DIRT;
|
||
else if(m_iPipeType == 4)
|
||
return LAY_VPIPE_USELESS;
|
||
else if(m_iPipeType == 5)
|
||
return LAY_VPIPE_RAIN;
|
||
else if(m_iPipeType == 6)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_USED;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_USED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_USED3;
|
||
}
|
||
else if(m_iPipeType == 7)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_FIRE;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_FIRE2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_FIRE3;
|
||
}
|
||
else if(m_iPipeType == 8)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_VPIPE_SPRINKLE;
|
||
else if(m_iPos == 1)
|
||
return LAY_VPIPE_SPRINKLE2;
|
||
else if(m_iPos == 2)
|
||
return LAY_VPIPE_SPRINKLE3;
|
||
}
|
||
else if(m_iPipeType == 9)
|
||
return LAY_VPIPE_COAGULATE;
|
||
else if(m_iPipeType == 10)
|
||
return LAY_VPIPE_DRINK;
|
||
else if(m_iPipeType == 11)
|
||
return LAY_VPIPE_PRESSDIRT;
|
||
else if(m_iPipeType == 12)
|
||
return LAY_VPIPE_PRESSUSELESS;
|
||
else if(m_iPipeType == 13)
|
||
return LAY_VPIPE_PRESSRAIN;
|
||
else if(m_iPipeType == 14)
|
||
return LAY_VPIPE_OTHER;
|
||
else if(m_iPipeType == 15)
|
||
return LAY_VPIPE_USER1;
|
||
else if(m_iPipeType == 16)
|
||
return LAY_VPIPE_USER2;
|
||
else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
|
||
{
|
||
return LAY_VPIPE_USER3;
|
||
}
|
||
else if (m_iPipeType == 30)
|
||
{
|
||
return LAY_VPIPE_USER4;
|
||
}
|
||
else if (m_iPipeType == 31)
|
||
{
|
||
return LAY_VPIPE_USER5;
|
||
}
|
||
else if (m_iPipeType == 32)
|
||
{
|
||
return LAY_VPIPE_USER6;
|
||
}
|
||
else if (m_iPipeType == 33)
|
||
{
|
||
return LAY_VPIPE_USER7;
|
||
}
|
||
else if (m_iPipeType == 34)
|
||
{
|
||
return LAY_VPIPE_USER8;
|
||
}
|
||
else
|
||
return _T("");
|
||
}
|
||
else{
|
||
if(m_iPipeType == 0)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_FEED;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_FEED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_FEED3;
|
||
}
|
||
else if(m_iPipeType == 1)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_HEADFEED;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_HEADFEED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_HEADFEED3;
|
||
}
|
||
else if(m_iPipeType == 2)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_HEADBACK;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_HEADBACK2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_HEADBACK3;
|
||
}
|
||
else if(m_iPipeType == 3)
|
||
return LAY_PIPE_DIRT;
|
||
else if(m_iPipeType == 4)
|
||
return LAY_PIPE_USELESS;
|
||
else if(m_iPipeType == 5)
|
||
return LAY_PIPE_RAIN;
|
||
else if(m_iPipeType == 6)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_USED;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_USED2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_USED3;
|
||
}
|
||
else if(m_iPipeType == 7)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_FIRE;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_FIRE2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_FIRE3;
|
||
}
|
||
else if(m_iPipeType == 8)
|
||
{
|
||
if(m_iPos == 0)
|
||
return LAY_PIPE_SPRINKLE;
|
||
else if(m_iPos == 1)
|
||
return LAY_PIPE_SPRINKLE2;
|
||
else if(m_iPos == 2)
|
||
return LAY_PIPE_SPRINKLE3;
|
||
}
|
||
else if(m_iPipeType == 9)
|
||
return LAY_PIPE_COAGULATE;
|
||
else if(m_iPipeType == 10)
|
||
return LAY_PIPE_DRINK;
|
||
else if(m_iPipeType == 11)
|
||
return LAY_PIPE_PRESSDIRT;
|
||
else if(m_iPipeType == 12)
|
||
return LAY_PIPE_PRESSUSELESS;
|
||
else if(m_iPipeType == 13)
|
||
return LAY_PIPE_PRESSRAIN;
|
||
else if(m_iPipeType == 14)
|
||
return LAY_PIPE_OTHER;
|
||
else if(m_iPipeType == 15)
|
||
return LAY_PIPE_USER1;
|
||
else if(m_iPipeType == 16)
|
||
return LAY_PIPE_USER2;
|
||
else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
|
||
{
|
||
return LAY_PIPE_USER3;
|
||
}
|
||
else if (m_iPipeType == 30)
|
||
{
|
||
return LAY_PIPE_USER4;
|
||
}
|
||
else if (m_iPipeType == 31)
|
||
{
|
||
return LAY_PIPE_USER5;
|
||
}
|
||
else if (m_iPipeType == 32)
|
||
{
|
||
return LAY_PIPE_USER6;
|
||
}
|
||
else if (m_iPipeType == 33)
|
||
{
|
||
return LAY_PIPE_USER7;
|
||
}
|
||
else if (m_iPipeType == 34)
|
||
{
|
||
return LAY_PIPE_USER8;
|
||
}
|
||
else
|
||
return _T("");
|
||
}
|
||
return _T("");
|
||
}
|
||
|
||
//返回全局pipe index
|
||
int CDrawStandPipeDlg::GetPipeIdx()
|
||
{
|
||
int ret = 0;
|
||
if(m_iPipeType == 0)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 0;
|
||
else if(m_iPos == 1)
|
||
ret = 17;
|
||
else if(m_iPos == 2)
|
||
ret = 18;
|
||
}
|
||
else if(m_iPipeType == 1)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 1;
|
||
else if(m_iPos == 1)
|
||
ret = 19;
|
||
else if(m_iPos == 2)
|
||
ret = 20;
|
||
}
|
||
else if(m_iPipeType == 2)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 2;
|
||
else if(m_iPos == 1)
|
||
ret = 21;
|
||
else if(m_iPos == 2)
|
||
ret = 22;
|
||
}
|
||
else if(m_iPipeType == 3)
|
||
ret = 3;
|
||
else if(m_iPipeType == 4)
|
||
ret = 4;
|
||
else if(m_iPipeType == 5)
|
||
ret = 5;
|
||
else if(m_iPipeType == 6)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 6;
|
||
else if(m_iPos == 1)
|
||
ret = 27;
|
||
else if(m_iPos == 2)
|
||
ret = 28;
|
||
}
|
||
else if(m_iPipeType == 7)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 7;
|
||
else if(m_iPos == 1)
|
||
ret = 23;
|
||
else if(m_iPos == 2)
|
||
ret = 24;
|
||
}
|
||
else if(m_iPipeType == 8)
|
||
{
|
||
if(m_iPos == 0)
|
||
ret = 8;
|
||
else if(m_iPos == 1)
|
||
ret = 25;
|
||
else if(m_iPos == 2)
|
||
ret = 26;
|
||
}
|
||
else if(m_iPipeType == 9)
|
||
ret = 9;
|
||
else if(m_iPipeType == 10)
|
||
ret = 10;
|
||
else if(m_iPipeType == 11)
|
||
ret = 11;
|
||
else if(m_iPipeType == 12)
|
||
ret = 12;
|
||
else if(m_iPipeType == 13)
|
||
ret = 13;
|
||
else if(m_iPipeType == 14)
|
||
ret = 14;
|
||
else if(m_iPipeType == 15)
|
||
ret = 15;
|
||
else if(m_iPipeType == 16)
|
||
ret = 16;
|
||
else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
|
||
{
|
||
ret = 29;
|
||
}
|
||
else if (m_iPipeType == 30)
|
||
{
|
||
ret = 30;
|
||
}
|
||
else if (m_iPipeType == 31)
|
||
{
|
||
ret = 31;
|
||
}
|
||
else if (m_iPipeType == 32)
|
||
{
|
||
ret = 32;
|
||
}
|
||
else if (m_iPipeType == 33)
|
||
{
|
||
ret = 33;
|
||
}
|
||
else if (m_iPipeType == 34)
|
||
{
|
||
ret = 34;
|
||
}
|
||
else
|
||
return 0;
|
||
return ret;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPlace1()
|
||
{
|
||
UpdateData();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPlace2()
|
||
{
|
||
UpdateData();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPlace3()
|
||
{
|
||
UpdateData();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::ResetRegion()
|
||
{
|
||
// UpdateData();
|
||
CWnd *pWnd1 = GetDlgItem(IDC_RADIO_POS1);
|
||
CWnd *pWnd2 = GetDlgItem(IDC_RADIO_POS2);
|
||
CWnd *pWnd3 = GetDlgItem(IDC_RADIO_POS3);
|
||
//cet 2011.12.1 modify
|
||
//if(m_iPipeType == 0 || m_iPipeType == 1 || m_iPipeType == 2 || m_iPipeType == 6 || m_iPipeType == 7 || m_iPipeType == 8)
|
||
if(m_iPipeType2 == 0 || m_iPipeType2 == 1 || m_iPipeType2 == 2 || m_iPipeType2 == 6 || m_iPipeType2 == 7 || m_iPipeType2 == 8)
|
||
{
|
||
pWnd1->EnableWindow(TRUE);
|
||
pWnd2->EnableWindow(TRUE);
|
||
pWnd3->EnableWindow(TRUE);
|
||
}
|
||
else
|
||
{
|
||
pWnd1->EnableWindow(FALSE);
|
||
pWnd2->EnableWindow(FALSE);
|
||
pWnd3->EnableWindow(FALSE);
|
||
}
|
||
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype1()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 0;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype2()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 1;
|
||
UpdateData(FALSE);
|
||
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype3()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 2;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype4()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 3;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype5()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 4;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype6()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 5;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype7()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 6;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype8()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 7;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype9()
|
||
{
|
||
UpdateData();
|
||
m_iPipeType = 8;
|
||
UpdateData(FALSE);
|
||
ResetRegion();
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::PullMenu()
|
||
{
|
||
// if(m_iPipeType < 9)//sr 2009-10-20 有时候无缘无故会激发这个出来，比如选图上管线，系统从其它跳到指定管线系统
|
||
// return;
|
||
|
||
CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10); // GetDlgItem(IDC_RADIO_PIPETYPE15) cet 2011.12.1 modify
|
||
CRect rc;
|
||
pWnd->GetWindowRect(rc);
|
||
|
||
|
||
if(m_pMenu) {
|
||
m_pMenu->DestroyMenu();
|
||
m_pMenu->CreatePopupMenu();
|
||
} else {
|
||
m_pMenu = new CMenu;
|
||
m_pMenu->CreatePopupMenu();
|
||
}
|
||
|
||
/* cet 2011.12.1 modify
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 1, g_csPipeName[0]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 2, g_csPipeName[1]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 3, g_csPipeName[2]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 4, g_csPipeName[3]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 5, g_csPipeName[4]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 6, g_csPipeName[5]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 7, g_csPipeName[6]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 8, _T("其 它 管"));
|
||
*/
|
||
|
||
std::vector<CString> vecPipeName;
|
||
GetPipeName(vecPipeName);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 1, vecPipeName[0]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 2, vecPipeName[1]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 3, vecPipeName[2]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 4, vecPipeName[3]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 5, vecPipeName[4]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 6, vecPipeName[5]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 7, vecPipeName[6]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 8, vecPipeName[7]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 9, vecPipeName[8]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 10, vecPipeName[9]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 11, vecPipeName[10]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 12, vecPipeName[11]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 13, vecPipeName[12]);
|
||
m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 14, _T("其 它 管"));
|
||
|
||
m_pMenu->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
|
||
rc.left, rc.bottom, this, &rc);
|
||
|
||
PostCommand(_T("V "), false);
|
||
// if(m_iPipeMode == 1)
|
||
// PostCommand(_T("W "), false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype10()
|
||
{
|
||
// cet 2012.10.19 add 判断鼠标点是否在控件上
|
||
CPoint pt;
|
||
::GetCursorPos(&pt);
|
||
CRect rect;
|
||
GetDlgItem(IDC_RADIO_PIPETYPE10)->GetWindowRect(rect);
|
||
if (!rect.PtInRect(pt))
|
||
{
|
||
return;
|
||
}
|
||
|
||
UpdateData();
|
||
// cet 2011.12.6 add
|
||
m_iPipeType = m_iPipeType3;
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
/* cet 2011.12.1 del
|
||
void CDrawStandPipeDlg::OnRadioPipetype11()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype12()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype13()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype14()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype15()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype16()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPipetype17()
|
||
{
|
||
UpdateData();
|
||
ResetRegion();
|
||
PullMenu();
|
||
}
|
||
*/
|
||
|
||
void CDrawStandPipeDlg::OnButtonSetting()
|
||
{
|
||
CTemporaryResourceOverride vTemp;
|
||
CPipeSettingFrameDlg dlg;
|
||
if(dlg.DoModal() != IDOK)
|
||
return;
|
||
|
||
m_csDim1 = g_csPipeDim[0];
|
||
m_csDim2 = g_csPipeDim[1];
|
||
m_csDim3 = g_csPipeDim[2];
|
||
m_csDim4 = g_csPipeDim[3];
|
||
m_csDim5 = g_csPipeDim[4];
|
||
m_csDim6 = g_csPipeDim[5];
|
||
m_csDim7 = g_csPipeDim[6];
|
||
m_csDim8 = g_csPipeDim[7];
|
||
m_csDim9 = g_csPipeDim[8];
|
||
UpdateData(FALSE);
|
||
}
|
||
|
||
#define GET_WM_COMMAND_CMD(wp, lp) HIWORD(wp)
|
||
#define GET_WM_COMMAND_ID(wp, lp) LOWORD(wp)
|
||
#define GET_WM_COMMAND_HWND(wp, lp) ((HWND)lp)
|
||
|
||
|
||
BOOL CDrawStandPipeDlg::OnCommand(WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CString csCommand;
|
||
|
||
//2010-9-2 SR 增加以下7句。对话框启动的时候m_iPipeType有1个默认值，会临时产生单击事件，更换管线类型后点击其他控件，会无缘无故引发这个消息从而改变管线类型
|
||
int nID = GET_WM_COMMAND_ID(wParam,lParam);
|
||
UINT nCodeNotify = GET_WM_COMMAND_CMD(wParam,lParam);
|
||
HWND hwndCtl = GET_WM_COMMAND_HWND(wParam,lParam);
|
||
CPoint pt;
|
||
::GetCursorPos(&pt);
|
||
if (hwndCtl != ::WindowFromPoint(pt) && (nID >= IDC_RADIO_PIPETYPE1 && nID <= IDC_RADIO_PIPETYPE9))
|
||
return TRUE;//如果点所在的控件不是当前控件，终止消息执行
|
||
|
||
// cet 2013.3.13 add 处理立管编号菜单
|
||
if (m_iPipeMode == 1 && m_pMenuSerial != NULL && m_bOpeningMenuSerial)
|
||
{
|
||
m_bOpeningMenuSerial = false;
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator it, itEnd = m_mapSerial.end();
|
||
it = m_mapSerial.find(nID);
|
||
if (it != itEnd)
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_EDIT_NAME);
|
||
if (pWnd != NULL)
|
||
{
|
||
pWnd->SetFocus();
|
||
}
|
||
// 选项没有变化
|
||
if (it->second.second)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator itBegin;
|
||
for (itBegin = m_mapSerial.begin(); itBegin != itEnd; ++itBegin)
|
||
{
|
||
if (itBegin != it)
|
||
{
|
||
itBegin->second.second = false;
|
||
}
|
||
else
|
||
{
|
||
itBegin->second.second = true;
|
||
}
|
||
}
|
||
m_nSelSerialID = nID;
|
||
UpdateSpinVisible();
|
||
PostCommand(_T("V "), false);
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
// cet 2012.3.16 add 处理角度菜单
|
||
int nAngleID = PipeMenuID + 15;
|
||
if (nAngleID <= nID && nID < nAngleID + m_mapAngle.size())
|
||
{
|
||
if (m_pMenuAngle != NULL)
|
||
{
|
||
m_pMenuAngle->GetMenuString(wParam, csCommand, MF_BYCOMMAND);
|
||
double dAngle = _tstof(csCommand);
|
||
if (!SelectAngleMenuItem(dAngle))
|
||
{
|
||
return CDialog::OnCommand(wParam, lParam);
|
||
}
|
||
else if (m_bSendCmdKeyToCAD)
|
||
{
|
||
PostCommand(_T("T "), false);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return CDialog::OnCommand(wParam, lParam);
|
||
}
|
||
}
|
||
|
||
// cet 2010.6.23
|
||
if (m_pMenuEle != NULL)
|
||
{
|
||
m_pMenuEle->GetMenuString(wParam, csCommand, MF_BYCOMMAND);
|
||
if (csCommand.Compare(_T("自动读取前一管线标高")) == 0)
|
||
{
|
||
m_bEle = true;
|
||
}
|
||
else if (csCommand.Compare(_T("不读取前一管线标高")) == 0)
|
||
{
|
||
m_bEle = false;
|
||
}
|
||
}
|
||
|
||
if(m_pMenu == NULL)
|
||
{
|
||
return CModelessDialog::OnCommand(wParam, lParam);
|
||
|
||
}
|
||
// return TRUE;
|
||
|
||
m_pMenu->GetMenuString(wParam, csCommand, MF_BYCOMMAND); //判断用户是否点的是弹出菜单
|
||
if(csCommand.IsEmpty()){
|
||
return CModelessDialog::OnCommand(wParam, lParam);
|
||
}
|
||
|
||
/* cet 2011.12.1 modify
|
||
CWnd *pWnd1 = GetDlgItem(IDC_RADIO_PIPETYPE10);
|
||
CWnd *pWnd2 = GetDlgItem(IDC_RADIO_PIPETYPE11);
|
||
CWnd *pWnd3 = GetDlgItem(IDC_RADIO_PIPETYPE12);
|
||
CWnd *pWnd4 = GetDlgItem(IDC_RADIO_PIPETYPE13);
|
||
CWnd *pWnd5 = GetDlgItem(IDC_RADIO_PIPETYPE14);
|
||
CWnd *pWnd6 = GetDlgItem(IDC_RADIO_PIPETYPE15);
|
||
CWnd *pWnd7 = GetDlgItem(IDC_RADIO_PIPETYPE16);
|
||
CWnd *pWnd8 = GetDlgItem(IDC_RADIO_PIPETYPE17);
|
||
|
||
pWnd1->ShowWindow(SW_HIDE);
|
||
pWnd2->ShowWindow(SW_HIDE);
|
||
pWnd3->ShowWindow(SW_HIDE);
|
||
pWnd4->ShowWindow(SW_HIDE);
|
||
pWnd5->ShowWindow(SW_HIDE);
|
||
pWnd6->ShowWindow(SW_HIDE);
|
||
pWnd7->ShowWindow(SW_HIDE);
|
||
pWnd8->ShowWindow(SW_HIDE);
|
||
|
||
pWnd1->EnableWindow(FALSE);
|
||
pWnd2->EnableWindow(FALSE);
|
||
pWnd3->EnableWindow(FALSE);
|
||
pWnd4->EnableWindow(FALSE);
|
||
pWnd5->EnableWindow(FALSE);
|
||
pWnd6->EnableWindow(FALSE);
|
||
pWnd7->EnableWindow(FALSE);
|
||
pWnd8->EnableWindow(FALSE);
|
||
|
||
if(csCommand == g_csPipeName[0]){
|
||
m_iPipeType = 9;
|
||
pWnd1->ShowWindow(SW_SHOW);
|
||
pWnd1->EnableWindow(TRUE);
|
||
pWnd1->SetWindowText(g_csPipeName[0]);
|
||
}
|
||
else if(csCommand == g_csPipeName[1]){
|
||
m_iPipeType = 10;
|
||
pWnd2->EnableWindow(TRUE);
|
||
pWnd2->ShowWindow(SW_SHOW);
|
||
pWnd2->SetWindowText(g_csPipeName[1]);
|
||
}
|
||
else if(csCommand == g_csPipeName[2]){
|
||
m_iPipeType = 11;
|
||
pWnd3->EnableWindow(TRUE);
|
||
pWnd3->ShowWindow(SW_SHOW);
|
||
pWnd3->SetWindowText(g_csPipeName[2]);
|
||
}
|
||
else if(csCommand == g_csPipeName[3]){
|
||
m_iPipeType = 12;
|
||
pWnd4->ShowWindow(SW_SHOW);
|
||
pWnd4->EnableWindow(TRUE);
|
||
pWnd4->SetWindowText(g_csPipeName[3]);
|
||
}
|
||
else if(csCommand == g_csPipeName[4]){
|
||
m_iPipeType = 13;
|
||
pWnd5->EnableWindow(TRUE);
|
||
pWnd5->ShowWindow(SW_SHOW);
|
||
pWnd5->SetWindowText(g_csPipeName[4]);
|
||
}
|
||
else if(csCommand == _T("其 它 管")){
|
||
m_iPipeType = 14;
|
||
pWnd6->EnableWindow(TRUE);
|
||
pWnd6->ShowWindow(SW_SHOW);
|
||
}
|
||
else if(csCommand == g_csPipeName[5]){
|
||
m_iPipeType = 15;
|
||
pWnd7->EnableWindow(TRUE);
|
||
pWnd7->ShowWindow(SW_SHOW);
|
||
pWnd7->SetWindowText(g_csPipeName[5]);
|
||
}
|
||
else if(csCommand == g_csPipeName[6]){
|
||
m_iPipeType = 16;
|
||
pWnd8->EnableWindow(TRUE);
|
||
pWnd8->ShowWindow(SW_SHOW);
|
||
pWnd8->SetWindowText(g_csPipeName[6]);
|
||
}
|
||
m_csDim10 = g_csPipeDim[m_iPipeType];
|
||
*/
|
||
std::vector<CString> vecPipeName;
|
||
GetPipeName(vecPipeName);
|
||
CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10);
|
||
if(csCommand == vecPipeName[0]){
|
||
m_iPipeType = 9;
|
||
pWnd->SetWindowText(vecPipeName[0]);
|
||
}
|
||
else if(csCommand == vecPipeName[1]){
|
||
m_iPipeType = 10;
|
||
pWnd->SetWindowText(vecPipeName[1]);
|
||
}
|
||
else if(csCommand == vecPipeName[2]){
|
||
m_iPipeType = 11;
|
||
pWnd->SetWindowText(vecPipeName[2]);
|
||
}
|
||
else if(csCommand == vecPipeName[3]){
|
||
m_iPipeType = 12;
|
||
pWnd->SetWindowText(vecPipeName[3]);
|
||
}
|
||
else if(csCommand == vecPipeName[4]){
|
||
m_iPipeType = 13;
|
||
pWnd->SetWindowText(vecPipeName[4]);
|
||
}
|
||
else if(csCommand == _T("其 它 管")){
|
||
m_iPipeType = 14;
|
||
pWnd->SetWindowText(_T("其 它 管"));
|
||
}
|
||
else if(csCommand == vecPipeName[5]){
|
||
m_iPipeType = 15;
|
||
pWnd->SetWindowText(vecPipeName[5]);
|
||
}
|
||
else if(csCommand == vecPipeName[6]){
|
||
m_iPipeType = 16;
|
||
pWnd->SetWindowText(vecPipeName[6]);
|
||
}
|
||
else if(csCommand == vecPipeName[7]){
|
||
m_iPipeType = 29;
|
||
pWnd->SetWindowText(vecPipeName[7]);
|
||
}
|
||
else if(csCommand == vecPipeName[8]){
|
||
m_iPipeType = 30;
|
||
pWnd->SetWindowText(vecPipeName[8]);
|
||
}
|
||
else if(csCommand == vecPipeName[9]){
|
||
m_iPipeType = 31;
|
||
m_iPipeType2 = 9;
|
||
pWnd->SetWindowText(vecPipeName[9]);
|
||
}
|
||
else if(csCommand == vecPipeName[10]){
|
||
m_iPipeType = 32;
|
||
pWnd->SetWindowText(vecPipeName[10]);
|
||
}
|
||
else if(csCommand == vecPipeName[11]){
|
||
m_iPipeType = 33;
|
||
pWnd->SetWindowText(vecPipeName[11]);
|
||
}
|
||
else if(csCommand == vecPipeName[12]){
|
||
m_iPipeType = 34;
|
||
pWnd->SetWindowText(vecPipeName[12]);
|
||
}
|
||
m_csDim10 = g_csPipeDim[m_iPipeType];
|
||
m_iPipeType3 = m_iPipeType;
|
||
m_iPipeType2 = 9;
|
||
CString sText;
|
||
pWnd->GetWindowText(sText);
|
||
if (sText.Find(_T("↓")) == -1)
|
||
{
|
||
sText+=_T("↓");
|
||
pWnd->SetWindowText(sText);
|
||
}
|
||
|
||
UpdateData(FALSE);
|
||
if(m_iPipeMode == 1)
|
||
PostCommand(_T("V "), false);
|
||
|
||
return CModelessDialog::OnCommand(wParam, lParam);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::ReadWriteData(bool bRead)
|
||
{
|
||
UpdateData(TRUE);
|
||
CRegProperty reg(GetRegLocation(), _T("DrawPipe"));
|
||
// reg.SetTopRootKey(HKEY_LOCAL_MACHINE); // cet 2010.7.19 del 存储位置错误
|
||
reg.SetTopRootKey(HKEY_CURRENT_USER); // cet 2010.7.19 add
|
||
|
||
if (bRead)
|
||
{
|
||
if(!reg.GetValue(_T("Elevation"), m_bEle))
|
||
{
|
||
m_bEle = false;
|
||
}
|
||
|
||
if (!reg.GetValue(_T("LockAngle"), m_bLockAngle)) // cet 2011.7.27 add
|
||
{
|
||
m_bLockAngle = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
reg.SetValue(_T("Elevation"), m_bEle);
|
||
reg.SetValue(_T("LockAngle"), m_bLockAngle); // cet 2011.7.27 add
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnButtonMenu()
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_BUTTON_MENU);
|
||
CRect rc;
|
||
pWnd->GetWindowRect(rc);
|
||
|
||
if(m_pMenuEle != NULL)
|
||
{
|
||
m_pMenuEle->DestroyMenu();
|
||
m_pMenuEle->CreatePopupMenu();
|
||
}
|
||
else
|
||
{
|
||
m_pMenuEle = new CMenu;
|
||
m_pMenuEle->CreatePopupMenu();
|
||
}
|
||
|
||
if (m_bEle)
|
||
{
|
||
m_pMenuEle->AppendMenu(MF_CHECKED, PipeMenuID + 11, _T("自动读取前一管线标高"));
|
||
m_pMenuEle->AppendMenu(MF_UNCHECKED, PipeMenuID + 12, _T("不读取前一管线标高"));
|
||
}
|
||
else
|
||
{
|
||
m_pMenuEle->AppendMenu(MF_UNCHECKED, PipeMenuID + 11, _T("自动读取前一管线标高"));
|
||
m_pMenuEle->AppendMenu(MF_CHECKED, PipeMenuID + 12, _T("不读取前一管线标高"));
|
||
}
|
||
|
||
m_pMenuEle->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
|
||
rc.left, rc.bottom, this, &rc);
|
||
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnButtonSerial()
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_BTN_SERIAL);
|
||
if (pWnd == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
CRect rect;
|
||
pWnd->GetWindowRect(&rect);
|
||
if (m_pMenuSerial == NULL)
|
||
{
|
||
m_pMenuSerial = new CMenu;
|
||
}
|
||
else
|
||
{
|
||
m_pMenuSerial->DestroyMenu();
|
||
}
|
||
m_pMenuSerial->CreatePopupMenu();
|
||
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator it, itEnd = m_mapSerial.end();
|
||
for (it = m_mapSerial.begin(); it != itEnd; ++it)
|
||
{
|
||
UINT nflag = it->second.second ? MF_CHECKED : MF_UNCHECKED;
|
||
m_pMenuSerial->AppendMenu(nflag, it->first, it->second.first);
|
||
}
|
||
m_pMenuSerial->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL, rect.left, rect.bottom, this, &rect);
|
||
m_bOpeningMenuSerial = true;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnButtonAngleMenu()
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_BUTTON_ANGLEMENU);
|
||
CRect rc;
|
||
pWnd->GetWindowRect(rc);
|
||
|
||
if(m_pMenuAngle != NULL)
|
||
{
|
||
m_pMenuAngle->DestroyMenu();
|
||
m_pMenuAngle->CreatePopupMenu();
|
||
}
|
||
else
|
||
{
|
||
m_pMenuAngle = new CMenu;
|
||
m_pMenuAngle->CreatePopupMenu();
|
||
}
|
||
|
||
CString sAngle;
|
||
int nID = PipeMenuID + 15;
|
||
std::map<double,bool>::iterator it;
|
||
for (it = m_mapAngle.begin(); it != m_mapAngle.end(); it++)
|
||
{
|
||
sAngle.Format(_T("%.3f"), it->first);
|
||
sAngle.TrimRight(_T("0"));
|
||
sAngle.TrimRight(_T("."));
|
||
m_pMenuAngle->AppendMenu(it->second ? MF_CHECKED : MF_UNCHECKED, nID++, (LPCTSTR)sAngle);
|
||
}
|
||
m_pMenuAngle->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
|
||
rc.left, rc.bottom, this, &rc);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnDestroy()
|
||
{
|
||
CModelessDialog::OnDestroy();
|
||
ReadWriteData(false);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::GetPipeName(std::vector<CString> &vecPipeName)
|
||
{
|
||
CString sTemp;
|
||
if(GetLayerReMark(LAY_PIPE_COAGULATE, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("凝结"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_DRINK, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("直饮"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_PRESSDIRT, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("压力污"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_PRESSUSELESS, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("压力废"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_PRESSRAIN, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("压力雨"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER1, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户1管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER2, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户2管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER3, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户3管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER4, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户4管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER5, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户5管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER6, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户6管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER7, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户7管线"));
|
||
}
|
||
if(GetLayerReMark(LAY_PIPE_USER8, sTemp) && !sTemp.IsEmpty())
|
||
{
|
||
vecPipeName.push_back(sTemp);
|
||
}
|
||
else
|
||
{
|
||
vecPipeName.push_back(_T("用户8管线"));
|
||
}
|
||
}
|
||
|
||
//******************************************************************************
|
||
//******************************************************************************
|
||
int TPipeEdJig::m_iUnit = 0;
|
||
TPipeEdJig::TPipeEdJig(XPoint pt, double nRadius)
|
||
{
|
||
m_iType = 1;
|
||
m_pt1 = pt;
|
||
m_pt2 = pt;
|
||
m_nRadius = nRadius;
|
||
m_pPipe = new TDbPipe;
|
||
m_pPipe->SetDnDiameter(25);
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pt2.z += 3000;
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
m_pPipe->SetRadius(nRadius);
|
||
m_bLock = FALSE;
|
||
m_bInit = TRUE;
|
||
m_iUnit = 0;
|
||
m_nLockAng = -1;
|
||
m_bGreen = false; // cet 2010.6.23 add
|
||
m_dWatchScale = 15; // cet 2011.7.27 add
|
||
m_pDlg = NULL; // cet 2011.7.27 add
|
||
m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
|
||
m_pVirtualPipe->SetPipe(m_pPipe); // cet 2011.7.27 add
|
||
m_vtWatch = AcGeVector3d::kXAxis; // cet 2011.7.28 add
|
||
m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
|
||
m_dViewSize = GetViewSize(); // cet 2011.8.1 add
|
||
m_ptViewCenter = GetViewCenter(); // cet 2011.8.1 add
|
||
}
|
||
|
||
TPipeEdJig::TPipeEdJig(XPoint pt, double nRadius, AcGeVector3d vectBase)//沿线布置
|
||
{
|
||
m_iType = 3;
|
||
m_ptRef = pt;
|
||
m_pt1 = pt;
|
||
m_pt2 = pt;
|
||
m_nRadius = nRadius;
|
||
m_pPipe = new TDbPipe;
|
||
m_pPipe->SetDnDiameter(25);
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pt2.z += 3000;
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
m_pPipe->SetRadius(nRadius);
|
||
m_bLock = FALSE;
|
||
m_bInit = TRUE;
|
||
m_iUnit = 0;
|
||
m_nLockAng = -1;
|
||
m_vectBase = vectBase;
|
||
m_bGreen = false; // cet 2010.6.23 add
|
||
m_dWatchScale = 15; // cet 2011.7.27 add
|
||
m_pDlg = NULL; // cet 2011.7.27 add
|
||
m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
|
||
m_pVirtualPipe->SetPipe(m_pPipe); // cet 2011.7.27 add
|
||
m_vtWatch = AcGeVector3d::kXAxis; // cet 2011.7.28 add
|
||
m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
|
||
m_dViewSize = GetViewSize(); // cet 2011.8.1 add
|
||
m_ptViewCenter = GetViewCenter(); // cet 2011.8.1 add
|
||
}
|
||
|
||
TPipeEdJig::TPipeEdJig(XPoint pt1, XPoint pt2)
|
||
{
|
||
m_iType = 2;
|
||
m_pt1 = pt1;
|
||
m_pt2 = pt2;
|
||
m_pPipe = new TDbPipe;
|
||
m_pPipe->SetDnDiameter(25);
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pPipe->DrawPropertyText(TRUE);
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
m_pPipe->setColorIndex(1);
|
||
m_bLock = TRUE;
|
||
m_bInit = TRUE;
|
||
m_nLockAng = -1;
|
||
m_bGreen = false; // cet 2010.6.23 add
|
||
m_dWatchScale = 15; // cet 2011.7.27 add
|
||
m_pDlg = NULL; // cet 2011.7.27 add
|
||
m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
|
||
m_pVirtualPipe->SetPipe(m_pPipe); // cet 2011.7.27 add
|
||
m_vtWatch = AcGeVector3d::kXAxis; // cet 2011.7.28 add
|
||
m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
|
||
m_dViewSize = GetViewSize(); // cet 2011.8.1 add
|
||
m_ptViewCenter = GetViewCenter(); // cet 2011.8.1 add
|
||
}
|
||
|
||
TPipeEdJig::TPipeEdJig(XPoint pt1, XPoint pt2, double nRadius)
|
||
{
|
||
m_iType = 0;
|
||
m_pt1 = pt1;
|
||
m_pt2 = pt2;
|
||
m_nRadius = nRadius;
|
||
m_pPipe = new TDbPipe;
|
||
m_pPipe->SetDnDiameter(25);
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pPipe->DrawPropertyText(TRUE);
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
m_pPipe->SetRadius(nRadius);
|
||
m_pPipe->setColorIndex(1);
|
||
m_bLock = TRUE;
|
||
m_bInit = TRUE;
|
||
m_nLockAng = -1;
|
||
m_bGreen = false; // cet 2010.6.23 add
|
||
m_dWatchScale = 15; // cet 2011.7.27 add
|
||
m_pDlg = NULL; // cet 2011.7.27 add
|
||
m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
|
||
m_pVirtualPipe->SetPipe(m_pPipe); // cet 2011.7.27 add
|
||
m_vtWatch = AcGeVector3d::kXAxis; // cet 2011.7.28 add
|
||
m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
|
||
m_dViewSize = GetViewSize(); // cet 2011.8.1 add
|
||
m_ptViewCenter = GetViewCenter(); // cet 2011.8.1 add
|
||
}
|
||
|
||
TPipeEdJig::~TPipeEdJig()
|
||
{
|
||
if(m_pPipe)
|
||
delete m_pPipe;
|
||
}
|
||
|
||
AcEdJig::DragStatus
|
||
TPipeEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
if(m_bInit){
|
||
m_bInit = FALSE;
|
||
if(!m_ptRef)
|
||
return acquirePoint(pt);
|
||
else
|
||
{
|
||
XPoint ptTmp = m_ptRef;
|
||
ptTmp.z = 0;
|
||
return acquirePoint(pt, ptTmp);
|
||
}
|
||
}
|
||
if(!m_ptRef || m_iUnit != 0){
|
||
return acquirePoint(pt);
|
||
}
|
||
else
|
||
return acquirePoint(pt, m_ptRef);
|
||
}
|
||
|
||
void TPipeEdJig::SetStartPoint(XPoint pt)
|
||
{
|
||
m_pt1 = pt;
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
}
|
||
|
||
int TPipeEdJig::DoIt(int *keyIndex)
|
||
{
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
return nRet;
|
||
}
|
||
|
||
|
||
XPoint TPipeEdJig::GetCorrectPt()
|
||
{
|
||
XPoint ptTmp = m_ptResult;
|
||
if(m_bLock && m_iUnit>=5){
|
||
XPoint ptTmp2 = m_pt1;
|
||
ptTmp2.z = 0;
|
||
|
||
// 2008－2－18 轴锁支持UCS
|
||
double dUcs = Radian2Angle(Ucs2Wcs(0.0));
|
||
XPoint ptStartUcs = Wcs2Ucs(ptTmp2);
|
||
XPoint ptEndUcs = Wcs2Ucs(m_ptResult);
|
||
double nAngle = ads_angle(ptStartUcs, ptEndUcs); //注意，ads_angle必须是UCS
|
||
// double nAngle = ads_angle(ptTmp2, m_ptResult);
|
||
int Ang = (int)Radian2Angle(nAngle);
|
||
double nDist = ads_distance(ptTmp2, m_ptResult);
|
||
int nTmp = Ang % m_iUnit;
|
||
int multiple = Ang / m_iUnit;
|
||
if(nTmp > m_iUnit / 2)
|
||
nAngle = m_iUnit * (multiple + 1);
|
||
else
|
||
nAngle = m_iUnit * multiple;
|
||
nAngle = nAngle + dUcs;
|
||
nAngle = nAngle / 180 * PI;
|
||
ads_polar(m_pt1, nAngle, nDist, ptTmp);
|
||
}
|
||
else if(!m_bLock && m_nLockAng > -1){
|
||
m_ptRef = XPoint();
|
||
XPoint ptTmp2 = m_pt1;
|
||
ptTmp2.z = 0;
|
||
XPoint ptTmp3 = m_ptResult;
|
||
ptTmp3.z = 0;
|
||
|
||
double nAngle = ads_angle(ptTmp2, m_ptResult) - m_nLockAng;
|
||
double nDist = ads_distance(ptTmp2, ptTmp3);
|
||
if(nAngle > PI/2 && nAngle < PI/2*3)
|
||
ads_polar(m_pt1, m_nLockAng, -nDist, ptTmp);
|
||
else
|
||
ads_polar(m_pt1, m_nLockAng, nDist, ptTmp);
|
||
}
|
||
|
||
// cet 2011.7.27 add 普通管线，有角度盘时调整点位置
|
||
if (m_pDlg != NULL && m_iType == 0 && m_pDlg->m_bLockAngle)
|
||
{
|
||
double dAngle = 0.0;
|
||
GetWatchPt(TADSGePoint3d(ptTmp), ptTmp, dAngle);
|
||
}
|
||
|
||
return ptTmp;
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TPipeEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet=Adesk::kTrue;
|
||
|
||
m_ptPick = m_ptResult;
|
||
XPoint ptTmp = m_ptResult;
|
||
if(m_iType == 1){
|
||
m_pt1 = m_ptResult;
|
||
m_pt2 = m_ptResult;
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pt2.z += 3000;
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
}
|
||
else if(m_iType == 2){
|
||
XArc arc(m_pt1, m_ptResult, m_pt2);
|
||
XPoint ptArcS, ptArcE;
|
||
arc.GetStartPoint(ptArcS);
|
||
arc.GetEndPoint(ptArcE);
|
||
if(m_pt1 == ptArcS)
|
||
m_pPipe->SetPoints(m_pt1, m_pt2, arc.Bulge());
|
||
else
|
||
m_pPipe->SetPoints(m_pt1, m_pt2, -arc.Bulge());
|
||
}
|
||
else if(m_iType == 3){//沿线布置立管
|
||
AcGeVector3d vectTmp(m_ptPick.x - m_ptRef.x, m_ptPick.y - m_ptRef.y, 0);
|
||
double dAng = m_vectBase.angleTo(vectTmp, AcGeVector3d::kZAxis);
|
||
//求橡皮筋向量投影到 以m_vectBase为法向量的 平面
|
||
AcGeVector3d vtOrtho = vectTmp.orthoProject(m_vectBase);
|
||
vtOrtho.normalize();
|
||
vtOrtho *= m_nLockAng;
|
||
m_pt1 = m_ptRef;
|
||
m_pt1 += vtOrtho;
|
||
|
||
m_pt2 = m_pt1;
|
||
m_pt2.z += 3000;
|
||
m_pPipe->SetStartPoint(m_pt1);
|
||
m_pPipe->SetEndPoint(m_pt2);
|
||
m_ptPick = m_pt1;
|
||
}
|
||
else{
|
||
if(m_bLock && m_iUnit>=5 ){
|
||
ptTmp = GetCorrectPt();
|
||
}
|
||
else if(!m_bLock && m_nLockAng > -1){
|
||
ptTmp = GetCorrectPt();
|
||
}
|
||
|
||
m_pt2 = ptTmp;
|
||
// cet 2011.7.27 add 调整值
|
||
if (m_pDlg != NULL && m_pDlg->m_bLockAngle)
|
||
{
|
||
double dAngle = 0.0;
|
||
GetWatchPt(m_pt2, ptTmp, dAngle);
|
||
m_pVirtualPipe->SetAngleDim(m_pt2, dAngle);
|
||
}
|
||
|
||
m_pVirtualPipe->ShowAngleDim((m_pDlg != NULL && m_pDlg->m_bLockAngle) ? true : false);
|
||
|
||
m_pPipe->SetEndPoint(ptTmp);
|
||
}
|
||
// cet 2010.6.23
|
||
if (m_bGreen)
|
||
{
|
||
m_pPipe->setColorIndex(3);
|
||
}
|
||
|
||
// cet 2011.7.27 add 普通管线，有角度盘时调整点位置
|
||
double dViewSize = GetViewSize();
|
||
AcGePoint3d ptViewCenter = GetViewCenter();
|
||
if (m_pDlg != NULL && m_iType == 0 && m_pDlg->m_bLockAngle && m_ptWatch.Distance(m_pt1) > _DIST_SNAP
|
||
|| (m_pDlg != NULL && m_iType == 0 && fabs(dViewSize - m_dViewSize) > 0.00001 && m_pDlg->m_bLockAngle)
|
||
|| (m_pDlg != NULL && m_iType == 0 && ptViewCenter.distanceTo(m_ptViewCenter) > _DIST_SNAP && m_pDlg->m_bLockAngle))
|
||
{
|
||
m_dViewSize = dViewSize;
|
||
m_ptViewCenter = ptViewCenter;
|
||
m_ptWatch = m_pt1;
|
||
DrawDuctWatch(m_ptWatch);
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TPipeEdJig::entity() const
|
||
{
|
||
// return (AcDbEntity *)m_pPipe; cet 2011.7.27 modify
|
||
return (AcDbEntity*)m_pVirtualPipe;
|
||
}
|
||
|
||
// 绘制刻度盘
|
||
void TPipeEdJig::DrawDuctWatch(const AcGePoint3d& ptCenter)
|
||
{
|
||
if (Is3DView()) // 三维下不绘制
|
||
{
|
||
return;
|
||
}
|
||
|
||
double dScale = m_dWatchScale * PI / 180.0;
|
||
int iSegs = (int)(0.5 * PI / dScale);
|
||
if (iSegs < 1)
|
||
iSegs = 1;
|
||
dScale = 0.5 * PI / iSegs;
|
||
|
||
// 刻度盘支持0~180之间的任意角度
|
||
double dScale2 = m_dWatchScale * PI / 180.0;
|
||
int iSegs2 = (int)(PI * 2 / dScale2);
|
||
if(1e-6 < PI * 2 - iSegs2 * dScale2)
|
||
iSegs2++;
|
||
|
||
AcGeVector3d vt = m_vtWatch * PixelToWcs(40);
|
||
AcGePoint3d pt1, pt2, pt3, pt4;
|
||
pt1 = ptCenter + vt;
|
||
|
||
ads_point ptS, ptE;
|
||
if(EQUAL_ZERO(dScale2 - dScale))
|
||
{
|
||
for (int i = 0; i < iSegs * 4; i++)
|
||
{
|
||
pt3 = pt1 + vt / 10.0;
|
||
pt4 = pt1 - vt / 10.0;
|
||
|
||
ptS[0] = pt3.x; ptS[1] = pt3.y; ptS[2] = pt3.z;
|
||
ptE[0] = pt4.x; ptE[1] = pt4.y; ptE[2] = pt4.z;
|
||
acdbWcs2Ucs(ptS, ptS, FALSE);
|
||
acdbWcs2Ucs(ptE, ptE, FALSE);
|
||
acedGrDraw(ptS, ptE, -1, 0);
|
||
|
||
vt.rotateBy(dScale, AcGeVector3d::kZAxis);
|
||
pt2 = ptCenter + vt;
|
||
|
||
ptS[0] = pt1.x; ptS[1] = pt1.y; ptS[2] = pt1.z;
|
||
ptE[0] = pt2.x; ptE[1] = pt2.y; ptE[2] = pt2.z;
|
||
acdbWcs2Ucs(ptS, ptS, FALSE);
|
||
acdbWcs2Ucs(ptE, ptE, FALSE);
|
||
acedGrDraw(ptS, ptE, -1, 0);
|
||
|
||
pt1 = pt2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGePoint3d ptEnd = pt1;
|
||
for (int i = 0; i < iSegs2; i++)
|
||
{
|
||
pt3 = pt1 + vt / 10.0;
|
||
pt4 = pt1 - vt / 10.0;
|
||
|
||
ptS[0] = pt3.x; ptS[1] = pt3.y; ptS[2] = pt3.z;
|
||
ptE[0] = pt4.x; ptE[1] = pt4.y; ptE[2] = pt4.z;
|
||
acdbWcs2Ucs(ptS, ptS, FALSE);
|
||
acdbWcs2Ucs(ptE, ptE, FALSE);
|
||
acedGrDraw(ptS, ptE, -1, 0);
|
||
|
||
vt.rotateBy(dScale2, AcGeVector3d::kZAxis);
|
||
pt2 = ptCenter + vt;
|
||
if(iSegs2 - 1 == i)
|
||
pt2 = ptEnd;
|
||
|
||
ptS[0] = pt1.x; ptS[1] = pt1.y; ptS[2] = pt1.z;
|
||
ptE[0] = pt2.x; ptE[1] = pt2.y; ptE[2] = pt2.z;
|
||
acdbWcs2Ucs(ptS, ptS, FALSE);
|
||
acdbWcs2Ucs(ptE, ptE, FALSE);
|
||
acedGrDraw(ptS, ptE, -1, 0);
|
||
pt1 = pt2;
|
||
}
|
||
}
|
||
}
|
||
|
||
void TPipeEdJig::GetWatchPt(const TADSGePoint3d pt1, TADSGePoint3d &pt, double &dAngleRet)
|
||
{
|
||
if (Is3DView())
|
||
{
|
||
pt = pt1;
|
||
dAngleRet = 0.0;
|
||
return;
|
||
}
|
||
|
||
if (!m_ptWatch) // 第一次使用直接返回，防止出现错误管线
|
||
{
|
||
return;
|
||
}
|
||
|
||
AcGeVector3d vt = pt1 - m_ptWatch;
|
||
if(vt.isZeroLength()) // cet 2011.8.23 add
|
||
{
|
||
return;
|
||
}
|
||
AcGeVector3d vtX = m_vtWatch;
|
||
double dAngle = vtX.angleTo(vt, AcGeVector3d::kZAxis);
|
||
dAngle *= 180 / PI;
|
||
double dAngle1 = 0.0;
|
||
while(dAngle > dAngle1) // 找到大于dAngle的角度
|
||
{
|
||
dAngle1 += m_dWatchScale;
|
||
}
|
||
|
||
// 获得角度盘上小于dAngle的最大角度
|
||
double dMax = dAngle1 - m_dWatchScale;
|
||
// 获得角度盘上大于dAngle的最小角度
|
||
double dMin = dAngle1;
|
||
if (dMin > 2 * 180)
|
||
{
|
||
dMin = 2 * 180;
|
||
}
|
||
|
||
if (fabs(dAngle - dMax) < fabs(dAngle - dMin))
|
||
{
|
||
vt.rotateBy((dMax - dAngle) * PI / 180, AcGeVector3d::kZAxis);
|
||
dAngleRet = dMax;
|
||
}
|
||
else
|
||
{
|
||
vt.rotateBy((dMin - dAngle) * PI / 180, AcGeVector3d::kZAxis);
|
||
dAngleRet = dMin;
|
||
}
|
||
|
||
if (dAngleRet > 180)
|
||
{
|
||
dAngleRet = 180 - (dAngleRet - 180);
|
||
}
|
||
|
||
pt = m_ptWatch + vt;
|
||
}
|
||
|
||
void TPipeEdJig::SetDlg(CDrawStandPipeDlg *pDlg)
|
||
{
|
||
m_pDlg = pDlg;
|
||
}
|
||
|
||
void TPipeEdJig::SetPipeDir(const AcGeVector3d &vt)
|
||
{
|
||
m_vtWatch = vt;
|
||
}
|
||
|
||
double TPipeEdJig::GetViewSize()
|
||
{
|
||
struct resbuf rb = {NULL, RTREAL, 0};
|
||
acedGetVar(_T("VIEWSIZE"), &rb);
|
||
double dViewSize = rb.resval.rreal;
|
||
return dViewSize;
|
||
}
|
||
|
||
AcGePoint3d TPipeEdJig::GetViewCenter()
|
||
{
|
||
struct resbuf rb = {NULL, RT3DPOINT, 0};
|
||
acedGetVar(_T("VIEWCTR"), &rb);
|
||
AcGePoint3d ptViewCenter = asPnt3d(rb.resval.rpoint);
|
||
return ptViewCenter;
|
||
}
|
||
|
||
bool TPipeEdJig::Is3DView()
|
||
{
|
||
struct resbuf rb = {NULL, RT3DPOINT, 0};
|
||
acedGetVar(_T("VIEWDIR"), &rb);
|
||
AcGePoint3d ptView = asPnt3d(rb.resval.rpoint);
|
||
AcGeVector3d vtView = ptView.asVector();
|
||
return !vtView.isCodirectionalTo(AcGeVector3d::kZAxis);
|
||
}
|
||
|
||
// cet 2012.3.16 add 设置角度盘角度
|
||
void TPipeEdJig::SetWatchAngle( double dAngle )
|
||
{
|
||
m_dWatchScale = dAngle;
|
||
}
|
||
|
||
void TPipeEdJig::RedrawWatch()
|
||
{
|
||
acedRedraw(NULL, 0); // 清除当前表盘
|
||
DrawDuctWatch(m_ptWatch);
|
||
}
|
||
|
||
BOOL CDrawStandPipeDlg::PreTranslateMessage(MSG* pMsg)
|
||
{
|
||
|
||
return CModelessDialog::PreTranslateMessage(pMsg);
|
||
}
|
||
|
||
|
||
void CDrawStandPipeDlg::OnCheckLockangle()
|
||
{
|
||
UpdateData(TRUE);
|
||
// cet 2012.3.16 modify 操作角度盘时发送关键字
|
||
// if (!m_bLockAngle)
|
||
// {
|
||
// PostCommand(_T("L "), false); // cet 2011.8.1 add 刷新
|
||
// }
|
||
if (m_bSendCmdKeyToCAD)
|
||
{
|
||
PostCommand(_T("L "), false);
|
||
}
|
||
|
||
// cet 2012.3.15 add
|
||
EnableAngleMenu(m_bLockAngle);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPos1()
|
||
{
|
||
UpdateData(TRUE);
|
||
m_csDim1 = g_csPipeDim[0];
|
||
m_csDim2 = g_csPipeDim[1];
|
||
m_csDim3 = g_csPipeDim[2];
|
||
m_csDim7 = g_csPipeDim[6];
|
||
m_csDim8 = g_csPipeDim[7];
|
||
m_csDim9 = g_csPipeDim[8];
|
||
UpdateData(FALSE);
|
||
//PostCommand(_T("V "), false);
|
||
// zxl 2013.10.17 add
|
||
if (m_bInitDlg)
|
||
{
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPos2()
|
||
{
|
||
UpdateData(TRUE);
|
||
m_csDim1 = g_csPipeDim[17];
|
||
m_csDim2 = g_csPipeDim[19];
|
||
m_csDim3 = g_csPipeDim[21];
|
||
m_csDim7 = g_csPipeDim[27];
|
||
m_csDim8 = g_csPipeDim[23];
|
||
m_csDim9 = g_csPipeDim[25];
|
||
UpdateData(FALSE);
|
||
//PostCommand(_T("V "), false);
|
||
// zxl 2013.10.17 add
|
||
if (m_bInitDlg)
|
||
{
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnRadioPos3()
|
||
{
|
||
UpdateData(TRUE);
|
||
m_csDim1 = g_csPipeDim[18];
|
||
m_csDim2 = g_csPipeDim[20];
|
||
m_csDim3 = g_csPipeDim[22];
|
||
m_csDim7 = g_csPipeDim[28];
|
||
m_csDim8 = g_csPipeDim[24];
|
||
m_csDim9 = g_csPipeDim[26];
|
||
UpdateData(FALSE);
|
||
//PostCommand(_T("V "), false);
|
||
// zxl 2013.10.17 add
|
||
if (m_bInitDlg)
|
||
{
|
||
PostCommand(_T("V "), false);
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::UpdateDimText()
|
||
{
|
||
if (m_iPos == 0)
|
||
{
|
||
OnRadioPos1();
|
||
}
|
||
else if (m_iPos == 1)
|
||
{
|
||
OnRadioPos2();
|
||
}
|
||
else if (m_iPos == 2)
|
||
{
|
||
OnRadioPos3();
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::InitAngleData()
|
||
{
|
||
if (m_mapAngle.empty())
|
||
{
|
||
m_mapAngle.insert(std::make_pair(15, true));
|
||
m_mapAngle.insert(std::make_pair(22.5, false));
|
||
m_mapAngle.insert(std::make_pair(30, false));
|
||
m_mapAngle.insert(std::make_pair(45, false));
|
||
m_mapAngle.insert(std::make_pair(60, false));
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::EnableAngleMenu( BOOL bEnable )
|
||
{
|
||
// 设置角度菜单 cet 2012.3.15
|
||
CWnd *pWnd = GetDlgItem(IDC_BUTTON_ANGLEMENU);
|
||
if (pWnd != NULL)
|
||
{
|
||
pWnd->EnableWindow(bEnable);
|
||
}
|
||
}
|
||
|
||
BOOL CDrawStandPipeDlg::SelectAngleMenuItem( double dAngle )
|
||
{
|
||
std::map<double,bool>::iterator it;
|
||
it = m_mapAngle.find(dAngle);
|
||
if (it != m_mapAngle.end())
|
||
{
|
||
std::map<double,bool>::iterator itM;
|
||
for (itM = m_mapAngle.begin(); itM != m_mapAngle.end(); itM++)
|
||
{
|
||
if (it != itM)
|
||
{
|
||
itM->second = false;
|
||
}
|
||
else
|
||
{
|
||
itM->second = true;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
double CDrawStandPipeDlg::GetAngleFromMenu()
|
||
{
|
||
double dRet = 0.0;
|
||
std::map<double,bool>::iterator it;
|
||
for (it = m_mapAngle.begin(); it != m_mapAngle.end(); it++)
|
||
{
|
||
if(it->second)
|
||
{
|
||
dRet = it->first;
|
||
break;
|
||
}
|
||
}
|
||
return dRet;
|
||
}
|
||
|
||
BOOL CDrawStandPipeDlg::IsLockAngle()
|
||
{
|
||
return m_bLockAngle;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::EnableSendKeyToCAD( BOOL bSend )
|
||
{
|
||
m_bSendCmdKeyToCAD = bSend;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::EnableLockAngle( BOOL bEanble )
|
||
{
|
||
m_bLockAngle = bEanble;
|
||
EnableAngleMenu(bEanble);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::UpdatePipeDn( BOOL bRead /*= TRUE*/, BOOL bCmbSel /*= FALSE*/ )
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_COMBO_DN);
|
||
if (pWnd == NULL)
|
||
{
|
||
return;
|
||
}
|
||
if (bRead)
|
||
{
|
||
if (bCmbSel)
|
||
{
|
||
CComboBox *pBox = (CComboBox*)pWnd;
|
||
if (pBox != NULL)
|
||
{
|
||
int nIndex = pBox->GetCurSel();
|
||
if (nIndex != -1)
|
||
{
|
||
pBox->GetLBText(nIndex, m_csDn);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pWnd->GetWindowText(m_csDn);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pWnd->SetWindowText(m_csDn);
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnEditChangeComboDn()
|
||
{
|
||
UpdateData(TRUE);
|
||
UpdatePipeDn();
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnSelchangeComboDn()
|
||
{
|
||
UpdateData(TRUE);
|
||
UpdatePipeDn(TRUE, TRUE);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::OnEditChangeFloorName()
|
||
{
|
||
// cet 2013.3.18 modify 不能连续输入
|
||
// UpdateData(TRUE);
|
||
// // 更新编号
|
||
// PostCommand(_T("V "), false);
|
||
UpdateData(TRUE);
|
||
m_csName = ::GetCurSerial(GetLayer(), m_csFloorName, GetCurSerialFormat(), m_ssEnt);
|
||
UpdateData(FALSE);
|
||
}
|
||
|
||
void CDrawStandPipeDlg::InitMenuSerial()
|
||
{
|
||
m_mapSerial.clear();
|
||
DWORD id = WM_USER + 1;
|
||
CString sName = _T("数字编号递增");
|
||
m_mapSerial.insert(std::make_pair(id, std::make_pair(sName, false)));
|
||
sName = _T("英文编号递增");
|
||
m_mapSerial.insert(std::make_pair(++id, std::make_pair(sName, false)));
|
||
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator it;
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator itEnd = m_mapSerial.end();
|
||
it = m_mapSerial.find(m_nSelSerialID);
|
||
if (it != itEnd)
|
||
{
|
||
it->second.second = true;
|
||
}
|
||
else
|
||
{
|
||
std::map<DWORD, std::pair<CString, bool> >::iterator itBegin = m_mapSerial.begin();
|
||
itBegin->second.second = true;
|
||
}
|
||
}
|
||
|
||
void CDrawStandPipeDlg::UpdateSpinVisible()
|
||
{
|
||
CWnd *pWnd = GetDlgItem(IDC_SPIN_NAME);
|
||
if (pWnd == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
CWnd *pWndSerial = GetDlgItem(IDC_EDIT_NAME);
|
||
if (pWndSerial == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
CRect rect;
|
||
pWnd->GetWindowRect(&rect);
|
||
CRect rectNew;
|
||
pWndSerial->GetWindowRect(&rectNew);
|
||
ScreenToClient(&rectNew);
|
||
ScreenToClient(&rect);
|
||
|
||
if (m_nSelSerialID == WM_USER + 1)
|
||
{
|
||
pWnd->ShowWindow(SW_SHOW);
|
||
rectNew.right = rect.left;
|
||
pWndSerial->MoveWindow(&rectNew);
|
||
}
|
||
else if (m_nSelSerialID == WM_USER + 2)
|
||
{
|
||
pWnd->ShowWindow(SW_HIDE);
|
||
rectNew.right = rect.right;
|
||
pWndSerial->MoveWindow(&rectNew);
|
||
}
|
||
}
|
||
|
||
CString CDrawStandPipeDlg::GetCurSerialFormat()
|
||
{
|
||
CString sRet;
|
||
if (m_nSelSerialID == WM_USER + 1)
|
||
{
|
||
sRet = _T("1");
|
||
}
|
||
else if (m_nSelSerialID == WM_USER + 2)
|
||
{
|
||
sRet = _T("A");
|
||
std::map<int, std::map<CString, CString> > ::iterator it;
|
||
int nPipeIdx = GetPipeIdx();
|
||
it = m_mapPipeSerial.find(nPipeIdx);
|
||
if (it != m_mapPipeSerial.end())
|
||
{
|
||
std::map<CString, CString>::iterator itTemp;
|
||
itTemp = it->second.find(m_csFloorName);
|
||
if (itTemp != it->second.end())
|
||
{
|
||
sRet = itTemp->second;
|
||
}
|
||
}
|
||
}
|
||
return sRet;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::SetPickset( PickSet &ssPipe )
|
||
{
|
||
m_ssEnt.Free();
|
||
m_ssEnt += ssPipe;
|
||
}
|
||
|
||
void CDrawStandPipeDlg::UpdateSerial()
|
||
{
|
||
// 只更新英文编号
|
||
if (m_nSelSerialID != WM_USER + 2)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_csName = IncreaseSerial(m_csName);
|
||
int nPipeIdx = GetPipeIdx();
|
||
std::map<int, std::map<CString, CString> > ::iterator it;
|
||
it = m_mapPipeSerial.find(nPipeIdx);
|
||
if (it != m_mapPipeSerial.end())
|
||
{
|
||
std::map<CString, CString>::iterator it1;
|
||
it1 = it->second.find(m_csFloorName);
|
||
if (it1 != it->second.end())
|
||
{
|
||
it1->second = m_csName;
|
||
}
|
||
else
|
||
{
|
||
it->second.insert(std::make_pair(m_csFloorName, m_csName));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::map<CString, CString> mapTemp;
|
||
mapTemp.insert(std::make_pair(m_csFloorName, m_csName));
|
||
m_mapPipeSerial.insert(std::make_pair(nPipeIdx, mapTemp));
|
||
}
|
||
}
|
||
|
||
|