envi-code/SourceCode/Code2026/tg_shs/shs_outdoor/EditOutdoorPipeDlg.cpp

#include "stdafx.h"

#include "shs_outdoor.h"
#include "EditOutdoorPipeDlg.h"
#include "Resource.h"

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

//从Kernal移植过来  根据pline线选取设备
void GetEquipmentFromPline(PickSet &ss, const resbuf* rbMask = NULL)
{
	Entity entPoly;
	RBList rbMask2(RTDXF0, _T("LWPOLYLINE"), 8, _T("*"), NULL);
	if (SelectEntity(_T("\n请选择闭合PLINE:<退出>"), entPoly, rbMask2) == RTNORM)
	{
		XPoly2D poly(entPoly);
		poly.TransUCS(Groups(0), Groups(1));
		
		RBList rbFence = poly.Fence();
		
		XPoint ptLow, ptUp;
		poly.GetExtend(ptLow, ptUp);
		AssureInCurrentView(Ucs2Wcs(ptLow), Ucs2Wcs(ptUp));
		
		ss.Get(_T("CP"), rbFence, NULL, rbMask);
		
// 		CString sNot;
// 		sNot.Format(_T("\n共得到%d个设备"),ss.Length());
// 		acutPrintf(sNot);
	}
}

//降序排列函数
bool CompareGradient(const double &dGradient1, const double &dGradient2)
{
	if (dGradient1 >= dGradient2)
	{
		return true;
	}
	return false;
}

IMPLEMENT_DYNAMIC(CEditOutdoorPipeDlg, CModelessDialog)
int CEditOutdoorPipeDlg::m_iPipeDn = 200;

CEditOutdoorPipeDlg::CEditOutdoorPipeDlg(CWnd* pParent /*=NULL*/)
	: CModelessDialog(CEditOutdoorPipeDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CCheckPipeDlg)
	m_dDn = 0.0;
	m_sGradient = _T("");
	//}}AFX_DATA_INIT

	m_iPipeSys = 3;
	m_dGradient = 0.0;
	m_dDn = m_iPipeDn;
	m_nCurPos = 200;
	m_bIsVisible = true;
}

CEditOutdoorPipeDlg::~CEditOutdoorPipeDlg()
{
	m_vecIdPipe.clear();
	m_vecIdAll.clear();
	m_mapPipeGradient.clear();
}


void CEditOutdoorPipeDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CCheckPipeDlg)
	DDX_Control(pDX, IDC_BTN_CHANGEPIPE, m_wndBtnChange);
	DDX_Control(pDX, IDC_BTN_SETPIPE, m_wndBtnSetPipe);
	DDX_Control(pDX, IDC_SCROLLBAR_DN, m_wndScrollBar);
	DDX_Control(pDX, IDC_LST_GRADIENT, m_wndLstGradient);
	DDX_Text(pDX, IDC_EDIT_PIPEDN, m_dDn);
	DDX_Scroll(pDX, IDC_SCROLLBAR_DN, m_nCurPos);
	DDX_CBIndex(pDX, IDC_CMB_PIPESYS, m_iPipeSys);
	DDX_Text(pDX, IDC_EDIT_GRADIENT, m_sGradient);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CEditOutdoorPipeDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CCheckPipeDlg)
	ON_WM_VSCROLL()
	ON_BN_CLICKED(IDC_RADIO_DN1, OnRadioDn1)
	ON_BN_CLICKED(IDC_RADIO_DN2, OnRadioDn2)
	ON_BN_CLICKED(IDC_RADIO_DN3, OnRadioDn3)
	ON_BN_CLICKED(IDC_RADIO_DN4, OnRadioDn4)
	ON_BN_CLICKED(IDC_RADIO_DN5, OnRadioDn5)
	ON_BN_CLICKED(IDC_RADIO_DN6, OnRadioDn6)
	ON_BN_CLICKED(IDC_RADIO_DN7, OnRadioDn7)
	ON_BN_CLICKED(IDC_RADIO_DN8, OnRadioDn8)
	ON_BN_CLICKED(IDC_RADIO_DN9, OnRadioDn9)
	ON_LBN_SELCHANGE(IDC_LST_GRADIENT, OnSelchangeLstGradient)
	ON_WM_TIMER()
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_BTN_SETPIPE, OnBtnSetPipe)
	ON_EN_CHANGE(IDC_EDIT_GRADIENT, OnChangeEditGradient)
	ON_CBN_SELCHANGE(IDC_CMB_PIPESYS, OnSelChangeCmbPipesys)
	ON_BN_CLICKED(IDC_BTN_CHANGEPIPE, OnBtnChangePipeByUser)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BOOL CEditOutdoorPipeDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();
	m_wndScrollBar.SetScrollRange(200, 1100, TRUE);

#if (ADS == 15)
	SetTimer(1, 2000, NULL);
#else
	SetTimer(1, 200, NULL);
#endif
	OnChangeEditGradient();
	InitPipeColor();
	InitBtnColor();
	SetBtnColor();
	SetBtnText();
	
	return TRUE;
}

void CEditOutdoorPipeDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	m_nCurPos = pScrollBar->GetScrollPos();
	switch(nSBCode)                 //处理滚动信息
	{
	case SB_LINEUP:                 //向上的箭头被按下
		{
			m_nCurPos -= 100;
			break; 
		}
		  
	case SB_LINEDOWN:				//向下的箭头被按下
		{
			m_nCurPos += 100;
			break;   
		}
		 
	case SB_THUMBTRACK:				//鼠标拖动
		{
			m_nCurPos = nPos;
			m_nCurPos = m_nCurPos / 100;
			m_nCurPos = m_nCurPos * 100;
			break;
		}	
	}
	if (m_nCurPos < 200)
	{
		m_nCurPos = 200;
	}
	else if (m_nCurPos > 1100)
	{
		m_nCurPos = 1100;
	}

	pScrollBar->SetScrollPos(m_nCurPos);  //更新信息
	SetBtnColor();
	SetBtnText();

	CModelessDialog::OnVScroll(nSBCode, nPos, pScrollBar);
}

void CEditOutdoorPipeDlg::InitPipeColor()
{
	m_mapPipeColor.insert(std::make_pair(200, 1));
	m_mapPipeColor.insert(std::make_pair(300, 3));
	m_mapPipeColor.insert(std::make_pair(400, 5));
	m_mapPipeColor.insert(std::make_pair(500, 6));
	m_mapPipeColor.insert(std::make_pair(600, 7));
	m_mapPipeColor.insert(std::make_pair(700, 13));
	m_mapPipeColor.insert(std::make_pair(800, 40));
	m_mapPipeColor.insert(std::make_pair(900, 136));
	m_mapPipeColor.insert(std::make_pair(1000, 165));
	
	m_mapPipeColor.insert(std::make_pair(1100, 1));
	m_mapPipeColor.insert(std::make_pair(1200, 3));
	m_mapPipeColor.insert(std::make_pair(1300, 5));
	m_mapPipeColor.insert(std::make_pair(1400, 6));
	m_mapPipeColor.insert(std::make_pair(1500, 7));
	m_mapPipeColor.insert(std::make_pair(1600, 13));
	m_mapPipeColor.insert(std::make_pair(1700, 40));
	m_mapPipeColor.insert(std::make_pair(1800, 136));
	m_mapPipeColor.insert(std::make_pair(2000, 165));	
}

void CEditOutdoorPipeDlg::InitBtnColor()
{
	m_mapBtnColor.insert(std::make_pair(200, RGB(255, 0, 0)));
	m_mapBtnColor.insert(std::make_pair(300, RGB(0, 255, 0)));
	m_mapBtnColor.insert(std::make_pair(400, RGB(0, 0, 255)));
	m_mapBtnColor.insert(std::make_pair(500, RGB(255, 0, 255)));
	m_mapBtnColor.insert(std::make_pair(600, RGB(255, 255, 255)));
	m_mapBtnColor.insert(std::make_pair(700, RGB(204, 102, 102)));
	m_mapBtnColor.insert(std::make_pair(800, RGB(255, 191, 0)));
	m_mapBtnColor.insert(std::make_pair(900, RGB(0, 127, 127)));
	m_mapBtnColor.insert(std::make_pair(1000, RGB(76, 95, 153)));

	m_mapBtnColor.insert(std::make_pair(1100, RGB(255, 0, 0)));
	m_mapBtnColor.insert(std::make_pair(1200, RGB(0, 255, 0)));
	m_mapBtnColor.insert(std::make_pair(1300, RGB(0, 0, 255)));
	m_mapBtnColor.insert(std::make_pair(1400, RGB(255, 0, 255)));
	m_mapBtnColor.insert(std::make_pair(1500, RGB(255, 255, 255)));
	m_mapBtnColor.insert(std::make_pair(1600, RGB(204, 102, 102)));
	m_mapBtnColor.insert(std::make_pair(1700, RGB(255, 191, 0)));
	m_mapBtnColor.insert(std::make_pair(1800, RGB(0, 127, 127)));
	m_mapBtnColor.insert(std::make_pair(2000, RGB(76, 95, 153)));
}

//全局定义按钮数组
UINT id[] = {
		IDC_RADIO_DN1,
		IDC_RADIO_DN2,
		IDC_RADIO_DN3,
		IDC_RADIO_DN4,
		IDC_RADIO_DN5,
		IDC_RADIO_DN6,
		IDC_RADIO_DN7,
		IDC_RADIO_DN8,
		IDC_RADIO_DN9,
			};

void CEditOutdoorPipeDlg::SetBtnColor()
{
	int iIndex = m_nCurPos;
	for (int i = 0; i < 9; i++)
	{
		if (iIndex == 1900)
		{
			iIndex = 2000;
		}
		CWnd *pwnd = GetDlgItem(id[i]);
		CString sNote;
		sNote.Format(_T("%d"), iIndex);
		pwnd->SetWindowText(sNote);
		
		pwnd->ModifyStyle(0, BS_OWNERDRAW, 0);
		m_wndBtn[i].Attach(id[i], this);
		COLORREF color;
		std::map<double, COLORREF>::iterator it;
		it = m_mapBtnColor.find(iIndex);
		if (it != m_mapBtnColor.end())
		{
			color = (*it).second;
		}
		m_wndBtn[i].SetBackgroundColor(color);
		iIndex += 100;
	}
}

void CEditOutdoorPipeDlg::SetBtnText()
{
	for (int i = 0; i < 9; i++)
	{
		CWnd *pwnd = GetDlgItem(id[i]);
		CString sTemp;
		pwnd->GetWindowText(sTemp);
		sTemp.Replace(_T("▲"), _T(""));
		int iIndex = _ttoi(sTemp);
		if (iIndex == m_iPipeDn)
		{
			pwnd->SetWindowText(_T("▲") + sTemp);
		}
		else
		{
			pwnd->SetWindowText(sTemp);
		}
	}
}

void CEditOutdoorPipeDlg::GetButtonAct(const int &iIndex)
{
	CWnd *pwnd = GetDlgItem(id[iIndex]);
	CString sTemp;
	pwnd->GetWindowText(sTemp);
	sTemp.Replace(_T("▲"), _T(""));
	m_iPipeDn = _ttoi(sTemp);
	m_dDn = m_iPipeDn;
	SetBtnText();
	SetGradientList();
	UpdateData(FALSE);
	OnSelchangeLstGradient();
}

void CEditOutdoorPipeDlg::OnRadioDn1() 
{
	GetButtonAct(0);
}

void CEditOutdoorPipeDlg::OnRadioDn2() 
{
	GetButtonAct(1);
}

void CEditOutdoorPipeDlg::OnRadioDn3() 
{
	GetButtonAct(2);
}

void CEditOutdoorPipeDlg::OnRadioDn4() 
{
	GetButtonAct(3);
}

void CEditOutdoorPipeDlg::OnRadioDn5() 
{
	GetButtonAct(4);
}

void CEditOutdoorPipeDlg::OnRadioDn6() 
{
	GetButtonAct(5);
}

void CEditOutdoorPipeDlg::OnRadioDn7() 
{
	GetButtonAct(6);
}

void CEditOutdoorPipeDlg::OnRadioDn8() 
{
	GetButtonAct(7);
}

void CEditOutdoorPipeDlg::OnRadioDn9() 
{
	GetButtonAct(8);
}

int CEditOutdoorPipeDlg::GetPipeSys()
{
	return m_iPipeSys;
}

void CEditOutdoorPipeDlg::InitPipeDnGradient()
{
	m_mapPipeGradient.clear();
	std::vector<AcDbObjectId>::iterator it;
	AcDbObjectId id;
	TDbPipe *pPipe = NULL;
	//遍历选中的管线，根据其管径设置其颜色并初始化改管径对应的坡度列表
	for (it = m_vecIdSel.begin(); it != m_vecIdSel.end(); it++)
	{
		id = *it;
		acdbOpenObject(pPipe, id, AcDb::kForRead);
		if (pPipe != NULL)
		{
			double dDn = pPipe->GetDnDiameter();
			double dGradient = pPipe->GetPipeGradient();
			std::map<double, std::vector<double> >::iterator it = m_mapPipeGradient.find(dDn);
			if (it != m_mapPipeGradient.end())
			{
				bool bHasGra = false;
				std::vector<double> vec = (*it).second;
				std::vector<double>::iterator itVec = vec.begin();
				//去除重复的坡度
				for (; itVec != vec.end(); itVec++)
				{
					if (dGradient == *itVec)
					{
						bHasGra = true;
					}
				}
				if (!bHasGra)
				{
					vec.push_back(dGradient);
				}
				(*it).second = vec;
			}
			else
			{
				std::vector<double> vec;
				vec.push_back(dGradient);
				m_mapPipeGradient.insert(std::make_pair(dDn, vec));
			}
			pPipe->close();
		}
	}
}

void CEditOutdoorPipeDlg::SetGradientList()
{
	InitPipeDnGradient();
	std::vector<double> vec;
	std::map<double, std::vector<double> >::iterator it = m_mapPipeGradient.find(m_iPipeDn);
	if (it != m_mapPipeGradient.end())
	{
		vec = (*it).second;
	}
	else
	{
		m_sGradient = _T("");;
		UpdateData(FALSE);
		OnChangeEditGradient();
		m_wndLstGradient.ResetContent();
		return;
	}
	m_wndLstGradient.ResetContent();

	std::sort(vec.begin(), vec.end(), CompareGradient);

	std::vector<double>::iterator itVec = vec.begin();
	CString sTemp;
	for (; itVec != vec.end(); itVec++)
	{
		sTemp.Format(_T("%0.4f"), *itVec);
		if (m_wndLstGradient.FindString(0, sTemp) == LB_ERR)
		{
			m_wndLstGradient.AddString(sTemp);
		}
	}
	m_wndLstGradient.AddString(_T("全部"));
	m_wndLstGradient.SetCurSel(m_wndLstGradient.GetCount() - 1);
}

BOOL CEditOutdoorPipeDlg::GetPipeColor(int &nColor, double dDn)
{
	BOOL bRet = FALSE;
	std::map<double, int>::iterator it;
	it = m_mapPipeColor.find(dDn);
	if (it != m_mapPipeColor.end())
	{
		bRet = TRUE;
		nColor = (*it).second;
	}
	
	return bRet;
}

void CEditOutdoorPipeDlg::GetPipeOriginColor(PickSet &ssSel)
{
	AcDbObjectId id;
	TDbPipe *pPipe = NULL;
	for (long i = 0; i < ssSel.Length(); i++)
	{
		acdbGetObjectId(id, ssSel[i]);
		acdbOpenObject(pPipe, id, AcDb::kForRead);
		if (pPipe != NULL)
		{
			int nColor = pPipe->colorIndex();
			if (m_mapOriginColor.find(id) == m_mapOriginColor.end())
			{
				m_mapOriginColor.insert(std::make_pair(id, nColor));
			}	
			pPipe->close();
		}
	}
}

void CEditOutdoorPipeDlg::RecoverPipeOriginColor()
{
	std::map<AcDbObjectId, int>::iterator it;
	TDbPipe *pPipe = NULL;
	AcDbObjectId id;
	for (it = m_mapOriginColor.begin(); it != m_mapOriginColor.end(); it++)
	{
		id = (*it).first;
		acdbOpenObject(pPipe, id, AcDb::kForWrite);
		if (pPipe != NULL)
		{
			int iIndex = (*it).second;
			pPipe->setColorIndex(iIndex);
			pPipe->close();
		}
	}
}

//list选取不同的坡度值时，取得相应管径和对应坡度值的管线
void CEditOutdoorPipeDlg::OnSelchangeLstGradient() 
{
	int iSel = 0;
	bool bIsAll = false;
	CString sTemp;
	iSel = m_wndLstGradient.GetCurSel();
	if (iSel < 0)
	{
		ShowPipe(true);
		m_vecIdPipe.clear();
		m_sGradient = _T("");
		UpdateData(FALSE);
		OnChangeEditGradient();
		return;
	}

	m_wndLstGradient.GetText(iSel, sTemp);
	if (sTemp == _T("全部"))
	{
		m_wndLstGradient.GetText(0, sTemp);
		bIsAll = true;
	}
	m_dGradient = _tstof(sTemp);
	
	ShowPipe(true);
	m_vecIdPipe.clear();

	std::vector<AcDbObjectId>::iterator it;
	AcDbObjectId id;
	TDbPipe *pPipe = NULL;
	for (it = m_vecIdSel.begin(); it != m_vecIdSel.end(); it++)
	{
		id = *it;
		acdbOpenObject(pPipe, id, AcDb::kForRead);
		if (pPipe != NULL)
		{
			double dDn = pPipe->GetDnDiameter();
			double dGradient = pPipe->GetPipeGradient();
			if (bIsAll)//选择“全部”时
			{
				if (dDn == m_iPipeDn)
				{
					m_vecIdPipe.push_back(id);
				}
			}
			else
			{
				if (dDn == m_dDn && dGradient == m_dGradient)
				{
					m_vecIdPipe.push_back(id);
				}
			}
			pPipe->Close();
		}
	}

	m_sGradient.Format(_T("%0.4f"), m_dGradient);
	UpdateData(FALSE);
	OnChangeEditGradient();
}

void CEditOutdoorPipeDlg::ShowPipe(bool bIsShow)
{
	std::vector<AcDbObjectId>::iterator it;
	TDbPipe *pPipe = NULL;
	AcDbObjectId idPipe = NULL;
	for (it = m_vecIdPipe.begin(); it != m_vecIdPipe.end(); it++)
	{
		pPipe = NULL;
		idPipe = *it;
		AcApDocument* pDoc = acDocManager->curDocument();	
		acDocManager->lockDocument(pDoc, AcAp::kWrite);
		
		acdbOpenObject(pPipe, idPipe, AcDb::kForWrite);
		if (pPipe == NULL)
		{
			continue;
		}
		if (bIsShow)
		{
			pPipe->setVisibility(AcDb::kVisible);
		}
		else
		{
			pPipe->setVisibility(AcDb::kInvisible);
		}
		pPipe->Close();
		
		acedUpdateDisplay();
		actrTransactionManager->flushGraphics();
		acDocManager->unlockDocument(pDoc);
	}
}

void CEditOutdoorPipeDlg::ChangePipeColorDnGradient()//根据输入值修改选取管线的管径和坡度
{
	UpdateData(TRUE);
	std::vector<AcDbObjectId>::iterator it;
	TDbPipe *pPipe = NULL;
	int iNum = 0;
	m_dGradient = _tstof(m_sGradient);
	AcDbObjectId id;
	for (it = m_vecIdPipe.begin(); it != m_vecIdPipe.end(); it++) // 设定管径和坡度
	{
		id = *it;
		AcApDocument* pDoc = acDocManager->curDocument();	
		acDocManager->lockDocument(pDoc, AcAp::kWrite);

		acdbOpenObject(pPipe, id, AcDb::kForWrite);
		if (pPipe != NULL)
		{
			pPipe->SetDnDiameter(m_dDn);
			pPipe->SetPipeGradient(m_dGradient);
			iNum++;
			
			int nColor;
			if (GetPipeColor(nColor, m_dDn))
			{
				pPipe->setColorIndex(nColor);
			}
			pPipe->Close();
		}
		acedUpdateDisplay();
		actrTransactionManager->flushGraphics();
		acDocManager->unlockDocument(pDoc);
	}
	ShowPipe(true);
	m_vecIdPipe.clear();

	//重新读取设定后的管线管径和坡度
	SetGradientList();
	UpdateData(FALSE);
	OnSelchangeLstGradient();

	CString sNote = _T("");
	sNote.Format(_T("\n已完成%d条管道赋值:<退出>"), iNum);
	acutPrintf(sNote);
}

void CEditOutdoorPipeDlg::ChangePipeColor(PickSet &ssSel)
{
	m_vecIdAll.clear();
	AcDbObjectId id;
	for (long i = 0; i < ssSel.Length(); i++)
	{
		OPENOBJ_BEGIN(ssSel[i], AcDb::kForWrite, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			acdbGetObjectId(id, ssSel[i]);
			m_vecIdAll.push_back(id);
			int nColor;
			if (GetPipeColor(nColor, pPipe->GetDnDiameter()))
			{
				pPipe->setColorIndex(nColor);
			}
		}
		OPENOBJ_END();
	}
}


void CEditOutdoorPipeDlg::OnBtnSetPipe() //修改闪烁管线管径和坡度
{
	ChangePipeColorDnGradient();
}

void CEditOutdoorPipeDlg::OnBtnChangePipeByUser() //选择管线进行管径和坡度值修改
{
	SetPipeBySel();
}

void SetPipeSys(const int &iType, RBList &rbMask) // 根据系统类型选取该类型的管线
{
	struct resbuf *pBuf;
	if (iType == 0)
	{
		pBuf = ads_buildlist(RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_DIRT, NULL);
	}
	else if (iType == 1)
	{
		pBuf = ads_buildlist(RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_RAIN, NULL);
	}
	else if (iType == 2)
	{
		pBuf = ads_buildlist(RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USELESS, NULL);
	}
	else
	{
		pBuf = ads_buildlist( -4, _T("<or"),
			-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_RAIN, -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_DIRT, -4, _T("and>"), 
			-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USELESS, -4, _T("and>"),
			-4, _T("or>"), NULL);
	}
	rbMask.Append(pBuf);
}

void CEditOutdoorPipeDlg::SetPipeBySel()
{
	if (!UpdateData(TRUE)) 
	{
		return;
	}
	ShowPipe(true);
	m_vecIdPipe.clear();
	RBList rbMask;
	SetPipeSys(m_iPipeSys, rbMask);
	ShowWindow(SW_HIDE);
	PickSet ss(SS_FREE);
	if (SelectEntities(_T("\n请选择需要设置管径坡度的管段:<退出>"), ss, rbMask) != RTNORM)
	{
		PostCommand(_T("\3"));
		return;
	}
	GetPipeOriginColor(ss);
	for (long l = 0; l < ss.Length(); l++)
	{
		AcDbObjectId id;
		acdbGetObjectId(id, ss[l]);
		m_vecIdPipe.push_back(id);
	}
	ChangePipeColorDnGradient();
	ShowWindow(SW_SHOW);
}

void CEditOutdoorPipeDlg::OnChangeEditGradient() 
{
	UpdateData();
	if (m_sGradient.IsEmpty())//坡度值为空时，不能修改管线
	{
		m_wndBtnSetPipe.EnableWindow(false);
		m_wndBtnChange.EnableWindow(false);
	}
	else
	{
		m_wndBtnSetPipe.EnableWindow(true);
		m_wndBtnChange.EnableWindow(true);
	}
}

void CEditOutdoorPipeDlg::OnTimer(UINT_PTR nIDEvent) 
{
	ShowPipe(m_bIsVisible);
	m_bIsVisible = !m_bIsVisible;
	CModelessDialog::OnTimer(nIDEvent);
}


void CEditOutdoorPipeDlg::OnClose() 
{
	DestroyWindow();
	PostCommand(_T("\3"));
}

void CEditOutdoorPipeDlg::OnSelChangeCmbPipesys()//更新系统类型
{
	UpdateData(TRUE);
	CString sTemp;
	if (m_iPipeSys == 0)//污水
	{
		sTemp = LAY_PIPE_DIRT;
	}
	else if (m_iPipeSys == 1)//雨水
	{
		sTemp = LAY_PIPE_RAIN;
	}
	else if (m_iPipeSys == 2)//废水
	{
		sTemp = LAY_PIPE_USELESS;
	}
	else //全部
	{
		m_vecIdSel = m_vecIdAll;
		SetGradientList();
		OnSelchangeLstGradient();
		return;
	}

	std::vector<AcDbObjectId>::iterator it;
	m_vecIdSel.clear();
	CString sLayer;
	ads_name ssName;
	for (it = m_vecIdAll.begin(); it != m_vecIdAll.end(); it++)
	{
		acdbGetAdsName(ssName, *it);
		sLayer = GetPipeLayer(ssName);
		if(sTemp.Compare(sLayer) == 0)
		{
			m_vecIdSel.push_back(*it);
		}
	}
	SetGradientList();//重新读取坡度值列表
	OnSelchangeLstGradient();//重新设定当前闪烁对象
}


void CEditOutdoorPipeDlg::SetPipes(PickSet &ss)
{
	GetPipeOriginColor(ss);
	ChangePipeColor(ss);
	OnSelChangeCmbPipesys();
	SetGradientList();
}

BOOL CEditOutdoorPipeDlg::DestroyWindow()
{
	KillTimer(103);
	ShowPipe(true);

	RecoverPipeOriginColor();
	return CModelessDialog::DestroyWindow();
}


void EditOutdoorPipe()
{
	g_ssPickFirst.Free(); //清空当前选择集，避免执行命令前已选择实体
	PickSet ss(SS_FREE);

	RBList rbMask = ads_buildlist( -4, _T("<or"),
		-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_RAIN, -4, _T("and>"),  
		-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_DIRT, -4, _T("and>"), 
		-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_USELESS, -4, _T("and>"),
		-4, _T("or>"), NULL);
	
	TCHAR cRet;
	int ret(0);
	INITGET_BEG(0, _T("P A"));
	ret = SelectEntities(_T("\n请选择查询管网的范围{选取闭合PLINE线(P)/整张图(A)}:<退出>"), ss, rbMask, _T("P A"), cRet);
	INITGET_END();
	if (cRet == _T('P'))
	{
		GetEquipmentFromPline(ss, rbMask);
		if (ss.Length() == 0)
		{
			acutPrintf(_T("没有选择到管线，请重新选择!"));
			return;
		}
	}
	else if (cRet == _T('A'))
	{
		ss.Get(_T("X"), NULL, NULL, rbMask);
	}
	else if(ret == RTCAN)
	{
		return;
	}
	else if (ret != RTNORM)
	{
		return;
	}

	if (ss.Length() == 0)
	{
		return;
	}

	CTemporaryResourceOverride vTemp;
	CEditOutdoorPipeDlg dlg(acedGetAcadFrame());
	dlg.Create(IDD_EDIT_OUTDOORPIPE, acedGetAcadFrame());
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	dlg.SetPipes(ss);

	TCHAR sz[10];
	acedGetString(0, _T(""),sz);
	dlg.DestroyWindow();
}