envi-code/SourceCode/Code2026/tg_shs/shs_public/SAmountItem.cpp

// SAmountItem.cpp: implementation of the SAmountItem class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include <dbgridsheet.h>
#include <dbequipment.h>
#include <dbpipeValve.h>
#include "TSheetEdJig.h"

#include "tapi.h"
#include "SAmountItem.h"
#include "SSearchPipeList.h"
//#include "arxtools.h"
#include "twtdef.h"
#include "Teldef.h"
#include "dbxrecrd.h"
#include "DbPool.h"
#include "DbWell.h"
#include "DbPump.h"
#include "DbFireExtinguisher.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                统计合并
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void DrawPlanTable(DList<SAmountItem> &lstEquipInfo, BOOL bIsDown, double nTextSize, double nTableHeight, AcDbObjectId idTextStyle, int iPrePipeLen)
{
	CString csPrompt = _T("点取新表格左上角位置\n");
	if(bIsDown)
		csPrompt = _T("点取新表格左下角位置\n");

	XPoint pt;
	int ret = XGetPoint(NULL, csPrompt, pt);
	if(ret != RTNORM) 
		return;
	TDbSheet *pSheet = new TDbSheet;
	TGridStyle gridStyle;
	gridStyle.SetOverrideAll(TRUE);
	gridStyle.SetTextHeight(nTextSize);
	gridStyle.SetTextStyleId(idTextStyle);
 
	gridStyle.SetHorMode(AcDb::kTextCenter);
    gridStyle.SetVerMode(AcDb::kTextVertMid);
    gridStyle.SetLineSpaceFactor(0.2);
    gridStyle.SetTextWrap(FALSE);
	pSheet->SetGridStyle(gridStyle);


	pSheet->SetRowHeight(nTableHeight);
	pSheet->InitSheet(lstEquipInfo.Length()+1, 7, nTableHeight, 50);

    TSheetColumn column;
    column.SetWidth(12);   //序号
    pSheet->SetColumnAt(0, column);
	column.SetWidth(14);   //图例
	pSheet->SetColumnAt(1, column);
    column.SetWidth(43);   //名称
    pSheet->SetColumnAt(2, column);
    column.SetWidth(43);   //规格
    pSheet->SetColumnAt(3, column);
    column.SetWidth(12);   //单位
    pSheet->SetColumnAt(4, column);
    column.SetWidth(15);   //数量
    pSheet->SetColumnAt(5, column);
    column.SetWidth(41);   //备注
    pSheet->SetColumnAt(6, column);
	int FirstRow = 0;
	if(bIsDown)
		FirstRow = lstEquipInfo.Length();
 
	TGridCell &cell=*(*pSheet)(FirstRow, 0);
	cell.SetText(_T("序号"));
	TGridCell &cell2=*(*pSheet)(FirstRow, 1);
	cell2.SetText(_T("图例"));
	TGridCell &cell3=*(*pSheet)(FirstRow, 2);
	cell3.SetText(_T("名称"));
	TGridCell &cell4=*(*pSheet)(FirstRow, 3);
	cell4.SetText(_T("规格"));
	TGridCell &cell5=*(*pSheet)(FirstRow, 4);
	cell5.SetText(_T("单位"));
	TGridCell &cell6=*(*pSheet)(FirstRow, 5);
	cell6.SetText(_T("数量"));
	TGridCell &cell7=*(*pSheet)(FirstRow, 6);
	cell7.SetText(_T("备注"));

    pSheet->SetLocation(Ucs2Wcs(pt));
	XPoint ptex = pSheet->GetExtents(FALSE);
	int len = lstEquipInfo.Length();
	int index(0);
	for(int i=0;i<len;i++){
		int j = i, index = i + 1;
		if(bIsDown){
			index = lstEquipInfo.Length() - j;
		}
		else
			j = i + 1;
	 
		TGridCell &Cell=*(*pSheet)(j, 0);
		XString xsIndex(_T("%d"), index);
		Cell.SetText(xsIndex);
		CString csBlk = lstEquipInfo[i]->m_csBlkName;
		if(csBlk != _T("") && csBlk != _T("*")){
			TCellBlockInsert blk;
			if(lstEquipInfo[i]->m_csAttribText != _T("")){ //有属性字
				TAttribValue *pAttrib = new TAttribValue();
				pAttrib->m_sName = _T("$TEXT$");
				pAttrib->m_sValue = lstEquipInfo[i]->m_csAttribText;
				blk.m_lstAttribs.Append(pAttrib);
			}
			blk.m_sBlockName = csBlk;
			blk.m_nControlFlag = CBF_AUTOSIZE | CBF_UNISCALE | CBF_SHOW_ATTR | CBF_EQUAL_SIDE;
			XString xsBlk;
			blk.OutputDesc(xsBlk);
			TGridCell &Cell1=*(*pSheet)(j, 1);
			Cell1.SetText(xsBlk);
		
		}
		TGridCell &Cell2=*(*pSheet)(j, 2);
		Cell2.SetText(lstEquipInfo[i]->m_csName);
 
		TGridCell &Cell3=*(*pSheet)(j, 3);
		Cell3.SetText(lstEquipInfo[i]->m_csSpec);
	 
		TGridCell &Cell4=*(*pSheet)(j, 4);
		Cell4.SetText(lstEquipInfo[i]->m_csUnit);
	 
		TGridCell &Cell5=*(*pSheet)(j, 5);
		if(iPrePipeLen < 0 || lstEquipInfo[i]->m_csUnit != _T("米"))
			Cell5.SetText(XString(_T("%.0f"), lstEquipInfo[i]->m_nNum));
		else
		{
			CString sHead,sFormat,csNum;
			sHead.Format(_T("%d"), iPrePipeLen);
			sFormat = _T("%.") + sHead + _T("f");
			csNum.Format(sFormat, lstEquipInfo[i]->m_nNum);
			Cell5.SetText(csNum);
		}

		TGridCell &Cell6=*(*pSheet)(j, 6);
		Cell6.SetText(lstEquipInfo[i]->m_csDemo);

	}
	if(bIsDown){
		pt.y += (ptex.y*DocGetPScale());
		pSheet->SetLocation(pt);
	}

    pSheet->AddToCSpace(TRUE);

}

//判断2个用户图块，虽然后缀机器名不一样，但内容一样，系统认为他们是同一设备
//判断标准：包含图元数量一致，外包一致
BOOL IsSameBlk(CString csBlk1, CString csBlk2)
{
	BOOL bRet = FALSE;
	AcDbObjectId id1 = GetBlockIdFromString(csBlk1);
	AcDbObjectId id2 = GetBlockIdFromString(csBlk2);
	int len1(0), len2(0);
	AcDbExtents extAll1, extAll2;
	OPENOBJ_BEGIN(id1, AcDb::kForRead, AcDbBlockTableRecord, pRec);
	if(pRec){
		AcDbBlockTableRecordIterator *pIterator = NULL;
		pRec->newIterator(pIterator);
		for(pIterator->start(); !pIterator->done(); pIterator->step()){
			len1++;
			AcDbEntity *pEnt = NULL;
			pIterator->getEntity(pEnt, AcDb::kForRead);
			if(pEnt != NULL){
				AcDbExtents ext;
				pEnt->getGeomExtents(ext);
				extAll1.addExt(ext);
				pEnt->close();
			}
		}
	}
	OPENOBJ_END();
	
	OPENOBJ_BEGIN(id2, AcDb::kForRead, AcDbBlockTableRecord, pRec);
	if(pRec){
		AcDbBlockTableRecordIterator *pIterator = NULL;
		pRec->newIterator(pIterator);
		for(pIterator->start(); !pIterator->done(); pIterator->step()){
			len2++;
			AcDbEntity *pEnt = NULL;
			pIterator->getEntity(pEnt, AcDb::kForRead);
			if(pEnt != NULL){
				AcDbExtents ext;
				pEnt->getGeomExtents(ext);
				extAll2.addExt(ext);
				pEnt->close();
			}
		}
	}
	OPENOBJ_END();
	
	if(len1 == len2){
		if(extAll1.maxPoint() == extAll2.maxPoint() && extAll1.minPoint() == extAll2.minPoint())
			bRet = TRUE;
	}
	return bRet;
}

void MergeCountSheet()
{
    RBList rbMask(RTDXF0, _T("ATS_SHEET"), NULL);
	Entity entFirst, entLast;
	PickSet ss(SS_FREE);
	if(SelectEntities(_T("\n请选择要合并的上华统计表格:<退出>"), ss, rbMask) != RTNORM)
		return;
	if(ss.Length() < 2)
		return;
	BOOL bIsDown;
	int iPrePipeLen = -1;
	DList<SAmountItem> lstEquipInfo, lstSort;
	double nTextSize(5), nTableHeight(7);
	AcDbObjectId idTextStyle;
	long len = ss.Length();
	for(long j=0;j<len;j++){
		Entity ent = ss[j];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSheet, pSheet);
		if(pSheet){
			if(j==0){
				TGridStyle style = pSheet->GetGridStyle();
				nTextSize = style.GetTextHeight();
				nTableHeight = pSheet->GetRowHeight();
				idTextStyle = style.GetTextStyleId();
			}

			int nColnum = pSheet->GetColumnNum();
			int nRownum = pSheet->GetRowNum();
			if(nColnum != 7){
				AfxMessageBox(_T("不是上华统计表"));
				return;
			}

			for(int i=0;i<nRownum;i++){
				TGridCell &cell1=*(*pSheet)(i, 0);
				CString csIndex = cell1.GetText();
				TGridCell &cell2=*(*pSheet)(i, 1);
				CString csBlk = cell2.GetText();
				TGridCell &cell3=*(*pSheet)(i, 2);
				CString csName = cell3.GetText();
				TGridCell &cell4=*(*pSheet)(i, 3);
				CString csSpec = cell4.GetText();
				TGridCell &cell5=*(*pSheet)(i, 4);
				CString csUnit = cell5.GetText();
				TGridCell &cell6=*(*pSheet)(i, 5);
				CString csNum = cell6.GetText();
				TGridCell &cell7=*(*pSheet)(i, 6);
				CString csDemo = cell7.GetText();
				TCellBlockInsert blk;
				blk.ParserDesc(csBlk);
				CString csBlkName = (const TCHAR*)blk.m_sBlockName;

				CString csAttrib;
				if(csBlkName != _T("") && blk.m_lstAttribs.Length() > 0)
					csAttrib = blk.m_lstAttribs[0]->m_sValue;

				int iType = 0;
				if(csUnit == _T("米"))
					iType = 0;
				else if(csUnit == _T("个") && csBlkName !=  _T(""))
					iType = 1;
				else if(csUnit == _T("个") && csBlkName ==  _T(""))
					iType = 5;
				else if(csUnit == _T("盏") && csBlkName !=  _T(""))
					iType = 2;
				else if(csUnit == _T("台") && csBlkName !=  _T(""))
					iType = 3;

				if(iPrePipeLen < 0 && csUnit == _T("米"))//获得管线（导线）长度精度
				{
				 
					int idx = csNum.Find(_T("."));
					if(idx > -1)
						iPrePipeLen = csNum.GetLength() - idx - 1;
				}
 
		 		SAmountItem* pListItem = new SAmountItem(iType, csBlkName, csName, csSpec, csUnit, _tstof(csNum), csDemo);
				pListItem->m_csAttribText = csAttrib;
			
				if(csIndex == _T("序号") && csBlk == _T("图例") && csName == _T("名称") && csDemo == _T("备注")
					&& csSpec == _T("规格") && csUnit == _T("单位") && csNum == _T("数量"))
				{
					if(j != 0)//只检查第一个表格
						continue;
					if(i == 0)
						bIsDown = FALSE;
					else if(i == (nRownum -1))
						bIsDown = TRUE;
					else{
						AfxMessageBox(_T("不是上华统计表"));
						return;
					}
					continue;
				}
				BOOL bIsUser = FALSE;
				CString csBlk1;
				if(csBlkName.Find(_T("_U")) > -1 && csBlkName.Find(_T("(")) > -1)
				{//检查用户图块
					bIsUser = TRUE;
					int idx1 = csBlkName.Find(_T("("));
					csBlk1 = csBlkName.Left(idx1);
				}

				
				int iLength = lstEquipInfo.Length();
				int iIndex = -1;
				for(int j=0;j<iLength;j++)
				{
					if((lstEquipInfo[j]->m_csName == csName)
						&& (lstEquipInfo[j]->m_csBlkName == csBlkName)
						&& (lstEquipInfo[j]->m_csAttribText == csAttrib)
						&& (lstEquipInfo[j]->m_csSpec == csSpec))
					{
						iIndex = j;
						break;
					}
					else if(bIsUser && lstEquipInfo[j]->m_csBlkName.Find(_T("_U")) > -1
						&& lstEquipInfo[j]->m_csBlkName.Find(_T("(")) > -1)
					{ //仅仅图块名不同，看看是不是用户自定义图块
						CString csBlk2;
						int idx2 = lstEquipInfo[j]->m_csBlkName.Find(_T("("));
						csBlk2 = lstEquipInfo[j]->m_csBlkName.Left(idx2);
						if(_tcsicmp(csBlk1, csBlk2) == 0)
						{
							if(IsSameBlk(lstEquipInfo[j]->m_csBlkName, csBlkName)){
								iIndex = j;
								break;
							}
						}
						
					}
				}
				if(iIndex > -1){
					lstEquipInfo[iIndex]->m_nNum += _tstof(csNum);
					delete pListItem;
				}
				else{
					lstEquipInfo.Append(pListItem);
				}		
			}
		}
		OPENOBJ_END();
	}

	lstEquipInfo.QuickSort(SAmountItem::SortByItem);
	DrawPlanTable(lstEquipInfo, bIsDown, nTextSize, nTableHeight, idTextStyle, iPrePipeLen);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                统计查询
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 获得备注 cet 2011.11.30 add
BOOL GetLayerReMark(const TCHAR *szLayer, CString &sRemark)
{
	sRemark.Empty();
	XString fullFile;	
	if(FindFile(_T("LAYERDEF.DAT"), fullFile)) 
	{
		FILE *fp=fopen(_AS(fullFile), "r");
		if(!fp)
			return FALSE;
		while(!feof(fp)) 
		{
			char sBuf[256]="";
			TCHAR eName[256]=_T(""),sTemp[256]=_T("");
			fgets(sBuf, 255, fp);
			if(sBuf[0]) 
			{
				CT_strnth(TString(sBuf), 2, eName);
			}
			
			if (_tcscmp(eName, szLayer) == 0)
			{
				CT_strnth(TString(sBuf), 5, sTemp);
				sRemark = sTemp; 
				break;	
			}
		}
		fclose(fp);
	}
	else
		return FALSE;
	
	return TRUE;
}

void GetLayerPipeName(std::map<CString, CString> &mapLayerPipeName)
{
	CString sTemp;
	if(GetLayerReMark(LAY_PIPE_COAGULATE, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_COAGULATE, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_COAGULATE, CString(_T("凝结"))));
	}

	if(GetLayerReMark(LAY_PIPE_DRINK, sTemp) && !sTemp.IsEmpty())
	{	
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_DRINK, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_DRINK, CString(_T("直饮"))));
	}
	if(GetLayerReMark(LAY_PIPE_PRESSDIRT, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSDIRT, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSDIRT, CString(_T("压力污"))));
	}
	if(GetLayerReMark(LAY_PIPE_PRESSUSELESS, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSUSELESS, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSUSELESS, CString(_T("压力废"))));
	}
	if(GetLayerReMark(LAY_PIPE_PRESSRAIN, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSRAIN, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_PRESSRAIN, CString(_T("压力雨"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER1, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER1, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER1, CString(_T("用户1管线"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER2, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER2, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER2, CString(_T("用户2管线"))));	
	}
	if(GetLayerReMark(LAY_PIPE_USER3, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER3, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER3, CString(_T("用户3管线"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER4, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER4, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER4, CString(_T("用户4管线"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER5, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER5, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER5, CString(_T("用户5管线"))));		
	}
	if(GetLayerReMark(LAY_PIPE_USER6, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER6, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER6, CString(_T("用户6管线"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER7, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER7, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER7, CString(_T("用户7管线"))));
	}
	if(GetLayerReMark(LAY_PIPE_USER8, sTemp) && !sTemp.IsEmpty())
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER8, sTemp + _T("管线")));
	}
	else
	{
		mapLayerPipeName.insert(std::make_pair(LAY_PIPE_USER8, CString(_T("用户8管线"))));
	}
}

void GetPipeLayNameBySheet(CString csSheetName, CString &csPipeLay, CString &csVPipeLay)
{
	if(csSheetName == _T("给水管线"))
	{
		csPipeLay = LAY_PIPE_FEED;
		csVPipeLay = LAY_VPIPE_FEED;
	}
	else if(csSheetName == _T("给水中区管线"))
	{
		csPipeLay = LAY_PIPE_FEED2;
		csVPipeLay = LAY_VPIPE_FEED2;
	}
	else if(csSheetName == _T("给水高区管线"))
	{
		csPipeLay = LAY_PIPE_FEED3;
		csVPipeLay = LAY_VPIPE_FEED3;
	}
	else if(csSheetName == _T("喷淋管线"))
	{
		csPipeLay = LAY_PIPE_SPRINKLE;
		csVPipeLay = LAY_VPIPE_SPRINKLE;
	}
	else if(csSheetName == _T("喷淋中区管线"))
	{
		csPipeLay = LAY_PIPE_SPRINKLE2;
		csVPipeLay = LAY_VPIPE_SPRINKLE2;
	}
	else if(csSheetName == _T("喷淋高区管线"))
	{
		csPipeLay = LAY_PIPE_SPRINKLE3;
		csVPipeLay = LAY_VPIPE_SPRINKLE3;
	}
	else if(csSheetName == _T("热回水管线"))
	{
		csPipeLay = LAY_PIPE_HEADBACK;
		csVPipeLay = LAY_VPIPE_HEADBACK;
	}
	else if(csSheetName == _T("热回水中区管线"))
	{
		csPipeLay = LAY_PIPE_HEADBACK2;
		csVPipeLay = LAY_VPIPE_HEADBACK2;
	}
	else if(csSheetName == _T("热回水高区管线"))
	{
		csPipeLay = LAY_PIPE_HEADBACK3;
		csVPipeLay = LAY_VPIPE_HEADBACK3;
	}
	else if(csSheetName == _T("热给水管线"))
	{
		csPipeLay = LAY_PIPE_HEADFEED;
		csVPipeLay = LAY_VPIPE_HEADFEED;
	}
	else if(csSheetName == _T("热给水中区管线"))
	{
		csPipeLay = LAY_PIPE_HEADFEED2;
		csVPipeLay = LAY_VPIPE_HEADFEED2;
	}
	else if(csSheetName == _T("热给水高区管线"))
	{
		csPipeLay = LAY_PIPE_HEADFEED3;
		csVPipeLay = LAY_VPIPE_HEADFEED3;
	}
	else if(csSheetName == _T("中水管线"))
	{
		csPipeLay = LAY_PIPE_USED;
		csVPipeLay = LAY_VPIPE_USED;
	}
	else if(csSheetName == _T("中水中区管线"))
	{
		csPipeLay = LAY_PIPE_USED2;
		csVPipeLay = LAY_VPIPE_USED2;
	}
	else if(csSheetName == _T("中水高区管线"))
	{
		csPipeLay = LAY_PIPE_USED3;
		csVPipeLay = LAY_VPIPE_USED3;
	}
	else if(csSheetName == _T("消防管线"))
	{
		csPipeLay = LAY_PIPE_FIRE;
		csVPipeLay = LAY_VPIPE_FIRE;
	}
	else if(csSheetName == _T("消防中区管线"))
	{
		csPipeLay = LAY_PIPE_FIRE2;
		csVPipeLay = LAY_VPIPE_FIRE2;
	}
	else if(csSheetName == _T("消防高区管线"))
	{
		csPipeLay = LAY_PIPE_FIRE3;
		csVPipeLay = LAY_VPIPE_FIRE3;
	}
	else if(csSheetName == _T("废水管线"))
	{
		csPipeLay = LAY_PIPE_USELESS;
		csVPipeLay = LAY_VPIPE_USELESS;
	}
	else if(csSheetName == _T("污水管线"))
	{
		csPipeLay = LAY_PIPE_DIRT;
		csVPipeLay = LAY_VPIPE_DIRT;
	}
	else if(csSheetName == _T("雨水管线"))
	{
		csPipeLay = LAY_PIPE_RAIN;
		csVPipeLay = LAY_VPIPE_RAIN;
	}
	else if(csSheetName == _T("其它管线"))
	{
		csPipeLay = LAY_PIPE_OTHER;
		csVPipeLay = LAY_VPIPE_OTHER;
	}
	else  // cet 2012.9.19 add 其他13类管线
	{
		std::map<CString,CString> mapPipe;
		GetLayerPipeName(mapPipe);
		std::map<CString,CString>::iterator it;
		for (it = mapPipe.begin(); it != mapPipe.end(); it++)
		{
			if (it->second == csSheetName)
			{
				break;
			}
		}

		if (it != mapPipe.end())
		{
			CString sPipeLayer = it->first;
			if (sPipeLayer == LAY_PIPE_COAGULATE) 
			{
				csPipeLay = LAY_PIPE_COAGULATE;
				csVPipeLay = LAY_VPIPE_COAGULATE;
			}
			else if (sPipeLayer == LAY_PIPE_DRINK) 
			{
				csPipeLay = LAY_PIPE_DRINK;
				csVPipeLay = LAY_VPIPE_DRINK;
			}
			else if (sPipeLayer == LAY_PIPE_PRESSDIRT) 
			{
				csPipeLay = LAY_PIPE_PRESSDIRT;
				csVPipeLay = LAY_VPIPE_PRESSDIRT;
			}
			else if (sPipeLayer == LAY_PIPE_PRESSUSELESS)  
			{
				csPipeLay = LAY_PIPE_PRESSUSELESS;
				csVPipeLay = LAY_VPIPE_PRESSUSELESS;
			}
			else if (sPipeLayer == LAY_PIPE_PRESSRAIN) 
			{
				csPipeLay = LAY_PIPE_PRESSRAIN;
				csVPipeLay = LAY_VPIPE_PRESSRAIN;
			}
			else if (sPipeLayer == LAY_PIPE_USER1) 
			{
				csPipeLay = LAY_PIPE_USER1;
				csVPipeLay = LAY_VPIPE_USER1;
			}
			else if (sPipeLayer == LAY_PIPE_USER2) 
			{
				csPipeLay = LAY_PIPE_USER2;
				csVPipeLay = LAY_VPIPE_USER2;
			}
			else if (sPipeLayer == LAY_PIPE_USER3) 
			{
				csPipeLay = LAY_PIPE_USER3;
				csVPipeLay = LAY_VPIPE_USER3;
			}
			else if (sPipeLayer == LAY_PIPE_USER4) 
			{
				csPipeLay = LAY_PIPE_USER4;
				csVPipeLay = LAY_VPIPE_USER4;
			}
			else if (sPipeLayer == LAY_PIPE_USER5) 
			{
				csPipeLay = LAY_PIPE_USER5;
				csVPipeLay = LAY_VPIPE_USER5;
			}
			else if (sPipeLayer == LAY_PIPE_USER6) 
			{
				csPipeLay = LAY_PIPE_USER6;
				csVPipeLay = LAY_VPIPE_USER6;
			}
			else if (sPipeLayer == LAY_PIPE_USER7) 
			{
				csPipeLay = LAY_PIPE_USER7;
				csVPipeLay = LAY_VPIPE_USER7;
			}
			else if (sPipeLayer == LAY_PIPE_USER8) 
			{
				csPipeLay = LAY_PIPE_USER8;
				csVPipeLay = LAY_VPIPE_USER8;
			}
		}
	}
}

// cet 2012.9.18 add 从实体扩展字典中读取实体id
void ReadXDataFromEntity(const AcDbObjectId &idEnt, PickSet &ss, const CString &sXRecordName = _T("XdPickset"))
{

	AcDbEntity *pEnt = NULL;
	acdbOpenObject(pEnt, idEnt, AcDb::kForRead);
	if (pEnt == NULL)
	{
		return;
	}
	// 获取扩展字典
	AcDbObjectId idDict = pEnt->extensionDictionary(); 
	pEnt->close();
	// 打开扩展字典,获得扩展记录
	AcDbDictionary *pDict = NULL;
	acdbOpenObject(pDict, idDict, AcDb::kForRead);
	if (pDict == NULL)
	{
		return;
	}
	
	AcDbXrecord *pXd = NULL;
	pDict->getAt(sXRecordName, (AcDbObject *&)pXd, AcDb::kForRead);
	pDict->close();
	if (pXd == NULL)
	{
		return;
	}
	struct resbuf *pBuf = NULL;
	pXd->rbChain(&pBuf);
    pXd->close();
	
	if (pBuf != NULL)
	{
		struct resbuf *pTemp = pBuf;
		AcDbObjectId id;
		while(pTemp != NULL)
		{
			if (pTemp->restype == AcDb::kDxfSoftPointerId)
			{
				// 排除无效实体id（如已被删除的实体）
				acdbGetObjectId(id, pTemp->resval.rlname);
				if(!id.isValid())
				{
					pTemp = pTemp->rbnext;
					continue;
				}
				Entity ent(pTemp->resval.rlname);
				ss += ent;
				pTemp = pTemp->rbnext;
				continue;
			}
			break;
		}
		acutRelRb(pBuf);
	}
}

//void SelectPipeBySpec(CString csMat, CString csSpec, CString csLayName) cet 2012.9.18 modify
void SelectPipeBySpec(const AcDbObjectId &idSheet, CString csMat, CString csSpec, CString csLayName)
{
/*  cet 2012.9.18 modify 从扩展字典中读取实体
	g_ssPickFirst.Free();
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), NULL);
	PickSet ssAll(SS_FREE), ssPipe(SS_FREE);
	ssAll.Get(_T("X"), NULL, NULL, rbMask);
*/
	PickSet ssAll(SS_FREE), ssPipe(SS_FREE);
	ReadXDataFromEntity(idSheet, ssAll);
	if(ssAll.Length() == 0)
	{
		g_ssPickFirst.Free();
		RBList rbMask(RTDXF0, _T("ATS_PIPE"), NULL);
		ssAll.Get(_T("X"), NULL, NULL, rbMask);
	}

	CString csPipeLay, csVPipeLay;
	GetPipeLayNameBySheet(csLayName, csPipeLay, csVPipeLay);

	long len = ssAll.Length();
	for(long i=0;i<len;i++){
		Entity ent = ssAll[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe) {
			int iMaterial = pPipe->GetMaterial();
			CString csMat2 = GetPipeMaterialByIdx(iMaterial);
			if(csMat2 == csMat){
				int iDn = (int)pPipe->GetDnDiameter();
				CString csLable = pPipe->GetLabel();
				CString csDn;
				csDn.Format(_T("%s%d"), csLable, iDn);
				if(csSpec == csDn)
				{
					if(csLayName == _T(""))
						ssPipe += ent;
					else
					{
						TCHAR szLayer[256];
						ent.GetData(8, szLayer);
						if(_tcsicmp(szLayer, csPipeLay) == 0 || _tcsicmp(szLayer, csVPipeLay) == 0)
							ssPipe += ent;
					}
				}
			}
		}	
		OPENOBJ_END();
	}
	adsout <<  _T("\n总共选中了") << int(ssPipe.Length()) << _T("根管线"); 
	ads_sssetfirst(ssPipe, ssPipe);
}

//void SelectBlkByName(CString csBlkName) cet 2012.9.18 modify
//void SelectBlkByName(const AcDbObjectId &idSheet, CString csBlkName)
void SelectBlkByName(const AcDbObjectId &idSheet, CString csBlkName, const CString &csSpec, const CString &sName)
{
	/* cet 2012.9.18 modify 从扩展字典中读取实体
	g_ssPickFirst.Free();
	RBList rbMask = ads_buildlist( -4, _T("<or"),
		-4, _T("<and"), RTDXF0, _T("INSERT"), -4, _T("and>"),  
		-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), -4, _T("and>"),  
		-4, _T("<and"), RTDXF0, _T("ATS_PIPEVALVE"), -4, _T("and>"),  
		-4, _T("<and"), RTDXF0, _T("ATS_WELL"), -4, _T("and>"),  
		-4, _T("<and"), RTDXF0, _T("ATS_PUMP"), -4, _T("and>"),  
		-4, _T("or>"), NULL);
	
	PickSet ssAll(SS_FREE), ssSel(SS_FREE);
	ssAll.Get(_T("X"), NULL, NULL, rbMask);
	*/
	PickSet ssAll(SS_FREE), ssSel(SS_FREE);
	ReadXDataFromEntity(idSheet, ssAll);
	if(ssAll.Length() == 0)
	{
		g_ssPickFirst.Free();
		RBList rbMask = ads_buildlist( -4, _T("<or"),
			-4, _T("<and"), RTDXF0, _T("INSERT"), -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_PIPEVALVE"), -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_WELL"), -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_PUMP"), -4, _T("and>"),  
			-4, _T("<and"), RTDXF0, _T("ATS_POOL"), -4, _T("and>"),   
			-4, _T("<and"), RTDXF0, _T("ATS_FIRE_EXTINGUISHER"), -4, _T("and>"), // cet 2014.9.4 add 灭火器
			-4, _T("or>"), NULL);
		ssAll.Get(_T("X"), NULL, NULL, rbMask);
	}
	long len = ssAll.Length();
	for(long i=0;i<len;i++){
		Entity ent = ssAll[i];
		if(ent.Is(_T("INSERT"))){
			TCHAR szBlkName[256];
			ent.GetData(2, szBlkName);
			if(_tcsicmp((const TCHAR*)csBlkName, szBlkName) == 0){
				ssSel += ent;
			}
		}
		else if (ent.Is(_T("ATS_EQUIPMENT"))){
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
			if(pEquip) {
				AcDbObjectId idBlk = pEquip->GetBlock2d();
				CString csName = GetSymbolName(idBlk);
			 
				if(_tcsicmp((const TCHAR*)csBlkName, (const TCHAR*)csName) == 0){
					ssSel += ent;
				}
				else
				{
					// zxl 2012.09.19 add
					CString csNodeSpec;
					double dX = pEquip->GetScale();
					double dY = pEquip->GetYScale();
					if(dX > 10 && dY > 10)
					{
						csNodeSpec.Format(_T("%.0f*%.0f"), dX, dY);
					}

					if(_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000125")) == 0) //喷淋头
					{
						if(_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000283")) == 0 && !pEquip->IsHidePipe()) 
						{
							ssSel += ent;//下喷
						}
						else if(_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000443")) == 0 && pEquip->IsHidePipe()) 
						{
							ssSel += ent;//上喷
						}
					}
					else if(_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000128")) == 0) //上下喷头
					{
						if(_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000444")) == 0) 
						{
							ssSel += ent;
						}
					}
					else if (_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000172")) == 0)//淋浴头 zxl 2012.09.19 add
					{
						if (_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000017")) == 0)
						{
							ssSel += ent;
						}
					}
					else if (_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000225")) == 0)//给水点 zxl 2012.09.19 add
					{
						if (_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000297")) == 0)
						{
							ssSel += ent;
						}
					}
					else if (pEquip->IsHydrant() && csNodeSpec.Compare(csSpec) == 0)// 支持消火栓 zxl 2012.09.19 add
					{
						if (_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000434")) == 0)
						{
							if (_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000427")) == 0)
							{
								ssSel += ent;
							}
						}
						else if (_tcsicmp((const TCHAR*)csName, _T("$TwtSys$00000435")) == 0)
						{
							if (_tcsicmp((const TCHAR*)csBlkName, _T("$TwtSys$00000421")) == 0)
							{
								ssSel += ent;
							}
						}
					}
				}
			}
			OPENOBJ_END();
		}	
		else if (ent.Is(_T("ATS_PIPEVALVE")))
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipeValve, pEquip);
			if(pEquip) {
				AcDbObjectId idBlk = pEquip->GetBlock2d();
				CString csName = GetSymbolName(idBlk);
//				cet 2014.5.5 modify
// 				if(_tcsicmp((const TCHAR*)csBlkName, (const TCHAR*)csName) == 0){
// 					ssSel += ent;
// 				}
				if (csName != csBlkName)
				{
					continue;
				}
				CString sValveSpec;
				AcDbObjectId idPipe = pEquip->GetPipeId();
				TDbPipe *pPipe = NULL;
				acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
				if (pPipe != NULL)
				{
					double dDn = pPipe->GetDnDiameter();
					CString sLabel = pPipe->GetLabel();
					sValveSpec.Format(_T("%s%.0f"), sLabel, dDn);
					pPipe->close();
				}
				if (sValveSpec == csSpec)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("ATS_POOL")))      // cet 2012.9.19 add
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPool, pPool);
			if(pPool != NULL) 
			{
				const int nScale = DocGetMeterUnitDraw() ? 1000 : 1;
				int dWidth = pPool->GetPoolWidth() * nScale;
				int dLength = pPool->GetPoolLength() * nScale;
				CString sPoolSpec;
				sPoolSpec.Format(_T("%d*%d"), dLength, dWidth);
				AcDbObjectId idBlk = pPool->GetBlock2d();
				CString csName = GetSymbolName(idBlk);
				if(_tcsicmp((const TCHAR*)csBlkName, (const TCHAR*)csName) == 0 && sPoolSpec.Compare(csSpec) == 0)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("ATS_WELL"))) // cet 2012.9.20 add
		{
//          cet 2013.1.23 modify 支持方检查井
// 			CString sWellRadius = ReadXdata(ent, _T("TG-WELL-RADIUS"));
// 			CString sWellSpec;
// 			sWellSpec.Format(_T("Φ %.0f"), _tstof(sWellRadius));
// 			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWell, pWell);
// 			if(pWell != NULL) 
// 			{
// 				CString sWellName = _T("检查井"), sWellLayer;
// 				TCHAR *pLayer = pWell->layer();
// 				sWellLayer = pLayer;
// 				delete pLayer;
// 				pLayer = NULL;
// 				if (sWellLayer.CompareNoCase(LAY_WELL_RAIN) == 0)
// 				{
// 					sWellName = _T("雨水检查井");
// 				}
// 				else if (sWellLayer.CompareNoCase(LAY_WELL_DIRT) == 0)
// 				{
// 					sWellName = _T("污水检查井");
// 				}
// 
// 				AcDbObjectId idBlk = pWell->GetBlock2d();
// 				CString csName = GetSymbolName(idBlk);
// 				if((_tcsicmp((const TCHAR*)csBlkName, (const TCHAR*)csName) == 0) &&
// 					(sWellSpec.Compare(csSpec) == 0) &&
// 					sWellName.Compare(sName) == 0)
// 				{
// 					ssSel += ent;
// 				}
// 			}
// 			OPENOBJ_END();
			int nItem(0);
			CString sWellBlkName, sWellDesName;
			AcDbObjectId id;
			acdbGetObjectId(id, ent);
			if(!GetEquipNameById(id, sWellBlkName, sWellDesName, nItem))
			{
				continue;
			}

			CString sWellRadius = ReadXdata(ent, _T("TG-WELL-RADIUS"));
			double dWellRadius = _tstof(sWellRadius);
			CString sWellSpec;
			if (sWellDesName.CompareNoCase(_T("方检查井")) == 0)
			{
				sWellSpec.Format(_T("%.0fX%.0f"), dWellRadius, dWellRadius);
			}
			else if (sWellDesName.CompareNoCase(_T("检查井")) == 0)
			{
				sWellSpec.Format(_T("Φ %.0f"), _tstof(sWellRadius));
			}

			CString sWellLayer;
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWell, pWell);
			if(pWell != NULL) 
			{
				if (sWellDesName.CompareNoCase(_T("检查井")) == 0)
				{
					TCHAR *pLayer = pWell->layer();
					sWellLayer = pLayer;
					delete pLayer;
					pLayer = NULL;
					if (sWellLayer.CompareNoCase(LAY_WELL_RAIN) == 0)
					{
						sWellDesName = _T("雨水检查井");
					}
					else if (sWellLayer.CompareNoCase(LAY_WELL_DIRT) == 0)
					{
						sWellDesName = _T("污水检查井");
					}
				}

				if((sWellBlkName.Compare(csBlkName) == 0) &&
					(sWellSpec.Compare(csSpec) == 0) &&
					sWellDesName.Compare(sName) == 0)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("ATS_PUMP"))) // cet 2012.9.20 add
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPump, pPump);
			if(pPump != NULL) 
			{
				AcDbObjectId idBlk = pPump->GetBlock2d();
				CString csName = GetSymbolName(idBlk);
				if(_tcsicmp((const TCHAR*)csBlkName, (const TCHAR*)csName) == 0)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("ATS_OPENING"))) // cet 2014.5.5 add 基础洞
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
			if (pOpening != NULL)
			{
				AcDbObjectId idBlk = pOpening->m_nIdStyle2d;
				CString sName = GetSymbolName(idBlk);
				if (sName != csBlkName)
				{
					continue;
				}

				double dW = 0.0, dH = 0.0, dT = 0.0;
				dW = pOpening->GetWidth();
				dH = pOpening->GetHeight();
				dT = pOpening->GetWallThickness(TRUE);
				CString sOpeningSpec;
				sOpeningSpec.Format(_T("%.0f×%.0f×%.0f"), dW, dH, dT);
				if (sOpeningSpec == csSpec)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("ATS_FIRE_EXTINGUISHER"))) // cet 2014.9.4 add 支持灭火器
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbFireExtinguisher, pEnt);
			if (pEnt != NULL)
			{
				CString sName = GetSymbolName(pEnt->GetBlock2d());
				CString  sSpecification = pEnt->GetSpec();
				int nIndex = sSpecification.Find(_T("("));  
				if (nIndex != -1)
				{
					sSpecification = sSpecification.Left(nIndex);
				}
				// 按规格和图块名区分不同灭火器
				if (sSpecification == csSpec && sName == csBlkName)
				{
					ssSel += ent;
				}
			}
			OPENOBJ_END();
		}
	}
	adsout <<  _T("\n总共选中了") << int(ssSel.Length()) << _T("个图块"); 
	ads_sssetfirst(ssSel, ssSel);
}

void CountSheetFind()
{
    XPushVar<int> vOsMode(_T("OSMODE"), 0);
    TSheetEdJig jig;
    jig.SetOperCode(TSheetEdJig::kSingleRow);

    jig.SetPrompt(_T("\n请点取要查询材料的表行<退出>"));
    int nKeyIndex=0;
    int nCode=jig.DoIt(&nKeyIndex);
    if(nCode != RTNORM)
        return;
    int nRow;
    AcDbObjectId id = jig.GetHitRow(nRow);
	XStringList lstMat;
	CString csSpec, csBlk, csName, csBlkName, csLayName;
    if(!!id) {
        OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSheet, pSheet);
        if(pSheet) {
			int nColnum = pSheet->GetColumnNum();
			if(nColnum != 7){
				AfxMessageBox(_T("不是上华统计表"));
				return;
			}
			TGridCell &cell2=*(*pSheet)(nRow, 1);
			csBlk = cell2.GetText();
			TGridCell &cell3=*(*pSheet)(nRow, 2);
			csName = cell3.GetText();
			TGridCell &cell4=*(*pSheet)(nRow, 3);
			csSpec = cell4.GetText();
 
			TCellBlockInsert blk;
			blk.ParserDesc(csBlk);
			csBlkName = (const TCHAR*)blk.m_sBlockName;
			
			CString csAttrib;
			if(csBlkName != _T("") && blk.m_lstAttribs.Length() > 0)
				csAttrib = blk.m_lstAttribs[0]->m_sValue;
			if(csBlkName.Find(_T("TWT_")) > -1 && csName.Find(_T("管线")) > -1)
			{
				csLayName = csName;
				TCHAR szMat[64], szSpec[64];
				CT_strnth(csSpec, 1, szMat);
				CT_strnth(csSpec, 2, szSpec);
				csName = szMat;
				csSpec = szSpec;
				csBlk = _T("");
			}
        }
        OPENOBJ_END();
    }
	else
		return;

	if(g_nProductId==14)//给排水专业需要统计管材
		GetPipeMaterialList(lstMat);
	if(lstMat.Index(csName) > -1 && csBlk == _T("")){
		//SelectPipeBySpec(csName, csSpec, csLayName); cet 2012.9.18 modify
		SelectPipeBySpec(id,csName, csSpec, csLayName);
	}
	else if(csBlkName != _T("")){
		//SelectBlkByName(csBlkName); cet 2012.9.18 modify
		//SelectBlkByName(id,csBlkName);
		SelectBlkByName(id,csBlkName, csSpec, csName);
	}

}