#include "stdafx.h"
#include "LayPinDlg.h"
#include "LightningRodData.h"
#include "ThunderCaculate.h"
#include "dbxutil.h"
#include "dbgroup.h"
#include "ThunderDbReactor.h"
#include "ThunderCmdGroup.h"
#include "CreateWordApp.h"
#include "TReactorAssociate.h"
#include "TThunderInsertPreviewJig.h"
#include "GroupHelp.h"
#include "ktsetting.h"

#include <list>
#include <vector>
#include <algorithm>

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

CLayPinDlg::CLayPinDlg(const AcDbObjectId& entId,BOOL bIsModel,CWnd* pParent)
: CDialog(CLayPinDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CLayPinDlg)
	m_strTextHigh = _T("3.0");
	m_strBlockScale = _T("1");
	m_idThunder = entId;
	m_bIsModel = bIsModel;
	m_bTipChange = FALSE;
	m_bValid = FALSE;
	m_pDrawThunder = NULL;
	m_pReactor = NULL;
	m_pDrawThunder = NULL;
	m_sGroupNo = _T("1");
	m_sProvider = _T("深圳雷晟专业防雷器厂");
	//}}AFX_DATA_INIT
}

CLayPinDlg::~CLayPinDlg()
{

}

void CLayPinDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CLayPinDlg)
	DDX_Control(pDX, IDC_GROUP_EXPLAIN, m_btnGroupExplain);
	DDX_Text(pDX, IDC_EDIT_TEXTHIGH, m_strTextHigh);
	DDX_Text(pDX, IDC_EDIT_BLOCKSCALE, m_strBlockScale);
	DDX_Text(pDX,IDC_COMBO_RADIUS,m_strRadius);
	DDX_Text(pDX,IDC_EDIT_HEIGHT,m_strPinHeight);
	DDX_Control(pDX, IDC_THUNDER_HEIGHT_TIP, m_btnTip);
	DDX_Control(pDX, IDC_STATIC_NUMCUE, m_stcNumCue);
	DDX_Control(pDX, IDC_EDIT_SAFEHT, m_edtSafeHt);
	DDX_Control(pDX, IDC_RADIO_2D, m_radiShowType);
	DDX_Control(pDX, IDC_BUTTON_CANCEL, m_btnCancel);
	DDX_Control(pDX, IDC_BUTTON_UPDATE, m_btnUpdate);
	DDX_Control(pDX, IDC_EDIT_NUM, m_edtNumber);
	DDX_Control(pDX, IDC_EDIT_HEIGHT, m_edtHeight);
	DDX_Control(pDX, IDC_COMBO_RADIUS, m_cmbRadius);
	DDX_Control(pDX, IDC_LIST_SAFEHEIGHT, m_wndGrid);
	DDX_Control(pDX, IDC_SPIN_OPT, m_wndModulate);
	DDX_Control(pDX, IDC_SPIN_GROUP_NO, m_wndSpinGroupNo);
	DDX_Control(pDX, IDC_SPIN_TH, m_wndHT);
	DDX_Text(pDX, IDC_GROUP_NO, m_sGroupNo);
	DDX_Text(pDX, IDC_EDT_PRV,m_sProvider);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CLayPinDlg, CDialog)
	//{{AFX_MSG_MAP(CLayPinDlg)
	ON_WM_CLOSE()
	ON_WM_CTLCOLOR()
	ON_BN_CLICKED(IDC_BUTTON_UPDATE, OnButtonUpdate)
	ON_BN_CLICKED(IDC_BUTTON_CANCEL, OnButtonCancel)
	ON_EN_CHANGE(IDC_EDIT_NUM, OnChangeEditNum)
	ON_BN_CLICKED(IDC_RADIO_2D, OnLayer2d)
	ON_BN_CLICKED(IDC_RADIO_3D, OnLayer3d)
	ON_BN_CLICKED(IDC_THUNDER_HEIGHT_TIP, OnThunderHeightTip)
	ON_WM_DESTROY()
	ON_EN_CHANGE(IDC_GROUP_NO, OnChangeGroupNo)
	ON_MESSAGE(WM_ACAD_KEEPFOCUS, OnAcadKeepFocus)
    ON_BN_CLICKED(IDC_GROUP_EXPLAIN, OnGroupExplain)
	ON_BN_CLICKED(IDC_BUTTON1, OnAddHeight)
	ON_BN_CLICKED(IDC_BUTTON2, OnRemoveHeight)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

// 初始化模式对话框
void CLayPinDlg::InitModalDlg()
{
	SetWindowText(_T("单针编辑(滚球法)"));
	if (!GetCurrentExData(m_idThunder))
		return;

	if (m_arsXData.GetSize() < 4) return;

	// 编号，高度，半径, 维数, 图块系数, 字体高度
	m_strRadius = m_arsXData.GetAt(CThunderXData::eXDataPinRadius);
	m_strPinHeight = m_arsXData.GetAt(CThunderXData::eXDataPinHeight);
	m_strBlockScale = m_arsXData.GetAt(CThunderXData::eXDataBlockScale);
	m_strTextHigh = m_arsXData.GetAt(CThunderXData::eXDataTextHeight);

	UpdateData(FALSE);

	int nIndex = m_cmbRadius.SelectString(-1, m_arsXData.GetAt(CThunderXData::eXDataPinRadius));
	if (nIndex != LB_ERR)
	{
		m_cmbRadius.SetCurSel(nIndex);
	}
	else
	{
		m_cmbRadius.SetCurSel(0);
	}

	// 禁用维数选择
	m_radiShowType.EnableWindow(FALSE);

	((CButton*)GetDlgItem(IDC_RADIO_3D))->EnableWindow(FALSE);
	// 维数 1 : 2d
	if (_tstof(m_arsXData.GetAt(CThunderXData::eXDataPinIs2d)))
	{
		m_radiShowType.SetCheck(1);
	}
	else
	{
		((CButton*)GetDlgItem(IDC_RADIO_3D))->SetCheck(1);
	}

	// 保护高度
	CStringArray arProHt;
	if (GetProtectHeightFromObj(m_idThunder, arProHt))
	{
		m_wndGrid.DeleteAllItems();
		
		CString sValue;
		long lRowIndex = 0;
		for (int i = 0;i < arProHt.GetSize();++i)
		{
			if (!arProHt[i].IsEmpty())
			{
				lRowIndex = m_wndGrid.GetItemCount();
				sValue.Format(_T("%d"),lRowIndex + 1);

				m_wndGrid.InsertItem(lRowIndex,sValue);
				m_wndGrid.SetItemText(lRowIndex,1,arProHt[i]);
			}
		}
	}
	
	// 设置组名
	CThunderXData thundXData;
	CString sTemp;
	thundXData.GetXData(m_idThunder, TEL_GROUP_NO, sTemp);
	SetDlgItemText(IDC_GROUP_NO, sTemp);

	thundXData.GetXData(m_idThunder, TEL_ORDER_NUMBER, sTemp);
	m_edtNumber.SetWindowText(sTemp);
}

// 初始化非模式对话框
void CLayPinDlg::InitModalessDlg()
{
	ReadDlgData();
	UpdateData(FALSE);
	if (m_strRadius.IsEmpty())
	{
		m_cmbRadius.SetCurSel(0);
		UpdateDlgData(TRUE);
	}
 	
 	m_wndModulate.SetPos(1);
 	m_wndHT.SetPos(_ttoi(m_strTextHigh));
 	m_edtSafeHt.SetWindowText(_T("5"));
	if (m_strPinHeight.IsEmpty())
	{
		m_edtHeight.SetWindowText(_T("20"));
		UpdateDlgData(TRUE);
	}
 	
	m_radiShowType.SetCheck(1);
	CString sGroundRadius,sThunderHeight,sProHeight;

	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);    
	regProp.SetTopRootKey(HKEY_CURRENT_USER);
	regProp.GetValue(KEY_THU_LAST_GROUPNO,m_sGroupNo);

	UpdateData(FALSE);

	//滚球半径
	int nIndex = m_cmbRadius.SelectString(-1, m_strRadius);
	if (nIndex != LB_ERR)
	{
		m_cmbRadius.SetCurSel(nIndex);
	}
	else
	{
		m_cmbRadius.SetCurSel(0);
	}
	// 保护高度
	CStringArray arProHt;
	if (GetProtectHeightFromReg(arProHt))
	{
		m_wndGrid.DeleteAllItems();

		CString sValue;
		long lRowIndex = 0;
		for (int i = 0;i < arProHt.GetSize();++i)
		{
			if (arProHt[i].IsEmpty())
			{
				continue;
			}

			lRowIndex = m_wndGrid.GetItemCount();
			sValue.Format(_T("%d"),lRowIndex + 1);

			m_wndGrid.InsertItem(lRowIndex,sValue);
			m_wndGrid.SetItemText(lRowIndex,1,arProHt[i]);
		}
	}
	else // 增加默认
	{
		m_wndGrid.DeleteAllItems();
		m_wndGrid.InsertItem(0,_T("1"));
		m_wndGrid.SetItemText(0,1,_T("15"));
	}

	// 避雷针编号
	AcGeIntArray arNum;
	ThunderContainer->GetNumArrayBySpecGroup(m_sGroupNo, arNum);
	if (arNum.length() > 0)
	{
		CString sNum;
		sNum.Format(_T("%d"), arNum.last()+1);
		m_edtNumber.SetWindowText(sNum);
	}
	else
	{
		m_edtNumber.SetWindowText(_T("1"));
	}
}

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

	LPCTSTR pcmbOption[GRADENUM] = 
	{
		_T("30m"),
		_T("45m"),
		_T("60m"),
		_T("100m")
	};

	for (int i = 0;i < GRADENUM;i++)
	{
		m_cmbRadius.InsertString(-1, pcmbOption[i]);
	}
	m_wndModulate.SetRange32(SPNMIN,SPNMAX);
	m_wndSpinGroupNo.SetRange32(SPNMIN,SPNMAX);
	m_wndHT.SetRange(0, 100);
	UpdateData(FALSE);
	DisplayOrHideBtn(m_bIsModel);

	// 保护高度
	m_wndGrid.SetExtendedStyle(LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT | LVS_EX_SINGLEROW);
	m_wndGrid.InsertColumn(0,_T("编号"),LVCFMT_LEFT,120);
	m_wndGrid.InsertColumn(1,_T("保护高度"),LVCFMT_LEFT,200);
	m_wndGrid.SetColumnItemData(1,NULL,ET_Edit);

	m_bValid = TRUE;
	if (m_bIsModel)
	{
		InitModalDlg();		// 编辑(模式)
	}
	else
	{
		InitModalessDlg();  // 插入(非模式)
	}

	m_bitTip.LoadBitmap(IDB_BITMAPHELP);
	m_btnTip.SetBitmap(HBITMAP(m_bitTip));
	m_btnGroupExplain.SetBitmap(HBITMAP(m_bitTip));
	//CenterWindow();
	return TRUE; 
}

// 对话框的非模式形式
BOOL CLayPinDlg::DoModeless()
{
	if (!Create(IDD_LAYPINDLG)) 
	{
		return FALSE;
	}
	ShowWindow(SW_SHOW);
	return TRUE;
}

void CLayPinDlg::OnAddHeight()
{
	UpdateData();

	int nCnt = m_wndGrid.GetItemCount();

	CString sTxt;
	sTxt.Format(_T("%d"),nCnt + 1);
	m_wndGrid.InsertItem(nCnt,sTxt);

	double dH = _ttof(m_strPinHeight);
	dH -= 1;

	sTxt.Format(_T("%d"),(int)(dH));
	m_wndGrid.SetItemText(nCnt,1,sTxt);

	for (int i = 0;i < m_wndGrid.GetItemCount();i++)
	{
		sTxt.Format(_T("%d"),i + 1);
		m_wndGrid.SetItemText(i,0,sTxt);
	}
}

void CLayPinDlg::OnRemoveHeight()
{
	POSITION ps = m_wndGrid.GetFirstSelectedItemPosition();
	if (ps != NULL)
	{
		int nItem = m_wndGrid.GetNextSelectedItem(ps);
		if (nItem != -1)
		{
			m_wndGrid.DeleteItem(nItem);

			CString sTxt;
			for (int i = 0;i < m_wndGrid.GetItemCount();i++)
			{
				sTxt.Format(_T("%d"),i + 1);
				m_wndGrid.SetItemText(i,0,sTxt);
			}
		}
	}
}

HBRUSH CLayPinDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

	if (IDC_STATIC_NUMCUE == pWnd->GetDlgCtrlID())
	{
		if (m_bTipChange)
		{
			pDC->SetTextColor(RGB(255,0,0));
		}
		else
		{
			pDC->SetTextColor(RGB(0, 0, 0));
		}
	}
	return hbr;
}

LONG_PTR CLayPinDlg::OnAcadKeepFocus(UINT_PTR, LONG_PTR)
{
	CPoint pt;
	GetCursorPos(&pt);
	CRect rc;
	GetWindowRect(&rc);
	return (rc.PtInRect(pt) ? TRUE : FALSE);
}

void  CLayPinDlg::PostNcDestroy()
{
	CDialog::PostNcDestroy();
}

void CLayPinDlg::OnClose() 
{
	CDialog::OnClose();
	acedPostCommand(_T("\33\33"));
}

// 获取用户填写对话框数据
BOOL CLayPinDlg::GetDlgData(BOOL bIsUpdate)
{
	if (!AssertProtectHeight())
	{
		return FALSE;
	}

	UpdateData();
	// 首先输入的数据应合法
	// 编号，高度，半径, 维数
	CString strHeight = _T(""),strProHeight = _T("");
	CString strRadius = _T(""), strNum = _T(""), strRad = _T("");
	CString strExRadius = _T("");
	CString strTextHeight = _T(""),strBlockScale = _T("");

	// 保护高度arpro
	m_arProHeight.setLogicalLength(0);
	CString sValue;
	for (long p = 0;p < m_wndGrid.GetItemCount();++p)
	{
		sValue = m_wndGrid.GetItemText(p,1);
		if (!(_tstof(sValue) < -1e-6) && !sValue.IsEmpty())
		{
			m_arProHeight.append(_tstof(sValue));
		}
	}

	std::list<double> lstHT;
	for (int s = 0;s < m_arProHeight.length();++s)
	{
		lstHT.push_back(m_arProHeight[s]);
	}
	lstHT.sort();
	m_arProHeight.setLogicalLength(0);
	std::list<double>::iterator it;
	for (it = lstHT.begin();it != lstHT.end();++it)
	{
		m_arProHeight.append(*it);
	}

	m_edtHeight.GetWindowText(strHeight);

	// 避雷针高度应大于其保护高度
	for (int i = 0;i < m_arProHeight.length();++i)
	{
		if (m_arProHeight[i] >= _tstof(strHeight))
		{
			AfxMessageBox(_T("避雷针高度应大于其保护高度!"));
			return FALSE;
		}
	}

	// 滚球半径应大于避雷针高度
	m_cmbRadius.GetWindowText(strRadius);
	strRadius.TrimRight(_T("m"));
	if (_tstof(strHeight) >= _tstof(strRadius))
	{
		AfxMessageBox(_T("滚球半径应大于避雷针高度!"));
		return FALSE;
	}

	// 编号
	m_edtNumber.GetWindowText(strNum);

	strRad = _T("1");
	BOOL bIsRadiusChanged = FALSE;
	BOOL bIsBlockScaleChanged = FALSE;
	BOOL bIsTextHighChanged = FALSE;
	CThunderXData thunderXData;

	//如果是更新操作
	if (bIsUpdate)
	{
		//注销对话框
		CDialog::OnOK();

		//判断字体高度是否改变
		if (!thunderXData.GetIndexOf(m_idThunder, strTextHeight, CThunderXData::eXDataTextHeight, TEL_THUNDER_BASEINFOR))
		{
			return FALSE;
		}
		if (m_strTextHigh != strTextHeight && bIsUpdate)
		{
			bIsTextHighChanged = TRUE;
		}
		
		//判断图块系数是否改变
		if (!thunderXData.GetIndexOf(m_idThunder, strBlockScale, CThunderXData::eXDataBlockScale, TEL_THUNDER_BASEINFOR))
		{
			return FALSE;
		}
		if (m_strBlockScale != strBlockScale && bIsUpdate)
		{
			bIsBlockScaleChanged = TRUE;
		}
	}

	AcDbObjectId idRef = AcDbObjectId::kNull;
	if (bIsUpdate)
	{
		idRef = m_idThunder;
	}
	else
	{
		AcDbObjectIdArray arIDThun;
		ThunderContainer->GetGroupThunder(m_sGroupNo, arIDThun);
		if (arIDThun.length() > 0)
		{
			idRef = arIDThun.first();
		}
	}

	
	if (idRef.isValid())
	{
		if (!thunderXData.GetIndexOf(idRef, strExRadius, CThunderXData::eXDataPinRadius, TEL_THUNDER_BASEINFOR))
			return FALSE;
		strExRadius.TrimRight(_T("m"));
		if (strExRadius.CompareNoCase(strRadius))
		{
			bIsRadiusChanged = TRUE;
		}
	}

	//用户选择"字高"和"图块"系数的更新方式
	if (bIsTextHighChanged || bIsBlockScaleChanged)
	{
		CString sChose = _T("");
		if (bIsTextHighChanged && !bIsBlockScaleChanged)
		{
			sChose.Format(_T("发现字体高度修改,请选择:\n")
				_T("是:将所有字体高度%s替换为%s\n")
				_T("否:将当前字体高度%s替换为%s\n")
				_T("取消:放弃这次操作"),strTextHeight,m_strTextHigh,strTextHeight,m_strTextHigh);
			m_Us = UpdateAllTH;
		}
		else if (!bIsTextHighChanged && bIsBlockScaleChanged)
		{
			sChose.Format(_T("发现图块系数修改,请选择:\n")
				_T("是:将所有图块系数%s替换为%s\n")
				_T("否:将当前图块系数%s替换为%s\n")
				_T("取消:放弃这次操作"),strBlockScale,m_strBlockScale,strBlockScale,m_strBlockScale);
			m_Us = UpdateAllSc;
		}
		else
		{
			sChose.Format(_T("发现字体高度和图块系数修改,请选择:\n")
				_T("是:将所有字体高度%s和图块系数%s替换为%s和%s\n")
				_T("否:将当前字体高度%s和图块系数%s替换为%s和%s\n")
				_T("取消:放弃这次操作"),
				strTextHeight,strBlockScale,m_strTextHigh,m_strBlockScale,
				strTextHeight,strBlockScale,m_strTextHigh,m_strBlockScale);
			m_Us = UpdateAllTHAndSc;
		}
		int iRet = 0;

		iRet = AfxMessageBox(sChose,MB_YESNOCANCEL);
		if (iRet == IDNO)
		{
			int st = m_Us;
			st++;
			m_Us = (UpdateStyle)st;
		}
		else if (iRet == IDCANCEL)
		{
			m_Us = UpdateNone;
		}
	}

	if (bIsRadiusChanged)
	{
		CString sOutText;
		sOutText.Format(_T("发现滚球半径修改,请选择:\n"
		_T("是:将所有针滚球半径%sm替换为%sm\n")
		_T("否:保持滚球半径%sm不变\n")),strExRadius,strRadius,strExRadius);

		int nRet = AfxMessageBox(sOutText,MB_YESNO);
		if (nRet == IDYES)
		{
			AcDbObjectIdArray arIDThun;
			ThunderContainer->GetGroupThunder(m_sGroupNo, arIDThun);
			CThunderXData xd;
			CStringArray arTemp;
			for (int i = 0;i < arIDThun.length();++i)
			{
				thunderXData.GetBaseInformationExData(arIDThun[i],arTemp,TEL_THUNDER_BASEINFOR);
				if (arTemp.GetSize() > 2)
				{
					arTemp.SetAt(2, strRadius);
					thunderXData.SetBaseInformationExData(arIDThun[i],arTemp,TEL_THUNDER_BASEINFOR);
				}
				
				arTemp.RemoveAll();
			}
		}
		else if (nRet == IDNO)
		{
			strRadius = strExRadius;
		}
	}

	m_arsXData.RemoveAll();
	// 编号
	m_arsXData.Add(strNum);
	
	// 针高度
	m_arsXData.Add(strHeight);
	
	// 半径
	strRadius += _T("m");
	m_arsXData.Add(strRadius);
	
	// 维数
	m_arsXData.Add(strRad);
	
	//图块系数
	m_arsXData.Add(m_strBlockScale);
	//字体高度
	m_arsXData.Add(m_strTextHigh);

	return TRUE;
}

void CLayPinDlg::PostErrorToCue(CString& strError)
{
	m_stcNumCue.SetWindowText(strError);
}

BOOL CLayPinDlg::AssertProtectHeight(BOOL bBoxTip)
{
	CString sPinHt;
	GetDlgItemText(IDC_EDIT_HEIGHT, sPinHt);

	CString sValue;
	AcGeDoubleArray arProHt;
	for (long i = 0;i < m_wndGrid.GetItemCount();++i)
	{
		sValue = m_wndGrid.GetItemText(i,1);
		if (_tstof(sPinHt) <= _tstof(sValue)) // 针高应大于保护高度
		{
			if (bBoxTip)
			{
				AfxMessageBox(_T("避雷针高度应大于其保护高度!"));
			}
			return FALSE;
		}

		if (!sValue.IsEmpty())
		{
			arProHt.append(_tstof(sValue));
		}
	}
	
	// 判断保护高度是否存在重复值
	double dT1,dT2;
	for (int c = 0;c < arProHt.length();++c)
	{
		dT1 = arProHt[c];
		for (int c2 = c+1;c2 < arProHt.length();++c2)
		{
			dT2 = arProHt[c2];
			if (fabs(dT1 - dT2) < 1e-3)
			{
				if (bBoxTip)
				{
					sValue.Format(_T("%.2f"), dT2);
					sValue = TrimDoubleString(sValue);
					CString sTip;
					sTip.Format(_T("保护高度值%s重复!"), sValue);
					AfxMessageBox(sTip);
				}

				return FALSE;
			}
		}
	}

	return TRUE;
}

// 更新数据
void CLayPinDlg::OnButtonUpdate() 
{
	if (!AssertProtectHeight())
	{
		return;
	}

	TReactorAssociate temp(acdbCurDwg(), m_pReactor);

	CString sGroundRadius = _T("");
	m_cmbRadius.GetWindowText(sGroundRadius);
	CString strRadius = m_arsXData.GetAt(CThunderXData::eXDataPinRadius);

	CString sValue;
	CStringArray arProHt;
	for (long i = 0;i < m_wndGrid.GetItemCount();++i)
	{
		sValue = m_wndGrid.GetItemText(i,1);
		if (!sValue.IsEmpty())
		{
			arProHt.Add(sValue);
		}
	}

	BOOL bChange = FALSE;
	CStringArray arsProHt;
	GetProtectHeightFromObj(m_idThunder, arsProHt);
	if (arsProHt.GetSize() == arProHt.GetSize())
	{
		for (int j = 0;j < arsProHt.GetSize();++j)
		{
			if (fabs(_tstof(arsProHt[j]) - _tstof(arProHt[j])) > 1e-3)
			{
				bChange = TRUE;
				break;
			}
		}
	}
	else
	{
		bChange = TRUE;
	}

	if (!bChange && strRadius.CompareNoCase(sGroundRadius) != 0)
	{
		bChange = TRUE;
	}
	
	if (m_arsXData.GetSize() < 4) return;

	// 获取对话框数据
	if (!GetDlgData(TRUE))
	{
		return;
	}

	//更新标注
	CString strText;
	CThunderXData xd;
	GetDlgItemText(IDC_GROUP_NO, strText);
	strText += _T("g,");
	strText += m_arsXData.GetAt(CThunderXData::eXDataPinNum);
	ads_name entThunder;
	acdbGetAdsName(entThunder,m_idThunder);
	Entity entBlock(entThunder);
	strText += _T("#,h=");
	CString sPinHeight = m_arsXData.GetAt(CThunderXData::eXDataPinHeight);
	strText += sPinHeight;
	strText += _T("m");
	double dTestHeight = _tstof(m_strTextHigh);
	SetBlkAttrText(entBlock, strText, _T("$TEXT$"), dTestHeight, TRUE, TRUE);

	//修改字高和缩放比例
	UpdateTHAndBkSc(m_Us);

	//保存设置
	UpdateDlgData(TRUE);

 	SetCurrentExData(m_idThunder);
	// 设置避雷针组号
	CThunderXData thundXData;
	CString sGroupNo,sOldGroupNo;
	GetDlgItemText(IDC_GROUP_NO, sGroupNo);
	thundXData.GetXData(m_idThunder, TEL_GROUP_NO, sOldGroupNo);
	CString sNum;
	GetDlgItemText(IDC_EDIT_NUM, sNum);
	thundXData.SetXData(m_idThunder, TEL_ORDER_NUMBER, sNum);

	AcGeDoubleArray arPro;
	for (int t = 0;t < arProHt.GetSize();++t)
	{
		arPro.append(_tstof(arProHt[t]));
	}

	if (_tstof(sGroupNo) == _tstof(sOldGroupNo)) // 组号没有改变
	{
		ThunderContainer->AppendProHeight(m_sGroupNo, arPro);
	}
	else // 改变组号
	{
		thundXData.SetXData(m_idThunder, TEL_GROUP_NO, sGroupNo);
		// 将该针从原组中移除
		AcGeDoubleArray arOldPro;
		ThunderContainer->RemoveThunder(sOldGroupNo, m_idThunder);
		thundXData.GetProtectHeightFromObjEx(m_idThunder, arOldPro);
		ThunderContainer->AppendProHeight(sOldGroupNo, arOldPro);

		// 将该针添加到新组
		ThunderContainer->AppendThunder(sGroupNo, m_idThunder);
		ThunderContainer->AppendProHeight(sGroupNo, arPro);
	}
	
	// 重绘
	CThunderCmdGroup::bExecute = TRUE;
}

void CLayPinDlg::OnButtonCancel() 
{
	CDialog::OnCancel();
	acedPostCommand(_T("\33\33"));
}

// 显示或隐藏控件
void CLayPinDlg::DisplayOrHideBtn(BOOL bIsHide)
{
	if (bIsHide)
	{
		// 显示更新按钮
		m_btnUpdate.ShowWindow(SW_SHOW);
		m_btnCancel.ShowWindow(SW_SHOW);
		m_stcNumCue.ShowWindow(SW_HIDE);
	}
	else
	{
		// 显示编辑框提示
		m_btnUpdate.ShowWindow(SW_HIDE);
		m_btnCancel.ShowWindow(SW_HIDE);
		m_stcNumCue.ShowWindow(SW_SHOW);
	}
}

void CLayPinDlg::OnChangeEditNum() 
{
	if (!m_bValid)
	{
		return;
	}

	CString sCurNo,sOldGNo,strTip;
	m_edtNumber.GetWindowText(sCurNo);
	GetDlgItemText(IDC_GROUP_NO, sOldGNo);
	
	if (_ttoi(sCurNo) < 1)
	{
		strTip.Format(_T("编号最小为1"));
		m_bTipChange = TRUE;
		PostErrorToCue(strTip);
		return;
	}

	BOOL bValid = FALSE;
	AcGeIntArray arNum;
	ThunderContainer->GetNumArrayBySpecGroup(sOldGNo, arNum);
	
	// 排除自身:当编辑时不提示自身编号已重复
	if (m_bIsModel)
	{
		CString sNum,sGroupNo;
		CThunderXData xd;
		xd.GetXData(m_idThunder, TEL_ORDER_NUMBER, sNum);
		xd.GetXData(m_idThunder, TEL_GROUP_NO, sGroupNo);

		// 统计是否存在多个重复编号
		int nCount = 0;
		for (int i = 0;i < arNum.length();++i)
		{
			if (arNum[i] == _ttoi(sNum))
			{
				nCount++;
			}
		}
		
		if (nCount > 1)
		{
			int nPos;
			if (!arNum.find(_ttoi(sCurNo),nPos))
			{
				bValid = TRUE;
			}
		}
		else if (_ttoi(sNum) == _ttoi(sCurNo) &&
				 _ttoi(sOldGNo) == _ttoi(sGroupNo) )
		{
			bValid = TRUE;
		}
		else
		{
			int nPos;
			if (!arNum.find(_ttoi(sCurNo),nPos))	
			{
				bValid = TRUE;
			}
		}
	}
	else
	{
		int nPos;
		if (!arNum.find(_ttoi(sCurNo),nPos))	
		{
			bValid = TRUE;
		}
	}
	
	if (!bValid)
	{
		// 提示错误（显示错误提示 + 隐藏更新和取消按钮）
		strTip.Format(_T("组%s中编号%s已存在"), sOldGNo,sCurNo);
		m_bTipChange = TRUE;
		PostErrorToCue(strTip);
		if (m_bIsModel)
		{
			DisplayOrHideBtn(FALSE);
		}
	}
	else
	{
		// 清除错误提示（显示更新和取消按钮 +　隐藏错误提示）
		strTip.Format(_T("组%s中编号%s可以使用"), sOldGNo,sCurNo);
		m_bTipChange = FALSE;
		PostErrorToCue(strTip);
		if (m_bIsModel)
		{
			DisplayOrHideBtn(TRUE);
		}
	}
}

// 添加扩展数据
BOOL CLayPinDlg::SetCurrentExData(const AcDbObjectId& idEnt)
{
	// 设置扩展数据
	CThunderXData thundXData;
	if (!thundXData.SetBaseInformationExData(idEnt, m_arsXData, TEL_THUNDER_BASEINFOR))
	{
		return FALSE;
	}
	
	return TRUE;
}

// 读取扩展数据
BOOL CLayPinDlg::GetCurrentExData(const AcDbObjectId& idEnt)
{
	CThunderXData thundXData;
	m_arsXData.RemoveAll();
	m_arProHeight.setLogicalLength(0);
	if (thundXData.GetBaseInformationExData(idEnt, m_arsXData, TEL_THUNDER_BASEINFOR) &&
		thundXData.GetProtectHeightFromObjEx(idEnt, m_arProHeight))
	{
		return TRUE;
	}

	return FALSE;
}

// 二维显示
void CLayPinDlg::OnLayer2d() 
{	
	if (!m_bIsModel)
	{
		TCurDocumentLock lockDoc;
		if (m_pDrawThunder != NULL)
		{
			m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_2D, TRUE);
			m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_3D, FALSE);
		}

		acedPostCommand(_T("\33\33"));
	}
}

// 三维显示
void CLayPinDlg::OnLayer3d() 
{
	if (!m_bIsModel)
	{
		TCurDocumentLock lockDoc;
		if (m_pDrawThunder != NULL)
		{
			m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_2D, FALSE);
			m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_3D, TRUE);
		}

		acedPostCommand(_T("\33\33"));
	}
}

// 插入避雷针
BOOL CLayPinDlg::InsertThunderBlock(AcDbObjectId& idEnt)
{
	//确认高度有效

	CString xstrTemp = _T("$Ectrical$00000091");
	AcDbObjectId idBlock = InitBlock((const TCHAR*)xstrTemp);

 	AcDbBlockReference blk(AcGePoint3d::kOrigin, idBlock);
	TThunderInsertPreviewJig jig(&blk);
	jig.SetLayPinDlgPtr(this);
	jig.setDispPrompt(_T("\n 请选择插入点<退出>:"));
	if (jig.DoIt() != RTNORM)
	{
		return FALSE;
	}
	if (!GetDlgData())
	{
		return TRUE;
	}

	AcGePoint3d ptInst = jig.GetLastPoint();
	ptInst.z = 0.0;

	CString sGroupNo;
	GetDlgItemText(IDC_GROUP_NO, sGroupNo);
	if (_ttoi(sGroupNo) < 1)
	{
		AfxMessageBox(_T("避雷针组号应大于0!"));
		return TRUE;
	}

	CString sNum;
	GetDlgItemText(IDC_EDIT_NUM, sNum);
	if (_ttoi(sNum) < 1)
	{
		AfxMessageBox(_T("避雷针编号应大于0!"));
		return TRUE;
	}
	
	if (m_bTipChange)
	{
		return TRUE;
	}

	KTSetting::InitLayer(LAY_EL_THUNDER);
	XPushVarStr cLayer(_T("CLAYER"), LAY_EL_THUNDER);
	XPushVar<int> vOsMode(_T("OSMODE"), 0);
	
	int dBlockScale = 0;
	dBlockScale = _ttoi(m_strBlockScale);
	if (dBlockScale == 0)
	{
		dBlockScale = 1;
	}

	double dInsScale1 = dBlockScale*10*DocGetPScale();
	XPoint xp(Wcs2Ucs(ptInst));
	SHads_command(RTSTR, _T(".INSERT"), RTSTR, (const TCHAR*)xstrTemp, RT3DPOINT, &xp,
				RTREAL, dInsScale1 , RTREAL,dInsScale1 ,RTSTR, _T(""),RTSTR, _T(""),RTREAL,0.0, RTNONE);

	Entity entLast;
	entLast.GetLast();

	acdbGetObjectId(idEnt, entLast);

	CString strText;
	//GetDlgItemText(IDC_GROUP_NO, strText);
	//strText += _T("g,");
	strText += m_arsXData.GetAt(CThunderXData::eXDataPinNum);
	CString sPinHeight = m_arsXData.GetAt(CThunderXData::eXDataPinHeight);
	
	strText += _T("#,h=");
	strText += sPinHeight;
	strText += _T("m");
	double dTextHeight = _tstof(m_strTextHigh);

	SetBlkAttrText(entLast, strText, _T("$TEXT$"), dTextHeight, TRUE, TRUE);

	SetCurrentExData(idEnt);

	// 设置避雷针组号
	CThunderXData thundXData;
	thundXData.SetXData(idEnt, TEL_GROUP_NO, sGroupNo);
	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
	regProp.SetTopRootKey(HKEY_CURRENT_USER);
	regProp.SetValue(KEY_THU_LAST_GROUPNO,sGroupNo);

	// 设置避雷针编号
	thundXData.SetXData(idEnt, TEL_ORDER_NUMBER, sNum);

	// 新插入的避雷针入库
	ThunderContainer->AppendThunder(sGroupNo, idEnt);

	if (m_pDrawThunder != NULL)
	{		
		m_pDrawThunder->DrawThunder2DArea(m_arProHeight, sGroupNo);
	}

	CString sNO;
	sNO.Format(_T("%d"), _ttoi(sNum)+1);
	m_edtNumber.SetWindowText(sNO);

	thundXData.SetProtectHeightToReg(m_arProHeight);

	acedUpdateDisplay();
	actrTransactionManager->flushGraphics();

	return TRUE;
}

void CLayPinDlg::GetCurrentData(CStringArray& arData)
{
	CString sTemp;
	m_arsXData.RemoveAll();
	// 编号
	GetDlgItemText(IDC_EDIT_NUM, sTemp);
	m_arsXData.Add(sTemp);
	
	// 针高度
	GetDlgItemText(IDC_EDIT_HEIGHT, sTemp);
	m_arsXData.Add(sTemp);
	
	// 半径
	GetDlgItemText(IDC_COMBO_RADIUS, sTemp);
	sTemp += _T("m");
	m_arsXData.Add(sTemp);
	
	// 维数
	m_arsXData.Add(_T("1"));
	
	//图块系数
	GetDlgItemText(IDC_EDIT_BLOCKSCALE, sTemp);
	m_arsXData.Add(sTemp);
	//字体高度
	GetDlgItemText(IDC_EDIT_TEXTHIGH, sTemp);
	m_arsXData.Add(sTemp);

	m_arProHeight.setLogicalLength(0);
	CString sValue;
	for (long p = 0;p < m_wndGrid.GetItemCount();++p)
	{
		sValue = m_wndGrid.GetItemText(p,1);
		if (!(_tstof(sValue) < -1e-6) && !sValue.IsEmpty())
		{
			m_arProHeight.append(_tstof(sValue));
		}
	}

	arData.RemoveAll();
	arData.Append(m_arsXData);
}

// 将圆和避雷针生成组并添加到有名对象字典的组字典中
AcDbObjectId CLayPinDlg::AddCurGroup(const AcDbObjectIdArray& arIds, LPCTSTR pszGroupName)
{
	AcDbObjectId idGroup = AcDbObjectId::kNull;
	return idGroup;

	if (pszGroupName == NULL || arIds.length() < 1)
	{
		return idGroup;
	}

	// 将组添加到有名对象字典的组字典中
	AcDbDictionary* pGroupDict = NULL;
	acdbHostApplicationServices()->workingDatabase()->getGroupDictionary(pGroupDict, AcDb::kForWrite);
	if (pGroupDict != NULL)
	{
		if (pGroupDict->has(pszGroupName))
		{
			AcDbGroup* pGroup = NULL;
			pGroupDict->getAt(pszGroupName, (AcDbObject*&)pGroup, AcDb::kForWrite);
			if (pGroup != NULL)
			{
				pGroup->clear();
				pGroup->append(arIds);
				pGroup->close();
			}

			pGroupDict->close();
		}
		else
		{
			AcDbGroup* pGroup = new AcDbGroup((TCHAR*)pszGroupName, true);
			pGroup->append(arIds);
			pGroupDict->setAt(pszGroupName, pGroup, idGroup);
			pGroupDict->close();
			pGroup->close();
		}	
	}

	return idGroup;
}

// 设置绘画指针
void CLayPinDlg::SetThunderDraw2d(CDrawThunderTools* pThundDraw)
{
	m_pDrawThunder = pThundDraw;
}

void CLayPinDlg::UpdateDlgData(BOOL ReadOrWrite)
{
	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);    
	regProp.SetTopRootKey(HKEY_CURRENT_USER);
	if (ReadOrWrite)
	{
		//读设置
		regProp.GetValue(KEY_GROUNDRADIUS,m_strRadius);
		regProp.GetValue(KEY_THUNDERPINHEIGHT,m_strPinHeight);
		regProp.GetValue(KEY_THUNDERSCALE,m_strBlockScale);
		regProp.GetValue(KEY_TEXTHIGHT,m_strTextHigh);
	}
	else
	{
		//写设置
		regProp.SetValue(KEY_GROUNDRADIUS,m_strRadius);
		regProp.SetValue(KEY_THUNDERPINHEIGHT,m_strPinHeight);
		regProp.SetValue(KEY_THUNDERSCALE,m_strBlockScale);
		regProp.SetValue(KEY_TEXTHIGHT,m_strTextHigh);
	}
}
void CLayPinDlg::OnThunderHeightTip() 
{
	CString sTip;
	sTip = _T("1、独立避雷针的针高\n2、若非独立避雷针时，一种为避雷针有效高度加上被保护建筑物的高度；一种\n为针高加上到建筑物被保护平面部分的距离；（前提均为不超过滚球半径）。");
	AfxMessageBox(sTip,MB_OK,MB_ICONINFORMATION);
}

void CLayPinDlg::UpdateTHAndBkSc(UpdateStyle us)
{
	AcDbObjectIdArray arcIds;
	switch(us)
	{
	case UpdateAllTH:
		{

			//更新所有字高
			UpdateTextHeight();
			break;
		}
	case UpdateCurTH:
		{

			// 更新当前字高
			UpdateTextHeight(FALSE);
			break;
		}
	case UpdateAllSc:
		{
			// 更新所有图块系数
			UpdateBlkScale();
			break;
		}
	case UpdateCurSc:
		{
			//更新当前图块系数
			UpdateBlkScale(FALSE);
			break;
		}
	case UpdateAllTHAndSc:
		{
			//更新所有 字高 和 图块系数
			UpdateTextHeight();
			UpdateBlkScale();
			break;
		}
	case UpdateCurTHAndSc:
		{
			//更新当前字高 和 图块系数
			UpdateTextHeight(FALSE);
			UpdateBlkScale(FALSE);
			break;
		}
	case UpdateNone:
		{
			//不做更新
			break;
		}
	}
}

void CLayPinDlg::GetAllInsert(AcDbObjectIdArray& arcId)
{
	arcId.setLogicalLength(0);
	
	TContainerSingleton::LstGroupIDMap::iterator itMap;
	TContainerSingleton::LstIDData::iterator itLst;

	TContainerSingleton::LstGroupIDMap mapData;
	ThunderContainer->GetThunderMap(mapData);
	for (itMap = mapData.begin();itMap != mapData.end();++itMap)
	{
		for (itLst = itMap->second.begin();itLst != itMap->second.end();++itLst)
		{
			arcId.append(*itLst);
		}
	}
}

void CLayPinDlg::UpdateTextHeight(BOOL IsUpdataAll)
{
	AcDbObjectIdArray arcIds;
	arcIds.append(m_idThunder);

	if (IsUpdataAll)
	{
		GetAllInsert(arcIds);
	}

	int iCount = 0;
	iCount = arcIds.length();
	ads_name entThunder;
	CThunderXData thundXData;
	CString strBlkTest = _T("");
	double dTextHeight = _tstof(m_strTextHigh);
	for (int i = 0;i < iCount; ++i)
	{
		acdbGetAdsName(entThunder,arcIds[i]);
		Entity entBlock(entThunder);
		GetBlkAttrText(arcIds[i],_T("$TEXT$"),strBlkTest);
		//设置字体高度
		SetBlkAttrText(entBlock,strBlkTest,_T("$TEXT$"),dTextHeight,TRUE,TRUE);
	}

	ModifyTHChanged(arcIds);
}

void CLayPinDlg::UpdateBlkScale(BOOL IsUpdataAll)
{
	AcDbObjectIdArray arcIds;
	arcIds.append(m_idThunder);
	
	if (IsUpdataAll)
	{
		GetAllInsert(arcIds);
	}

	double dBkScale = _tstof(m_strBlockScale);
	AcGeScale3d tmpSc;

	CThunderXData thundXData;

	AcDbObject* pObj = NULL;
	AcDbBlockReference* pRef = NULL;
	AcGePoint3d ptAttrPos;
	AcGePoint3d ptBlkPos;
	for (int i = 0; i< arcIds.length();++i)
	{
		if (acdbOpenObject(pObj,arcIds[i],AcDb::kForRead) == Acad::eOk)
		{
			pRef = AcDbBlockReference::cast(pObj);
			if (pRef != NULL)
			{
				CString Scale;
				thundXData.GetIndexOf(arcIds[i],Scale,CThunderXData::eXDataBlockScale,TEL_THUNDER_BASEINFOR);
				double dOldScale = _tstof(Scale);
				if (dOldScale < 1.0E-8)
				{
					dOldScale = 1;
				}
				//设置图块的缩放系数
				tmpSc = pRef->scaleFactors();
				tmpSc *= dBkScale/dOldScale;

				pRef->upgradeOpen();
				pRef->setScaleFactors(tmpSc);
				pRef->downgradeOpen();

 				GetBlkAttrPos(arcIds[i],_T("$TEXT$"),ptAttrPos);
				ptBlkPos = pRef->position();
				AcGeVector3d pmVector;

				if (dBkScale/dOldScale > 1)
				{
					pmVector = ptAttrPos - ptBlkPos;
					pmVector *= (sqrt(dBkScale/dOldScale) - 1);
				}
				else
				{
					pmVector = ptBlkPos - ptAttrPos;
					pmVector *= (1 - sqrt(dBkScale/dOldScale));
				}
				
				ptAttrPos += pmVector;

				//调整属性字插入点
				SetAttrPos(pRef,_T("$TEXT$"),ptAttrPos);
			}

			pObj->close();
		}

		//调整属性字插入点
		CString sAttrText = _T("");
		GetBlkAttrText(arcIds[i],_T("$TEXT$"),sAttrText);
		
		ads_name Blkname;
		acdbGetAdsName(Blkname,arcIds[i]);
		Entity ent(Blkname);
		
		double dTextHeight = _tstof(m_strTextHigh);
		if (dTextHeight < 1.0E-8)
		{
			dTextHeight = 1;
		}
		
		SetBlkAttrText(ent,sAttrText,_T("$TEXT$"),dTextHeight,TRUE,TRUE);
	}

	ModifyBlkScaleChanged(arcIds);
}

void CLayPinDlg::GetBlkAttrText(AcDbObjectId oid,LPCTSTR pszTag,CString& strBlkTest)
{
	AcDbAttribute* pAttr = NULL;
	AcDbObjectId attrid;	
	
	AcDbObject* pObj = NULL;
	AcDbBlockReference* pRef = NULL;
	if (acdbOpenObject(pObj,oid,AcDb::kForRead) == Acad::eOk)
	{
		pRef = AcDbBlockReference::cast(pObj);
		if (pRef != NULL)
		{
			AcDbObjectIterator* pIter = NULL;
			pIter = pRef->attributeIterator();

			if (pIter != NULL)
			{
				AcDbEntity* pEnt = NULL;
				for (pIter->start();!pIter->done();pIter->step())
				{
					attrid = pIter->objectId();

					if (acdbOpenAcDbEntity(pEnt,attrid,AcDb::kForWrite) == Acad::eOk)
					{
						pAttr = AcDbAttribute::cast(pEnt);
						if (pAttr != NULL)
						{
							CString sTag = pAttr->tag();
							if (_tcsicmp(sTag,pszTag) == 0)
							{
								strBlkTest = pAttr->textString();
							}
						}
						pEnt->close();
						pAttr = NULL;
					}
				}
				delete pIter;
				pIter = NULL;
			}
		}
		pObj->close();
		pRef = NULL;
	}
}

void CLayPinDlg::GetBlkAttrPos(AcDbObjectId oid,LPCTSTR pszTag,AcGePoint3d& ptPos)
{
	AcDbAttribute* pAttr = NULL;
	AcDbObjectId attrid;	
	
	AcDbObject* pObj = NULL;
	AcDbBlockReference* pRef = NULL;
	if (acdbOpenObject(pObj,oid,AcDb::kForRead) == Acad::eOk)
	{
		pRef = AcDbBlockReference::cast(pObj);
		if (pRef != NULL)
		{
			AcDbObjectIterator* pIter = NULL;
			pIter = pRef->attributeIterator();
			
			if (pIter != NULL)
			{					
				AcDbEntity* pEnt = NULL;
				for (pIter->start();!pIter->done();pIter->step())
				{
					attrid = pIter->objectId();

					if (acdbOpenAcDbEntity(pEnt,attrid,AcDb::kForRead) == Acad::eOk)
					{
						pAttr = AcDbAttribute::cast(pEnt);
						if (pAttr != NULL)
						{
							CString sTag = pAttr->tag();
							if (_tcsicmp(sTag,pszTag) == 0)
							{
								ptPos = pAttr->position();
							}
						}
						pEnt->close();
						pAttr = NULL;
					}
				}
				delete pIter;
				pIter = NULL;
			}
		}
		pObj->close();
		pRef = NULL;
	}
}

//修改扩展数据-字体高度
void CLayPinDlg::ModifyTHChanged(const AcDbObjectIdArray& arcIds)
{
	CThunderXData thundXData;
	CStringArray strAttrs;
	CString strPinNum,strPinHeight,strPinRadius,strPinIs2d,strBlkScale;
	AcDbObjectId IdEnt;

	for (int i = 0; i < arcIds.length(); ++i)
	{
		IdEnt = arcIds[i];
		thundXData.GetIndexOf(IdEnt,strPinNum,CThunderXData::eXDataPinNum,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinHeight,CThunderXData::eXDataPinHeight,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinRadius,CThunderXData::eXDataPinRadius,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinIs2d,CThunderXData::eXDataPinIs2d,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strBlkScale,CThunderXData::eXDataBlockScale,TEL_THUNDER_BASEINFOR);
		
		strAttrs.Add(strPinNum);
		strAttrs.Add(strPinHeight);
		strAttrs.Add(strPinRadius);
		strAttrs.Add(strPinIs2d);
		strAttrs.Add(strBlkScale);
		strAttrs.Add(m_strTextHigh);

		thundXData.SetBaseInformationExData(IdEnt,strAttrs,TEL_THUNDER_BASEINFOR);
	}
}

//修改扩展数据- 图块系数
void CLayPinDlg::ModifyBlkScaleChanged(const AcDbObjectIdArray& arcIds)
{
	CThunderXData thundXData;
	CStringArray strAttrs;
	CString strPinNum,strPinHeight,strPinRadius,strPinIs2d,strTextHigh;
	AcDbObjectId IdEnt;

	for (int i = 0; i < arcIds.length(); ++i)
	{
		IdEnt = arcIds[i];
		thundXData.GetIndexOf(IdEnt,strPinNum,CThunderXData::eXDataPinNum,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinHeight,CThunderXData::eXDataPinHeight,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinRadius,CThunderXData::eXDataPinRadius,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strPinIs2d,CThunderXData::eXDataPinIs2d,TEL_THUNDER_BASEINFOR);
		thundXData.GetIndexOf(IdEnt,strTextHigh,CThunderXData::eXDataTextHeight,TEL_THUNDER_BASEINFOR);
		
		strAttrs.Add(strPinNum);
		strAttrs.Add(strPinHeight);
		strAttrs.Add(strPinRadius);
		strAttrs.Add(strPinIs2d);
		strAttrs.Add(m_strBlockScale);
		strAttrs.Add(strTextHigh);

		thundXData.SetBaseInformationExData(IdEnt,strAttrs,TEL_THUNDER_BASEINFOR);
	}
}

Acad::ErrorStatus CLayPinDlg::SetAttrPos(AcDbBlockReference* pRef,LPCTSTR pszTag,const AcGePoint3d& pt)
{
	Acad::ErrorStatus us = Acad::eOk;
	if (pRef != NULL && pszTag != NULL)
	{
		Acad::ErrorStatus es = pRef->upgradeOpen();

			if (pRef->isWriteEnabled())
			{
				AcDbAttribute* pAttr = NULL;
				AcDbObjectId attrid;
				AcDbObjectIterator* pIter = NULL;
				pIter = pRef->attributeIterator();
				
				if (pIter != NULL)
				{						
					AcDbEntity* pEnt = NULL;
					for (pIter->start();!pIter->done();pIter->step())
					{
						attrid = pIter->objectId();

						if (acdbOpenAcDbEntity(pEnt,attrid,AcDb::kForWrite) == Acad::eOk)
						{
							pAttr = AcDbAttribute::cast(pEnt);
							if (pAttr != NULL)
							{
								CString sTag = pAttr->tag();
								if (_tcsicmp(sTag,pszTag) == 0)
								{
									AcGePoint3d ptPos = pAttr->position();
 									AcGeVector3d v = pt - ptPos;
 									AcGeMatrix3d mat;
 									mat.setToTranslation(v);
 									pAttr->transformBy(mat);
								}
							}
							pEnt->close();
							pAttr = NULL;
						}
					}
					delete pIter;
					pIter = NULL;
				}
			}
			pRef->downgradeOpen();
	}
	return us;
}

// 避雷针保护高度
BOOL CLayPinDlg::GetProtectHeightFromReg(CStringArray& arProHeight)
{
	arProHeight.RemoveAll();

	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
	regProp.SetTopRootKey(HKEY_CURRENT_USER);

	CString sProHt;
	if (regProp.GetValue(TEL_THUNDER_MULTIPROHT, sProHt))
	{
		if (SplitValue(sProHt, TEL_SPLIT_CH, arProHeight))
		{
			// 排序
			std::map<double,CString> mapData;
			for (int i = 0;i < arProHeight.GetSize();++i)
			{
				mapData.insert(std::make_pair(_tstof(arProHeight[i]),arProHeight[i]));
			}
			
			arProHeight.RemoveAll();
			std::map<double,CString>::iterator it;
			for (it = mapData.begin();it != mapData.end();++it)
			{
				arProHeight.Add(it->second);
			}
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CLayPinDlg::SetProtectHeightToReg(const CStringArray& arProHeight)
{
	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
	regProp.SetTopRootKey(HKEY_CURRENT_USER);
	
	CString sProHt = ConvertToCString(arProHeight, TEL_SPLIT_CH);
	if (regProp.SetValue(TEL_THUNDER_MULTIPROHT, sProHt))
	{
		return TRUE;
	}
	
	return FALSE;
}

BOOL CLayPinDlg::GetProtectHeightFromObj(const AcDbObjectId& idThunder, CStringArray& arProHeight)
{
	arProHeight.RemoveAll();

	CThunderXData thundXData;
	CString sValue;

	if (thundXData.GetXData(idThunder, TEL_THUNDER_MULTIPROHT, sValue))
	{
		if (SplitValue(sValue, TEL_SPLIT_CH, arProHeight))
		{
			// 排序
			std::map<double,CString> mapData;
			for (int i = 0;i < arProHeight.GetSize();++i)
			{
				mapData.insert(std::make_pair(_tstof(arProHeight[i]),arProHeight[i]));
			}

			arProHeight.RemoveAll();
			std::map<double,CString>::iterator it;
			for (it = mapData.begin();it != mapData.end();++it)
			{
				arProHeight.Add(it->second);
			}

			return TRUE;
		}
	}
		
	return FALSE;
}

BOOL CLayPinDlg::SetProtectHeightToObj(LPCTSTR pszGNo, const CStringArray& arProHeight)
{
	AcDbObjectIdArray arID;
	ThunderContainer->GetGroupThunder(pszGNo, arID);
	if (arID.length() < 1)
	{
		return FALSE;
	}

	AcGeDoubleArray arPHeight;
	for (int j = 0;j < arProHeight.GetSize();++j)
	{
		arPHeight.append(_tstof(arProHeight[j]));
	}

	CThunderXData thundXData;
	for (int i = 0;i < arID.length();++i)
	{
		thundXData.SetProtectHeightToObjEx(arID[i], arPHeight);
	}

	return TRUE;
}

BOOL CLayPinDlg::SplitValue(LPCTSTR pszSrc, LPCTSTR pszSplitCh, CStringArray& arValue)
{
	arValue.RemoveAll();

	CString sValue;
	CString sSrc = pszSrc;
	while (SplitString(sSrc, pszSplitCh, sValue))
	{
		sValue = TrimDoubleString(sValue);
		arValue.Add(sValue);
	}

	return arValue.GetSize() > 0;
}

CString CLayPinDlg::ConvertToCString(const CStringArray& arValue, LPCTSTR pszSplitCh)
{
	CString sData;
	for (int i = 0;i < arValue.GetSize();++i)
	{
		sData += arValue[i];
		sData += pszSplitCh;
	}

	return sData;
}

BOOL CLayPinDlg::SplitString(CString& sSrc, LPCTSTR pszSplitCh, CString& sValue)
{
	if (!sSrc.IsEmpty())
	{
		int nIndex = sSrc.Find(pszSplitCh, 0);
		if (nIndex > 0)
		{
			sValue = sSrc.Left(nIndex);
			sSrc = sSrc.Right(sSrc.GetLength()-nIndex-1);

			return TRUE;
		}
	}

	return FALSE;
}

CString CLayPinDlg::TrimDoubleString(LPCTSTR pszSrc)
{
	CString sSrc = pszSrc;
	
	sSrc.TrimLeft();
	sSrc.TrimRight();

	if (sSrc.Find(_T("."), 0) >= 0)
	{
		sSrc.TrimRight(_T("0"));
		sSrc.TrimRight(_T("."));
	}

	return sSrc;
}

void CLayPinDlg::UpdateThunderByProtectHeight()
{
	return;

	acedGetAcadFrame()->SetFocus();
	
	if (!AssertProtectHeight())
	{
		return;
	}
	
	if (!GetDlgData())
	{
		return;
	}

	CString sGroupNo;
	GetDlgItemText(IDC_GROUP_NO, sGroupNo);
	
	CString sValue;
	AcGeDoubleArray arProHeight;
	for (long i = 0;i < m_wndGrid.GetItemCount();++i)
	{
		sValue = m_wndGrid.GetItemText(i,1);
		if (!sValue.IsEmpty() && _tstof(sValue) > 0)
		{
			arProHeight.append(_tstof(sValue));
		}
	}

	TReactorAssociate rctAct(acdbCurDwg(), m_pReactor);
	
	m_pDrawThunder->DrawThunder2DArea(arProHeight,sGroupNo);
	
	m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_2D, TRUE);
	m_pDrawThunder->ShowLayer(LAY_EL_THUNDER_3D, FALSE);

	acedUpdateDisplay();
	actrTransactionManager->flushGraphics();
	ThunderContainer->ClearProHeight();
}

AcGePoint3d CLayPinDlg::GetThunderInsertPosition(const AcDbObjectId& id)
{
	AcGePoint3d ptPos;

	if (id.isValid())
	{
		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockReference, pRef);
		if (pRef != NULL)
		{
			ptPos = pRef->position();
		}
		OPENOBJ_END();
	}

	return ptPos;
}

double CLayPinDlg::GetThunderHeight() const
{
	CString sHt;
	GetDlgItemText(IDC_EDIT_HEIGHT, sHt);
	return _tstof(sHt);
}

// 是否响应动态更新
BOOL CLayPinDlg::IsDynamicUpdate() const
{
	return m_bIsModel;
}

void CLayPinDlg::HighlightSubEnt(double dProheight)
{
	CString sGroupNO;
	GetDlgItemText(IDC_GROUP_NO, sGroupNO);

	AcDbObjectIdArray arTemp,arAll;
	ThunderContainer->GetCircle(sGroupNO, arTemp);
	arAll.append(arTemp);
	ThunderContainer->GetRegion(sGroupNO, arTemp);
	arAll.append(arTemp);

	CString sPro;
	CThunderXData xd;
	// 挑选合适的实体并高亮
	for (int i = 0;i < arAll.length();++i)
	{
		if (arAll[i].isValid())
		{
			OPENOBJ_BEGIN(arAll[i], AcDb::kForRead, AcDbEntity, pEnt);
			if (pEnt != NULL)
			{
				xd.GetXData(pEnt, TEL_CURRENT_PROHEIGHT, sPro);
				if (fabs(dProheight-_tstof(sPro)) < 1e-3)
				{
					pEnt->highlight();
					m_arHlEnt.append(arAll[i]);
				}
			}
			OPENOBJ_END();
		}
	}

	acedUpdateDisplay();
	actrTransactionManager->flushGraphics();
}

void CLayPinDlg::UnHighlightSubEnt()
{
	for (int i = 0;i < m_arHlEnt.length();++i)
	{
		if (m_arHlEnt[i].isValid())
		{
			OPENOBJ_BEGIN(m_arHlEnt[i], AcDb::kForRead, AcDbEntity, pEnt);
			if (pEnt != NULL)
			{
				pEnt->unhighlight();
			}
			OPENOBJ_END();
		}
	}

	m_arHlEnt.setLogicalLength(0);

	acedUpdateDisplay();
	actrTransactionManager->flushGraphics();
}

void CLayPinDlg::SetDbReactorPtr(CThunderDbReactor* pRector)
{
	m_pReactor = pRector;
}

void CLayPinDlg::GetThunderProHeight(AcGeDoubleArray& arPro)
{
	arPro = m_arProHeight;
}

double CLayPinDlg::GetThunderRadius() const
{
	return _tstof(m_strRadius);
}

void CLayPinDlg::OnDestroy() 
{
	if (!m_bIsModel)
	{
		SaveDlgData();
	}
	CDialog::OnDestroy();

	UnHighlightSubEnt();	
}

void CLayPinDlg::OnChangeGroupNo() 
{
	if (!m_bValid)
	{
		return;
	}

	UpdateData();

	if (_ttoi(m_sGroupNo) < 1)
	{
		CString strTip;
		strTip.Format(_T("组号最小为1"));
		m_bTipChange = TRUE;
		PostErrorToCue(strTip);
		return;
	}

	// 避雷针编号
	AcGeIntArray arNum;
	ThunderContainer->GetNumArrayBySpecGroup(m_sGroupNo, arNum);
	if (arNum.length() > 0)
	{
		CString sNum;
		sNum.Format(_T("%d"), arNum.last()+1);
		m_edtNumber.SetWindowText(sNum);
	}
	else
	{
		m_edtNumber.SetWindowText(_T("1"));
	}
}

void CLayPinDlg::OnGroupExplain() 
{
	CAcModuleResourceOverride myResources;
	CGroupHelp hlpDlg;
	hlpDlg.DoModal();
}


void CLayPinDlg::ReadDlgData()
{
	//读取设置
	CString sGroup;
	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
	regProp.SetTopRootKey(HKEY_CURRENT_USER);

	regProp.GetValue(_T("PIN_RADIUS"),m_strRadius);
	regProp.GetValue(_T("PIN_HEIGHT"),m_strPinHeight);
}

void CLayPinDlg::SaveDlgData()
{
	//保存设置
	UpdateData(TRUE);
	CRegProperty regProp(GetRegLocation(), TEL_OBJECTKEY);
	regProp.SetTopRootKey(HKEY_CURRENT_USER);
	regProp.SetValue(_T("PIN_RADIUS"),m_strRadius);
	regProp.SetValue(_T("PIN_HEIGHT"),m_strPinHeight);
}