#include "stdafx.h"
#include "FGBZDlg.h"
#include "DuctlineTools.h"
#include "uihistory.h"

#ifndef ID_USER_MENU
#define ID_USER_MENU 10000
#endif

extern double MayAsMUnit(double dVal);

double AsMMUnit(double dVal)
{
	struct resbuf rb;
	acedGetVar(_T("INSUNITS"), &rb);
	if (rb.resval.rint == AcDb::kUnitsMeters)
	{
		dVal *= 1000;
	}
	return dVal;
}

IMPLEMENT_DYNAMIC(CFGBZDlg, CDialog)

CFGBZDlg::CFGBZDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CFGBZDlg::IDD, pParent)
	, m_dTopEl(0.0)
	, m_sProvider(_T("宁波伊斯特通风工程有限公司"))
	, m_sDuctUse(_T("送风"))
	, m_sMat(_T("镀锌钢板"))
	, m_nSecType(0)
	, m_dt(5.0)
	, m_dRatio(1.0)
	, m_nAlign(1)//中
	, m_sNo(_T("FG-001"))
	, m_dCenEl(0)
{

	m_pDbServer = NULL;
	m_csFlux = _T("");
	m_csHeight = _T("300");
	m_csWidth = _T("630");

	m_eOffsetFirst = AecHvac::eObliqueLink;	// 乙字弯优先类型
	m_eOffsetSec = AecHvac::eArcuateLink;	// 乙字弯其次类型
	m_csOffCalType = _T("曲率");
	m_dOffsetAngle = 90.0;					// 乙字弯角度
	m_dOffsetRatio = 1.0;					// 乙字弯曲率倍数

	m_eElbowTypeR = AecHvac::eAllArcuate;	// 矩形弯头默认类型
	m_eElbowTypeC = AecHvac::eAllArcuate;	// 圆形弯头默认类型
	m_dElbowRatio = 1.0;					// 弯头曲率
	m_nElbowXiaMi = 3;
	m_dDencity = 1.2;						// 密度

	m_eTeeTypeR = AecHvac::eArcuateBranch;	// 矩形三通默认类型
	m_eTeeTypeC = AecHvac::eArcuateBranch;	// 圆形三通默认类型
	m_dTeeRatio = 1.0;						// 三通曲率
	m_dTeeAngle = 90.0;						// 三通角度

	m_eCrossTypeR = AecHvac::eArcuateCross;	// 矩形四通默认类型
	m_eCrossTypeC = AecHvac::eArcuateCross;	// 圆形四通默认类型
	m_dCrossRatio = 1.0;					// 四通曲率
	m_dCrossAngle = 90.0;					// 四通角度

	m_csReduceCalType = _T("自动计算");		// 变径长度计算方法
	m_dReduceLength = 1000.0;				// 变径长度
	m_dReduceAnlge = 30.0;					// 变径角度

	m_eFlangeType = AecHvac::eHanJieLine;	// 焊接法兰
	m_dPlusEdge = 50.0;	
	
	m_dV = 0.0;
	m_dPy = 0.0;
	m_dR = 0.0;
	m_dElOld = 0;
	//
	m_bEnableAlign = TRUE;
	m_bEleReadOnly = FALSE;
	m_bLoadLast = FALSE;
	m_bLock = false;

	GET_CACHE(CFGBZDlg
		, %s%s%d%s%s%s%f%f%d%f%s%s
		, &m_sDuctUse
		, &m_sMat
		, &m_nSecType
		, &m_csFlux
		, &m_csWidth
		, &m_csHeight
		, &m_dt
		, &m_dRatio
		, &m_nAlign
		, &m_dTopEl
		, &m_sNo
		, &m_sProvider);
}

CFGBZDlg::~CFGBZDlg()
{
}

void CFGBZDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDT_SECTWIDTH, m_csWidth);
	DDX_Text(pDX, IDC_EDT_SECTHEIGHT, m_csHeight);
	DDX_Text(pDX, IDC_EDIT2, m_dTopEl);
	DDX_Text(pDX, IDC_EDIT1, m_sProvider);
	DDX_CBString(pDX, IDC_CMB_PIPETYPE, m_sDuctUse);
	DDX_CBString(pDX, IDC_CMB_PIPEMATERIAL, m_sMat);
	DDX_CBIndex(pDX, IDC_CMB_SECT, m_nSecType);
	DDX_Text(pDX, IDC_EDT_SECTWIDTH2, m_dt);
	DDX_Text(pDX, IDC_EDIT5, m_dRatio);
	DDX_Text(pDX, IDC_EDT_FLUX, m_csFlux);
	DDX_Text(pDX, IDC_EDIT3, m_sNo);
	DDX_Control(pDX, IDC_BTN_FLUX, m_wndBtnSTFlux);
	DDX_Control(pDX, IDC_BTN_POP_DN_MENU, m_wndBtnPopDnMenu);
	DDX_Control(pDX, IDC_LST_HEIGHT, m_wndLstHeight);
	DDX_Control(pDX, IDC_LST_WIDTH, m_wndLstWidth);
	DDX_Control(pDX, IDC_CMB_SECT, m_wndCmbSect);
	DDX_Control(pDX, IDC_CMB_PIPETYPE, m_wndCmbPipeType);
	DDX_Control(pDX, IDC_CMB_PIPEMATERIAL, m_wndCmbPipeMaterial);
	DDX_CBIndex(pDX, IDC_COMBO1, m_nAlign);
	DDX_Control(pDX, IDC_COMBO1, m_wndAlignCombo);
	DDX_Control(pDX, IDC_EDIT2, m_wndEditEl);
	DDX_Text(pDX, IDC_EDIT4, m_dCenEl);
}

BEGIN_MESSAGE_MAP(CFGBZDlg, CDialog)
	ON_BN_CLICKED(IDOK, &CFGBZDlg::OnBnClickedOk)
	ON_COMMAND(IDM_KG_H, OnKgH)
	ON_COMMAND(IDM_KG_S, OnKgS)
	ON_COMMAND(IDM_L_H, OnLH)
	ON_COMMAND(IDM_L_S, OnLS)
	ON_COMMAND(IDM_COBE_S, OnCobeS)
	ON_COMMAND(IDM_COBE_H, OnCobeH)
	ON_BN_CLICKED(IDC_BTN_POP_DN_MENU, &CFGBZDlg::OnBnClickedBtnPopDnMenu)
	ON_BN_CLICKED(IDC_BUT_CHANGE, &CFGBZDlg::OnBnClickedButChange)
	ON_EN_CHANGE(IDC_EDT_SECTWIDTH, OnChangeEdtSectWidth)
	ON_EN_CHANGE(IDC_EDT_SECTHEIGHT, OnChangeEdtSectHeight)
	ON_NOTIFY(NM_CLICK, IDC_LST_HEIGHT, OnClickLstHeight)
	ON_NOTIFY(NM_CLICK, IDC_LST_WIDTH, OnClickLstWidth)
	ON_CBN_SELCHANGE(IDC_CMB_SECT, &CFGBZDlg::OnSelchangeCmbSect)
	ON_EN_CHANGE(IDC_EDIT2, &CFGBZDlg::OnEnChangeEdit2)
	ON_BN_CLICKED(IDC_BUTTON1, &CFGBZDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

BOOL CFGBZDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	m_pDbServer = new CUIISQLiteServer;
	if ( !DuctlineTools::getSqliteDB(_T("HvacConfig.db"), *m_pDbServer))
	{
		AfxMessageBox(_T("未找到数据库文件HvacConfig.db,请重新安装！"));
		delete m_pDbServer;
		return FALSE;
	}

	// 风量
	m_wndBtnSTFlux.SetMenu(IDM_FLUX_DUCT, m_hWnd);
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(m^3/h):"));
	m_eFluxType = eCobeH;	
	m_csFlux = _T("1000.0");
	m_dFlux = 1000.0;

	// 截面宽、高
	//m_csHeight = _T("300");
	//m_csWidth = _T("630");

	CString csSQL;
	csSQL.Format(_T("SELECT DISTINCT [KEY], [VALUE] FROM %s"), _T("OtherConfig"));
	m_pDbServer->GetSelData(csSQL, m_mapCfg);

	m_wndBtnPopDnMenu.SetIcon(IDI_LAST_ROW);
	m_wndBtnPopDnMenu.SetFlat(FALSE);

	m_wndAlignCombo.EnableWindow(m_bEnableAlign);

	m_wndEditEl.SetReadOnly(m_bEleReadOnly);

	if (m_bLock)//锁定标高
	{
		GetDlgItem(IDC_EDIT2)->EnableWindow(FALSE);
	}
	
	UpdateData(FALSE);

	OnSelchangeCmbSect();

	// 设置截面尺寸列表状态
	OnChangeEdtSectWidth();
	if (m_nSecType == 0)//矩形
	{
		OnChangeEdtSectHeight();
	}
	CheckSysParameter();

	if (m_nSecType == 0)//矩形
	{
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csHeight);
	}
	else
	{
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csWidth);
	}

	UpdateData(FALSE);

	return TRUE;
}

void CFGBZDlg::OnBnClickedOk()
{
	UpdateData(TRUE);

	SET_CACHE(CFGBZDlg
		, %s%s%d%s%s%s%f%f%d%f%s%s
		, m_sDuctUse
		, m_sMat
		, m_nSecType
		, m_csFlux
		, m_csWidth
		, m_csHeight
		, m_dt
		, m_dRatio
		, m_nAlign
		, m_dTopEl
		, m_sNo
		, m_sProvider);
	OnOK();
}

void CFGBZDlg::EnableLoadLast(BOOL bLoadLast)
{
	m_bLoadLast = bLoadLast;
}

void CFGBZDlg::SetEleReadOnly(BOOL bEleReadOnly,double dEl)
{
	m_bEleReadOnly = bEleReadOnly;
	m_dTopEl = dEl;
}

void CFGBZDlg::GetPipeParam(AecHvac::DuctParam* pParam)
{
	/*
	typedef struct DuctParam
	{
	ESection eType;	//截面类型
	double dSize[9];//尺寸 宽度,高度,厚度
	int    m_nAlign;//对其方式
	double m_dEl;	//标高
	double m_dRatio;//曲率半径

	int   m_bCover;	//盖板 桥架用
	int   m_bSpart; //隔板 桥架用

	TCHAR szNo[33]; //编号
	TCHAR szMat[33];//材质
	TCHAR szFat[33];//厂家
	TCHAR szType[33]//类型
	TCHAR szExt[33];//其他

	}DUCTPARAM;
	*/

	if (pParam != NULL)
	{
		memset(pParam,0,sizeof(AecHvac::DuctParam));
		pParam->eType = (ESection)(m_nSecType+1);

		pParam->dSize[0] = MayAsMUnit(_ttof(m_csWidth));
		pParam->dSize[1] = MayAsMUnit(_ttof(m_csHeight));
		pParam->dSize[2] = MayAsMUnit(m_dt);

		pParam->m_nAlign = m_nAlign;

		if (m_bLock)
		{
			pParam->m_dEl = m_dElOld;
		}
		else
		{
			//存为中心标高
			if (pParam->eType == eCircle)
				pParam->m_dEl = m_dTopEl - 0.5 * pParam->dSize[0];
			else
				pParam->m_dEl = m_dTopEl - 0.5 * pParam->dSize[1];
		}

		pParam->m_dRatio = m_dRatio;
		pParam->m_bCover = 1;
		pParam->m_bSpart = 0;
		pParam->m_bCenDraw = 1;//绘制中心线
		pParam->m_dFullPer = 0;
		pParam->m_dPlusEdge = MayAsMUnit(m_dPlusEdge);
		
		pParam->iALUnit = (int)m_eFluxType;
		pParam->dAirload = m_dFlux;

		pParam->m_dV = m_dV;
		// 比摩阻
		pParam->m_dR = m_dR;
		// 沿层阻力
		pParam->m_dPy = m_dPy;

		_tcscpy(pParam->szNo,m_sNo);
		_tcscpy(pParam->szMat,m_sMat);
		_tcscpy(pParam->szFat,m_sProvider);
		_tcscpy(pParam->szType,m_sDuctUse);//
		_tcscpy(pParam->szSys,m_sDuctUse);
		_tcscpy(pParam->szRem,_T(""));
	}
}

void CFGBZDlg::SetShowParam(const AecHvac::DuctParam& param)
{
	double dSize[9];
	memcpy(dSize,param.dSize,sizeof(double)*9);

	for(int i = 0;i < 9;i++)
	{
		dSize[i] = AsMMUnit(param.dSize[i]);
	}

	m_nSecType = param.eType - 1;
	m_csWidth.Format(_T("%d"),(int)(dSize[0] + 0.5) );
	m_csHeight.Format(_T("%d"),(int)(dSize[1] + 0.5) );

	m_dt = param.dSize[2];
	m_nAlign = param.m_nAlign;

	if (m_nSecType == 0)//矩形
	{
		m_dTopEl = param.m_dEl + 0.5 * dSize[1];
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csHeight);
	}
	else
	{
		m_dTopEl = param.m_dEl + 0.5 * dSize[0];
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csWidth);
	}

	m_dElOld = param.m_dEl;

	m_dRatio = param.m_dRatio;
	m_dPlusEdge = param.m_dPlusEdge;
	m_sNo = param.szNo;
	m_sMat = param.szMat;
	m_sProvider = param.szFat;
	m_sDuctUse = param.szType;
}

int CFGBZDlg::GetDataRange(CArray<SPipeColor, SPipeColor>& arPipeColor)
{
	int iColor = 0;
	BOOL bIsV = TRUE;	// 流速

	iColor == 0 ? bIsV = TRUE : bIsV = FALSE;
	CString csSQL, csValue;
	csSQL.Format(_T("SELECT DISTINCT [MINVALUE], [MAXVALUE], [COLOR] FROM %s WHERE [ISVELOCITY] = %d ORDER BY [MINVALUE]"), _T("RangeValue"), bIsV);

	CUIIValueTable table;
	int iCount = m_pDbServer->GetSelData(csSQL, table);
	if (iCount > 0)
	{
		int i = 0;
		for (i = 0; i < iCount; i++)
		{
			CUIIValueRecord arRecord;
			table.GetValueRecord(i, arRecord);	// 得到一行记录

			CString scValue;
			SPipeColor sData;

			if (arRecord.GetValue(0, csValue))
				sData.m_dMinVal = _tstof(csValue);
			if (arRecord.GetValue(1, csValue))
				sData.m_dMaxVal = _tstof(csValue);
			if (arRecord.GetValue(2, csValue))
				sData.m_iColorIdx = _ttoi(csValue);

			arPipeColor.InsertAt(i, sData);
		}
	}
	return iColor;
}

BOOL CFGBZDlg::GetMediumInfo(CString& csPressure, CString& csMedium, CString& csTemperature,
							 CString& csHumidity, CString& csDensity, CString& csStickiness)
{
	BOOL bRet = TRUE;
	bRet &= m_mapCfg.Lookup(_T("csPressure"), csPressure);
	bRet &= m_mapCfg.Lookup(_T("csMedium"), csMedium);
	bRet &= m_mapCfg.Lookup(_T("csTemperature"), csTemperature);
	bRet &= m_mapCfg.Lookup(_T("csHumidity"), csHumidity);
	bRet &= m_mapCfg.Lookup(_T("csDensity"), csDensity);
	bRet &= m_mapCfg.Lookup(_T("csStickiness"), csStickiness);

	return bRet;
}

void CFGBZDlg::CheckSysParameter(BOOL bInit)
{
	// 寻找所有不同的宽高，并排序
	CArray<SDuctSectSpec, SDuctSectSpec> arMatSpec;
	m_arSizeRect.RemoveAll();

	GetDuctSectSpecArray(arMatSpec, 0);

	double dHeight = 0.0, dWidth = 0.0;
	for (int i = 0; i < arMatSpec.GetSize(); i++)
	{
		dHeight = fabs(arMatSpec.GetAt(i).m_dHeight);
		dWidth = fabs(arMatSpec.GetAt(i).m_dWidth);
		for (int j = 0; j < m_arSizeRect.GetSize(); j++)
		{
			if (fabs(dHeight - m_arSizeRect.GetAt(j)) < 1.0) 
			{
				break;
			}
			else if (dHeight < m_arSizeRect.GetAt(j)) 
			{
				m_arSizeRect.InsertAt(j, dHeight);
				break;
			}
		}
		if (j == m_arSizeRect.GetSize()) 
			m_arSizeRect.Add(dHeight);

		for (j = 0; j < m_arSizeRect.GetSize(); j++)
		{
			if (fabs(dWidth - m_arSizeRect.GetAt(j)) < 1.0) 
			{
				break;
			}
			else if (dWidth < m_arSizeRect.GetAt(j)) 
			{
				m_arSizeRect.InsertAt(j, dWidth);
				break;
			}			
		}
		if (j == m_arSizeRect.GetSize()) 
			m_arSizeRect.Add(dWidth);
	}

	// 寻找所有不同的直径，并排序
	arMatSpec.RemoveAll();
	m_arSizeCir.RemoveAll();
	GetDuctSectSpecArray(arMatSpec, 1);

	for (i = 0; i < arMatSpec.GetSize(); i++)
	{
		dHeight = fabs(arMatSpec.GetAt(i).m_dHeight);
		for (int j = 0; j < m_arSizeCir.GetSize(); j++)
		{
			if (fabs(dHeight - m_arSizeCir.GetAt(j)) < 1.0) 
			{
				break;
			}
			else if ((dHeight - m_arSizeCir.GetAt(j)) < 1.0) 
			{
				m_arSizeCir.InsertAt(j, dHeight);
				break;
			}

		}
		if (j == m_arSizeCir.GetSize()) 
			m_arSizeCir.Add(dHeight);		
	}

	CString csPre, csMed, csTem, csHumi, csDensity, csMoveVis;
	GetMediumInfo(csPre, csMed, csTem, csHumi, csDensity, csMoveVis);
	m_cHydraulic.SetDensity(_tstof(csDensity));	 // 密度	
	m_cHydraulic.SetMoveVis(_tstof(csMoveVis) * 1.e-6);	// 运动黏度
	m_dDencity = _tstof(csDensity);

	// 流速，R
	m_nOption =	GetDataRange(m_arPipeColor);
	
	SetSectWidthList();
	SetSectHeightList();

	ReCalWidthVR();
	ReCalHeightVR();
}

// 设置截面宽信息
void CFGBZDlg::SetSectWidthList()
{
	CString sInfo;
	if (0 == m_nOption)
		sInfo = _T("V");
	else
		sInfo = _T("R");

	// 填充截面宽列表信息
	CStringArray arHeadWidth;
	CByteArray   arColsWidth;
	arHeadWidth.Add(_T("宽(W)"));
	arColsWidth.Add(58);
	arHeadWidth.Add(sInfo);
	arColsWidth.Add(42);

	// 删除列表框中现有有列、数据
	m_wndLstWidth.DeleteColumn(0);
	m_wndLstWidth.DeleteColumn(0);
	m_wndLstWidth.DeleteAllItems();
	m_wndLstWidth.InitCtrl(&arHeadWidth, &arColsWidth);

	// 初始化截面宽
	CStringArray arItem;
	CString csSize;
	for (int i = 0; i < m_arSizeRect.GetSize(); i++)
	{
		arItem.RemoveAll();
		csSize.Format(_T("%.0f"), m_arSizeRect.GetAt(i));
		arItem.Add(csSize);
		arItem.Add(_T("0.0"));
		m_wndLstWidth.AddItem(&arItem);			
	}	
}

// 设置截面高信息
void CFGBZDlg::SetSectHeightList()
{
	CString sInfo;
	if (0 == m_nOption)
		sInfo = _T("V");
	else 
		sInfo = _T("R");

	// 填充截面高列表信息
	CStringArray arHeadHeight;
	CByteArray   arColsHeight;
	arHeadHeight.Add(_T("高(H)"));
	arColsHeight.Add(58);
	arHeadHeight.Add(sInfo);
	arColsHeight.Add(42);

	// 删除列表框中现有有列、数据
	m_wndLstHeight.DeleteColumn(0);
	m_wndLstHeight.DeleteColumn(0);
	m_wndLstHeight.DeleteAllItems();
	m_wndLstHeight.InitCtrl(&arHeadHeight, &arColsHeight);

	// 初始化截面高数据
	CStringArray arItem;
	CString csSize;
	for (int i = 0; i < m_arSizeRect.GetSize(); i++)
	{
		arItem.RemoveAll();
		csSize.Format(_T("%.0f"), m_arSizeRect.GetAt(i));
		arItem.Add(csSize);
		arItem.Add(_T("0.0"));
		m_wndLstHeight.AddItem(&arItem);			
	}	
}

double CFGBZDlg::ChangeFluxTo(double dFluxOld, EFluxDesc eType, double dDencity)
{
	if (dDencity < 1.0e-3)
		return 0.0;

	switch(eType)
	{
	case eKgH:		// kg/h
		return dFluxOld * dDencity;
	case eKgS:		// kg/s
		return dFluxOld * dDencity / 3600.0;
	case eCobeH:    // m^3/h
		return dFluxOld;
	case eCobeS:	// m^3/s
		return dFluxOld / 3600.0;		
	case eLH:		// L/h
		return dFluxOld * 1000.0;	
	case eLS:		// L/s
		return dFluxOld / 3.6;
	default:
		break;
	}
	return 0.0;
}

// 根据当前输入的风量，换算成以(m^3/h)为单位	
double CFGBZDlg::ChangeFluxBy(double dFluxOld, EFluxDesc eType, double dDencity)
{
	if (dDencity < 1.0e-3)
		return 0.0;
	
	switch(eType)
	{
	case eKgH:		// kg/h
		return dFluxOld / dDencity;
	case eKgS:		// kg/s
		return dFluxOld / dDencity * 3600.0;
	case eCobeH:    // m^3/h
		return dFluxOld;
	case eCobeS:	// m^3/s
		return dFluxOld * 3600.0;		
	case eLH:		// L/h
		return dFluxOld / 1000.0;	
	case eLS:		// L/s
		return dFluxOld * 3.6;
	default:
		break;
	}
	return 0.0;
}

// 要求arSize从小到大排列
double CFGBZDlg::GetNormalSize( const double &dSize, CArray<double, double>& arSize, BOOL bLittleHigh )
{
	double dRetSize(0.0);
	for (int i = 0; i < (int)arSize.GetSize(); i++)
	{
		if (arSize.GetAt(i) - dSize >= 0)
		{
			if (bLittleHigh)
				dRetSize = arSize.GetAt(i);	
			else
			{
				if (i - 1 >= 0)
					dRetSize = arSize.GetAt(i - 1);
				else 
					dRetSize = arSize.GetAt(i);
			}
			break;
		}
	}
	return dRetSize;
}

int CFGBZDlg::FindInsertIndex(double &dDifferArea, double &dBestArea, CArray<SDuctSectSpec, SDuctSectSpec>& arRmdSize)
{
	int nInsertIndex(0);

	int nCount = (int)arRmdSize.GetSize();
	double dDiffer(0.0);
	double dWidth(0.0), dHeight(0.0);
	int i;
	for (i = 0; i < nCount; i++)
	{
		dWidth = arRmdSize[i].m_dWidth;
		dHeight = arRmdSize[i].m_dHeight;
		dDiffer = fabs(dWidth * dHeight - dBestArea);

		// 要插入的面积,小于数组元素的面积时,才此位置插入
		if (dDifferArea < dDiffer)
		{
			nInsertIndex = i;
			break;
		}
	}
	// 没找到,插入的面积最大,放在最后,返回-1
	if (i >= nCount)
		return -1;

	return nInsertIndex;
}

int CFGBZDlg::GetDuctSectSpecArray(CArray<SDuctSectSpec, SDuctSectSpec>& arMatSpec, const int iSect)
{
	if (NULL == m_pDbServer)
		return 0;

	int iCount = 0;
	arMatSpec.RemoveAll();
	CString csSQL;
	csSQL.Format(_T("SELECT DISTINCT [HEIGHT], [WIDTH] FROM %s WHERE [ISCIRCLE] = %d ORDER BY [HEIGHT]"), _T("DuctMaterial"), iSect);

	CUIIValueTable table;
	iCount = m_pDbServer->GetSelData(csSQL, table);
	if (iCount > 0)
	{
		int i = 0;
		for (i = 0; i < iCount; i++)
		{
			CUIIValueRecord record;
			CString csValue;
			SDuctSectSpec sData;

			table.GetValueRecord(i, record);
			if (record.GetValue(0, csValue))
				sData.m_dHeight = _tstof(csValue);
			if (record.GetValue(1, csValue))
				sData.m_dWidth = _tstof(csValue);

			arMatSpec.InsertAt(i, sData);
		}
	}
	return iCount;
}

void CFGBZDlg::CalSizeByFlux()
{
	m_dFlux = ChangeFluxBy(_tstof(m_csFlux), m_eFluxType, m_dDencity);

	// 从数据库读入风管推荐风速(m/s)
	CString sData(_T(""));
	sData.Format(_T("SELECT [VALUE] FROM %s WHERE [KEY] = '%s'"), _T("OtherConfig"), _T("RecommendWindSpeed"));

	if (m_pDbServer->GetSelData(sData, m_sRmdVg) <= 0)
		m_sRmdVg = _T("8");

	double dVg = _tstof(m_sRmdVg);

	// 计算推荐管径dBestDn
	double dBestDn(0.0);
	dBestDn = sqrt( 4 * m_dFlux / (3600 * PI * dVg)) * 1000;

	// 先计算圆形的推荐尺寸
	int nMenuIndex(1);
	double dlittleLow(0.0), dlittleHigh(0.0);
	dlittleLow = GetNormalSize(dBestDn, m_arSizeCir, FALSE);
	dlittleHigh = GetNormalSize(dBestDn, m_arSizeCir, TRUE);
	if (dlittleHigh > 0.0)
	{
		if (dlittleLow != dlittleHigh)
		{
			sData.Format(_T("%.0f"), dlittleLow);
			m_SizeMenu.AppendMenu(MF_STRING, ID_USER_MENU + nMenuIndex++, sData);
		}

		sData.Format(_T("%.0f"), dlittleHigh);
		m_SizeMenu.AppendMenu(MF_STRING, ID_USER_MENU + nMenuIndex++, sData);
		m_SizeMenu.AppendMenu(MF_SEPARATOR);
	}

	double dBestArea = m_dFlux / (3600 * dVg);
	dBestArea *= 1000 * 1000;

	// 读取矩形截面全部尺寸列表
	CArray<SDuctSectSpec, SDuctSectSpec> arMatSpec;

	arMatSpec.RemoveAll();
	GetDuctSectSpecArray(arMatSpec, 0);

	// 遍历尺寸列表,按与最佳面积的绝对差值排序
	CArray<SDuctSectSpec, SDuctSectSpec> arRmdSize;
	int i;
	int nInsertIndex(0);
	double dWidth(0.0), dHeight(0.0);
	double dWidthTmp(0.0), dHeightTmp(0.0);
	double dDiffer(0.0);
	for (i = 0; i < (int)arMatSpec.GetSize(); i++)
	{
		dWidthTmp = arMatSpec[i].m_dWidth;
		dHeightTmp = arMatSpec[i].m_dHeight;
		// 尺寸要求: 宽大于高,宽高比不超过4:1
		if (dWidthTmp < dHeightTmp || dWidthTmp > dHeightTmp * 4)
			continue;

		// 与最佳面积的绝对差值
		dDiffer = fabs(dWidthTmp * dHeightTmp - dBestArea);

		nInsertIndex = FindInsertIndex(dDiffer, dBestArea, arRmdSize);
		if (nInsertIndex == -1)
			arRmdSize.Add(arMatSpec[i]);
		else
			arRmdSize.InsertAt(nInsertIndex, arMatSpec[i]);
	}

	// 只要前四个差距最小的尺寸
	for (i = 0; i < (int)arRmdSize.GetSize(); i++)
	{
		if ( i < 4 )
		{
			sData.Format(_T("%.0f*%.0f"), arRmdSize[i].m_dWidth, arRmdSize[i].m_dHeight);
			m_SizeMenu.AppendMenu(MF_STRING, ID_USER_MENU + nMenuIndex++, sData);
		}
		else
			break;
	}

	// 选中上一次选择的尺寸
	CString csMenuText(_T(""));
	for (i = 0; i < (int)m_SizeMenu.GetMenuItemCount(); i++)
	{
		m_SizeMenu.GetMenuString(ID_USER_MENU + i, csMenuText, MF_BYCOMMAND);
		if (m_sRmdSize == csMenuText)
		{
			m_SizeMenu.CheckMenuItem(ID_USER_MENU + i, MF_CHECKED);
			break;
		}
	}
}

void CFGBZDlg::SetFluxType( EFluxDesc eFluxDesc )
{
	m_eFluxType = eFluxDesc;

	switch(m_eFluxType) 
	{
	case eKgH:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(Kg/h):"));
		break;
	case eKgS:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(Kg/s):"));
		break;
	case eCobeH:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(m^3/h):"));
		break;
	case eCobeS:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(m^3/s):"));
		break;
	case eLH:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(L/h):"));
		break;
	default:
		GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(L/s):"));
		break;
	}

	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择的单位是kg/h
void CFGBZDlg::OnKgH()
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(Kg/h):"));
	m_eFluxType = eKgH;
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择的单位是kg/s
void CFGBZDlg::OnKgS() 
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(Kg/s):"));
	m_eFluxType = eKgS;	
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择的单位是L/h
void CFGBZDlg::OnLH() 
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(L/h):"));
	m_eFluxType = eLH;	
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择单位是L/s
void CFGBZDlg::OnLS()
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(L/s):"));
	m_eFluxType = eLS;	
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择单位是m^3/s
void CFGBZDlg::OnCobeS() 
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(m^3/s):"));
	m_eFluxType = eCobeS;	
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

// 选择单位是m^3/h
void CFGBZDlg::OnCobeH() 
{
	GetDlgItem(IDC_BTN_FLUX)->SetWindowText(_T("▼风量(m^3/h):"));
	m_eFluxType = eCobeH;	
	m_csFlux.Format(_T("%.3f"), ChangeFluxTo(m_dFlux, m_eFluxType, m_dDencity));
	UpdateData(FALSE);
}

void CFGBZDlg::OnBnClickedBtnPopDnMenu()
{
	CRect rc;
	CWnd *pBtnWnd = GetDlgItem(IDC_BTN_POP_DN_MENU);
	if (NULL == pBtnWnd)
		return;
	pBtnWnd->GetWindowRect(rc);

	m_SizeMenu.DestroyMenu();

	m_SizeMenu.CreatePopupMenu();

	CalSizeByFlux();

	m_SizeMenu.TrackPopupMenu(TPM_LEFTALIGN | TPM_VERTICAL,
		rc.left, rc.bottom, this, &rc);
}


int CFGBZDlg::GetVRDataRangeFromMDB(CArray<SPipeColor, SPipeColor>& arDataRange, BOOL bVData)
{
	int iRet = 0;
	CString csSQL;

	if (m_pDbServer != NULL)
	{
		csSQL.Format(_T("SELECT DISTINCT [MINVALUE], [MAXVALUE], [COLOR] FROM %s WHERE [ISVELOCITY] = %d ORDER BY [MINVALUE]"), _T("RangeValue"), bVData);
		CUIIValueTable table;
		iRet = m_pDbServer->GetSelData(csSQL, table);
		if (iRet > 0)
		{
			int i = 0;
			for (i = 0; i < iRet; i++)
			{
				CUIIValueRecord arRecord;
				table.GetValueRecord(i, arRecord);	// 得到一行记录

				CString csValue;
				SPipeColor sData;
				if (arRecord.GetValue(0, csValue))
					sData.m_dMinVal = _tstof(csValue);
				if (arRecord.GetValue(1, csValue))
					sData.m_dMaxVal = _tstof(csValue);
				if (arRecord.GetValue(2, csValue))
					sData.m_iColorIdx = _ttoi(csValue);

				arDataRange.InsertAt(i, sData);
			}
		}
	}

	return iRet;
}

BOOL CFGBZDlg::UpdataVRDataRangeArray()
{
	BOOL bRet = TRUE;
	m_arVRange.RemoveAll();

	bRet &= GetVRDataRangeFromMDB(m_arVRange);
	m_arRRange.RemoveAll();
	bRet &= GetVRDataRangeFromMDB(m_arRRange, FALSE);

	return bRet;
}

void CFGBZDlg::ReCalHeightVR()
{
	UpdateData(TRUE);
	
	if (m_nSecType == 0)//矩形
	{
		m_cHydraulic.SetShape(FALSE);
	}
	else
	{
		return;
	}
	m_cHydraulic.SetFlux(m_dFlux);			// 流量
	m_cHydraulic.SetWidth(_tstof(m_csWidth));// 宽
	
	int nLen = m_wndLstHeight.GetItemCount();	
	double dHeight = 0.0, dData = 0.0;
	CString csVR;
	CStringArray arItem;
	for (int i = 0; i < nLen; i++)
	{
		dHeight = _tstof(m_wndLstHeight.GetItemText(i, 0));
		m_cHydraulic.SetHeight(dHeight);		
		m_cHydraulic.CalFricLoss();
		
		if (0 == m_nOption)		// 显示风速
			dData = m_cHydraulic.GetVel();					
		else					// 显示R
			dData = m_cHydraulic.GetR();		
		csVR.Format(_T("%.2f"), dData);	
		m_wndLstHeight.SetItemText(i, 1, csVR);
	}
	
	// 重新显示当前流速和R
	m_cHydraulic.SetHeight(_tstof(m_csHeight));	
	m_cHydraulic.CalFricLoss();
	csVR.Format(_T("V(m/s) = %.2f"), m_cHydraulic.GetVel());	
	GetDlgItem(IDC_STC_V)->SetWindowText(csVR);
	m_dV = m_cHydraulic.GetVel();

	csVR.Format(_T("R(Pa/m) = %.2f"), m_cHydraulic.GetR());
	GetDlgItem(IDC_STC_R)->SetWindowText(csVR);	
	m_dR = m_cHydraulic.GetR();

	csVR.Format(_T("Py(Pa) = %.2f"), m_cHydraulic.GetFricLoss());
	GetDlgItem(IDC_STC_P)->SetWindowText(csVR);
	m_dPy = m_cHydraulic.GetFricLoss();

	UpdataVRDataRangeArray();
}

void CFGBZDlg::ReCalWidthVR()
{
	UpdateData(TRUE);

	if (m_nSecType == 0)//矩形
	{
		m_cHydraulic.SetShape(FALSE);
	}
	else
	{
		m_cHydraulic.SetShape(TRUE);
	}
	m_cHydraulic.SetFlux(m_dFlux);				// 流量
	m_cHydraulic.SetHeight(_tstof(m_csHeight));		// 高

	int nLen = m_wndLstWidth.GetItemCount();	
	double dWidth = 0.0, dData = 0.0;
	CString csVR;
	CStringArray arItem;
	for (int i = 0; i < nLen; i++)
	{
		dWidth = _tstof(m_wndLstWidth.GetItemText(i, 0));
		if (m_nSecType == 0)//矩形
		{
			m_cHydraulic.SetWidth(dWidth);
		}
		else
		{
			m_cHydraulic.SetDia(dWidth);
		}
		m_cHydraulic.CalFricLoss();
		
		if (0 == m_nOption)		// 显示风速
			dData = m_cHydraulic.GetVel();					
		else					// 显示R
			dData = m_cHydraulic.GetR();		
		csVR.Format(_T("%.2f"), dData);	
		m_wndLstWidth.SetItemText(i, 1, csVR);
	}

	// 重新显示当前流速和R
	if (m_nSecType == 0)//矩形
	{
		m_cHydraulic.SetWidth(_tstof(m_csWidth));
	}
	else
	{
		m_cHydraulic.SetDia(_tstof(m_csWidth));
	}
	m_cHydraulic.CalFricLoss();
	csVR.Format(_T("V(m/s) = %.2f"), m_cHydraulic.GetVel());
	GetDlgItem(IDC_STC_V)->SetWindowText(csVR);
	m_dV = m_cHydraulic.GetVel();

	UpdataVRDataRangeArray();	

	csVR.Format(_T("R(Pa/m) = %.2f"), m_cHydraulic.GetR());
	GetDlgItem(IDC_STC_R)->SetWindowText(csVR);	
	m_dR = m_cHydraulic.GetR();

	csVR.Format(_T("Py(Pa) = %.2f"), m_cHydraulic.GetFricLoss());
	GetDlgItem(IDC_STC_P)->SetWindowText(csVR);
	m_dPy = m_cHydraulic.GetFricLoss();
}

// 改变截面宽
void CFGBZDlg::OnChangeEdtSectWidth() 
{
	// 调整R值
	ReCalHeightVR();

	if (m_nSecType == 0) //矩形
	{
		// 取消原有的选中状态
		int iSelected = m_wndLstWidth.GetNextItem(-1, LVNI_SELECTED);
		if (iSelected > -1 && iSelected < m_arSizeRect.GetSize())
		{
			m_wndLstWidth.SetItemState(iSelected, 0, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
		}

		// 显示对应的尺寸
		double dData = _tstof(m_csWidth);
		for (int i = 0; i < m_arSizeRect.GetSize(); i++)
		{
			if (m_arSizeRect.GetAt(i) - dData >= 0.0 || i == m_arSizeRect.GetSize() - 1)
			{
				m_wndLstWidth.EnsureVisible(0, TRUE);
				if (i + 1 > m_arSizeRect.GetSize() - 1)
				{
					m_wndLstWidth.EnsureVisible((int)m_arSizeRect.GetSize() - 1, TRUE);
				}
				else
				{
					m_wndLstWidth.EnsureVisible(i + 1, TRUE);
				}

				// 设置选中状态
				if (fabs(dData - m_arSizeRect.GetAt(i)) < 1)
				{
					m_wndLstWidth.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
				}

				break;
			}
		}
	}
	else
	{
		// 取消原有的选中状态
		int iSelected = m_wndLstWidth.GetNextItem(-1, LVNI_SELECTED);
		if (iSelected > -1 && iSelected < m_arSizeCir.GetSize())
		{
			m_wndLstWidth.SetItemState(iSelected, 0, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
		}

		// 显示对应的尺寸
		double dData = _tstof(m_csWidth);
		for (int i = 0; i < m_arSizeCir.GetSize(); i++)
		{
			if ( m_arSizeCir.GetAt(i) - dData >= 0.0 || i == m_arSizeCir.GetSize() - 1)
			{
				m_wndLstWidth.EnsureVisible(0, TRUE);
				if (i + 1 > m_arSizeCir.GetSize() - 1)
				{
					m_wndLstWidth.EnsureVisible((int)m_arSizeCir.GetSize() - 1, TRUE);
				}
				else
				{
					m_wndLstWidth.EnsureVisible(i + 1, TRUE);
				}

				// 设置选中状态
				if (fabs(dData - m_arSizeCir.GetAt(i)) < 1)
				{
					m_wndLstWidth.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
				}

				break;
			}
		}
	}
}

void CFGBZDlg::OnChangeEdtSectHeight() 
{
	ReCalWidthVR();

	// 取消原有的选中状态
	int iSelected = m_wndLstHeight.GetNextItem(-1, LVNI_SELECTED);
	if (iSelected > -1 && iSelected < m_arSizeRect.GetSize())
	{
		m_wndLstHeight.SetItemState(iSelected, 0, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
	}

	// 显示对应的尺寸
	double dData = _tstof(m_csHeight);
	for (int i = 0; i < m_arSizeRect.GetSize(); i++)
	{
		if (m_arSizeRect.GetAt(i) - dData >= 0.0 || i == m_arSizeRect.GetSize() - 1)
		{
			// 将选中尺寸显示在中央
			m_wndLstHeight.EnsureVisible(0, TRUE);
			if (i + 1 > m_arSizeRect.GetSize() - 1)
			{
				m_wndLstHeight.EnsureVisible((int)m_arSizeRect.GetSize() - 1, TRUE);
			}
			else
			{
				m_wndLstHeight.EnsureVisible(i + 1, TRUE);
			}

			// 设置选中状态
			if (fabs(dData - m_arSizeRect.GetAt(i)) < 1)
			{
				m_wndLstHeight.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED|LVS_EX_FULLROWSELECT);
			}

			break;
		}
	}
}

// 单击截面（高），列表框
void CFGBZDlg::OnClickLstHeight(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// 当前选择项的的索引
	int iCurSelect = 0;
	POSITION pos  = m_wndLstHeight.GetFirstSelectedItemPosition();
	iCurSelect = m_wndLstHeight.GetNextSelectedItem(pos);
	// 获得高
	CString sHeight;
	sHeight = m_wndLstHeight.GetItemText(iCurSelect, 0);


	GetDlgItem(IDC_EDT_SECTHEIGHT)->SetWindowText(sHeight);

	ReCalWidthVR();

	*pResult = 0;
}

// 单击截面宽列表框
void CFGBZDlg::OnClickLstWidth(NMHDR* pNMHDR, LRESULT* pResult) 
{
	// 当前选择项的的索引
	int iCurSelect = 0;
	POSITION pos  = m_wndLstWidth.GetFirstSelectedItemPosition();
	iCurSelect = m_wndLstWidth.GetNextSelectedItem(pos);

	CString sWidth;
	sWidth = m_wndLstWidth.GetItemText(iCurSelect, 0);

	GetDlgItem(IDC_EDT_SECTWIDTH)->SetWindowText(sWidth);	

	if (m_nSecType == 0)//矩形
	{
		ReCalHeightVR();
	}
	else if (m_nSecType == 1)//圆形
	{
		ReCalWidthVR();
	}
	*pResult = 0;
}

void CFGBZDlg::OnBnClickedButChange()
{
	UpdateData(TRUE);
	CString cs = m_csWidth;
	m_csWidth = m_csHeight;
	m_csHeight = cs;
	UpdateData(FALSE);

	ReCalWidthVR();
	ReCalHeightVR();

	OnChangeEdtSectWidth();
	OnChangeEdtSectHeight();
}

BOOL CFGBZDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
	if (m_SizeMenu.GetMenuItemCount() > 0)
	{
		UINT menuID = LOWORD(wParam);
		if (menuID > ID_USER_MENU && menuID < ID_USER_MENU + m_SizeMenu.GetMenuItemCount())
		{
			CString csCommand(_T(""));
			m_SizeMenu.GetMenuString(menuID, csCommand, MF_BYCOMMAND);
			if (!csCommand.IsEmpty())
			{
				// 清除原有标记
				CString csMenuText(_T(""));
				for ( UINT i = 1; i < m_SizeMenu.GetMenuItemCount(); i++)
				{
					m_SizeMenu.CheckMenuItem(ID_USER_MENU + i, MF_UNCHECKED);
				}

				// 给选中的尺寸加个标记,并记录当前尺寸
				m_SizeMenu.CheckMenuItem(menuID, MF_CHECKED);
				csCommand.TrimLeft();
				csCommand.TrimRight();
				m_sRmdSize = csCommand;

				// 解析菜单命令,找到选中的尺寸
				int nPos = csCommand.Find(_T("*"));
				// 圆形尺寸
				if (-1 == nPos)
				{
					m_wndCmbSect.SelectString(-1, _T("圆形"));
					m_csWidth = csCommand;
					UpdateData(FALSE);

					OnSelchangeCmbSect();
				}
				// 矩形尺寸
				else
				{
					m_wndCmbSect.SelectString(-1, _T("矩形"));
					m_csWidth = csCommand.Left(nPos);
					m_csHeight = csCommand.Right(csCommand.GetLength() - nPos -1);
					UpdateData(FALSE);

					OnSelchangeCmbSect();
				}
			}
		}
	}
	return CDialog::OnCommand(wParam, lParam);;
}

// 设置截直径信息,(截面类型为圆形)
void CFGBZDlg::SetSectDia()
{
	CString sInfo;
	if (0 == m_nOption)
		sInfo = _T("V");
	else
		sInfo = _T("R");

	// 填充截面宽列表信息
	CStringArray arHeadWidth;
	CByteArray   arColsWidth;
	arHeadWidth.Add(_T("宽(W)"));
	arColsWidth.Add(58);
	arHeadWidth.Add(sInfo);
	arColsWidth.Add(42);

	// 删除列表框中现有有列、数据
	m_wndLstWidth.DeleteColumn(0);
	m_wndLstWidth.DeleteColumn(0);
	m_wndLstWidth.DeleteAllItems();
	m_wndLstWidth.InitCtrl(&arHeadWidth, &arColsWidth);

	// 初始化截面宽
	CStringArray arItem;
	CString csSize;
	for (int i = 0; i < m_arSizeCir.GetSize(); i++)
	{
		arItem.RemoveAll();
		csSize.Format(_T("%.0f"), m_arSizeCir.GetAt(i));
		arItem.Add(csSize);
		arItem.Add(_T("0.0"));
		m_wndLstWidth.AddItem(&arItem);			
	}
}

void CFGBZDlg::OnSelchangeCmbSect() 
{
	UpdateData();

	TCHAR szBuf[MAX_PATH];
	HDITEM hItem;
	hItem.mask = HDI_TEXT;
	hItem.pszText = szBuf;
	hItem.cchTextMax = MAX_PATH;


	// 截面类型为矩形
	if (m_nSecType == 0)//矩形 
	{
		GetDlgItem(IDC_EDT_SECTHEIGHT)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_LST_HEIGHT)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_BUT_CHANGE)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_STATIC_WIDTH)->SetWindowText(_T("宽度(毫米)"));


		m_wndLstWidth.GetHeaderCtrl()->GetItem(0,&hItem);

		_tcscpy(szBuf,_T("宽(W)"));
		m_wndLstWidth.GetHeaderCtrl()->SetItem(0,&hItem);

		SetSectWidthList();
		SetSectHeightList();
	}
	else if (m_nSecType == 1)//圆形
	{
		GetDlgItem(IDC_EDT_SECTHEIGHT)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_LST_HEIGHT)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_BUT_CHANGE)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_STATIC_WIDTH)->SetWindowText(_T("直径(毫米)"));

		m_wndLstWidth.GetHeaderCtrl()->GetItem(0,&hItem);

		_tcscpy(szBuf,_T("直径(W)"));
		m_wndLstWidth.GetHeaderCtrl()->SetItem(0,&hItem);

		SetSectDia();
	}
	else // 其他形状 
	{
	}

	ReCalWidthVR();
	ReCalHeightVR();
	OnChangeEdtSectWidth();

	if (m_nSecType == 0)//矩形 
	{
		OnChangeEdtSectHeight();
	}
}

void CFGBZDlg::OnEnChangeEdit2()
{
	UpdateData();
	if (m_nSecType == 0)//矩形
	{
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csHeight);
	}
	else
	{
		m_dCenEl = m_dTopEl - 0.5 * _ttof(m_csWidth);
	}
	UpdateData(FALSE);
}

//系统管理
void CFGBZDlg::OnBnClickedButton1()
{
	CStringArray arSyses;
	if (!DuctlineTools::setLayerSys(m_pDbServer, arSyses))
	{
		return;
	}

	m_wndCmbPipeType.ResetContent();
	for (int i = 0; i < arSyses.GetSize(); i++)
	{
		m_wndCmbPipeType.AddString(arSyses.GetAt(i));
	}

	if (arSyses.GetSize() > 0)
	{
		m_wndCmbPipeType.SetCurSel(0);
		m_wndCmbPipeType.GetLBText(0, m_sDuctUse);
	}
}