// ArcStairDlg.cpp : implementation file
//

#include "stdafx.h"
#include "resource.h"
#include "ArcStairCreateDlg.h"

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


/////////////////////////////////////////////////////////////////////////////
// CArcStairCreateDlg dialog

CString CArcStairCreateDlg::m_strStartAngle = _T("0");
CString CArcStairCreateDlg::m_strSweepAngle = _T("180");
CString CArcStairCreateDlg::m_strInRadius = _T("800");
int	CArcStairCreateDlg::m_nFace = 1;
int CArcStairCreateDlg::m_nLocate = 0;
CString CArcStairCreateDlg::m_strOutRadius = _T("2000");
CString CArcStairCreateDlg::m_strStairWidth = _T("1200");
CArcStairCreateDlg * CArcStairCreateDlg::p_selfARC=NULL;

BOOL CArcStairCreateDlg::m_bInsideR=FALSE;
BOOL CArcStairCreateDlg::m_bOutsideR=FALSE;
BOOL CArcStairCreateDlg::m_bAngle=FALSE;
//以下是对处理错误的填写数据判断的初始化
BOOL CArcStairCreateDlg::m_bError=FALSE;
//-------------------------------------
//以下是对ESC响应变量的初始化
BOOL CArcStairCreateDlg::m_bAng=FALSE;
BOOL CArcStairCreateDlg::m_bUpdateEdit=FALSE;
BOOL CArcStairCreateDlg::m_bPRI = FALSE;
BOOL CArcStairCreateDlg::m_bPRO = FALSE;
//-------------------------------------------
BOOL CArcStairCreateDlg::m_bWGroupStatus=FALSE;
//
int CArcStairCreateDlg::m_isaveStepNum=20;
CString CArcStairCreateDlg::m_strsaveStepHeight=_T("150");
CString CArcStairCreateDlg::m_strsaveStairHeight=_T("3000");
IMPLEMENT_DYNAMIC(CArcStairCreateDlg, CBaseStairDlg)
CArcStairCreateDlg::CArcStairCreateDlg(CWnd* pParent /*=NULL*/)
: CBaseStairDlg(CArcStairCreateDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CArcStairCreateDlg)
	//}}AFX_DATA_INIT
	/*m_groups.Append(&m_group1);
	m_groups.Append(&m_group2);
	m_groups.Append(&m_group3);*/

	//SetNeedCapBtn(TRUE);
	Exchange(m_nStepNum,m_isaveStepNum);
	Exchange(m_strStepHeight,m_strsaveStepHeight);
	Exchange(m_strStairHeight,m_strsaveStairHeight);

	m_bEdit=FALSE;//处于非编辑状态
	m_pBakObj=NULL;//为空状态
	m_bClickClose=FALSE;
}
CArcStairCreateDlg::~CArcStairCreateDlg()
{
	Exchange(m_nStepNum,m_isaveStepNum);
	Exchange(m_strStepHeight,m_strsaveStepHeight);
	Exchange(m_strStairHeight,m_strsaveStairHeight);
	if (m_bEdit)
	{
		if (m_pBakObj)
			delete m_pBakObj;//这个地方是不是有问题
	}
}
AcDbEntity *
CArcStairCreateDlg::NewObject()
{
	if (m_pBakObj==NULL)
	{
		TDbArcStair *pEnt=new TDbArcStair;
		pEnt->setLayer(InitLayer(LAY_STAIR));
		return pEnt;
	}
	return (AcDbEntity*)(m_pBakObj->clone());
}


void CArcStairCreateDlg::DoDataExchange(CDataExchange* pDX)
{
	CBaseStairDlg::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CArcStairCreateDlg)
	DDX_Text(pDX, IDC_STARTANGLE, m_strStartAngle);
	DDX_Text(pDX, IDC_SWEEPANGLE, m_strSweepAngle);
	DDX_Radio(pDX, IDC_DEASIL, m_nFace);
	DDX_Radio(pDX, IDC_LOCATE_IN, m_nLocate);
	DDX_Check(pDX,IDC_AS_ASCENT,m_ascent);
	DDX_Control(pDX,IDC_GROUP3,m_WGroup);
	DDX_GroupStatus(pDX,IDC_GROUP3,m_bWGroupStatus);
	//}}AFX_DATA_MAP
	if (!pDX->m_bSaveAndValidate)
	{
		DDX_Text(pDX, IDC_STAIR_INRADIUS, m_strInRadius);
		DDX_Text(pDX, IDC_STAIR_WIDTH, m_strStairWidth);
		DDX_Text(pDX, IDC_STEP_OUTRADIUS, m_strOutRadius);
	}
}
BEGIN_MESSAGE_MAP(CArcStairCreateDlg, CBaseStairDlg)
	//{{AFX_MSG_MAP(CArcStairCreateDlg)
	ON_BN_CLICKED(IDC_BT_STARTANGLE, OnBtStartangle)
	ON_BN_CLICKED(IDC_PICK_RADIUSIN, OnPickRadiusIn)
	ON_BN_CLICKED(IDC_PICK_RADIUSOUT, OnPickRadiusOut)
	ON_EN_KILLFOCUS(IDC_STEP_OUTRADIUS,OnKFRadiusOut)//外圆半径的失去焦点的处理函数
	ON_EN_KILLFOCUS(IDC_STAIR_INRADIUS,OnKFRadiusIn)//内圆半径失去焦点的处理函数
	ON_EN_KILLFOCUS(IDC_STAIR_WIDTH,OnKFStairWidth)
	ON_EN_KILLFOCUS(IDC_SWEEPANGLE,OnKFSweepAngle)//圆心角失去焦点的处理函数
	ON_EN_KILLFOCUS(IDC_STARTANGLE,OnKFStartAngle)//起始角度失去焦点的处理函数
	ON_EN_CHANGE(IDC_STEP_OUTRADIUS,OnChangeRadiusOut)//外圆半径的change处理函数
	ON_EN_CHANGE(IDC_STAIR_INRADIUS,OnChangeRadiusIn)//内圆半径的change处理函数
	ON_EN_CHANGE(IDC_STAIR_WIDTH,OnChangeStairWidth)//梯段宽度的change处理函数
	ON_EN_CHANGE(IDC_STARTANGLE,OnChangeStartAngle)//起始角度的change处理函数
	ON_EN_CHANGE(IDC_SWEEPANGLE,OnChangeSweepAngle)//圆心角度的change处理函数
	ON_EN_CHANGE(IDC_STEP_HEIGHT,OnChangeStepHeight)//对梯段高度的改变的应用
	ON_EN_CHANGE(IDC_STEP_NUM,OnChangeStepNum)//对踏步数目的改变的应用
	ON_EN_CHANGE(IDC_STAIR_HEIGHT,OnChangeStairHeight)//对梯段高度的问题的解决
	ON_EN_KILLFOCUS(IDC_STEP_NUM,OnKFStepNum)//对踏步数目的失去焦点的应用
	ON_EN_KILLFOCUS(IDC_STAIR_HEIGHT,OnKFStairHeight)//对梯段高度的失去焦点的应用
	ON_EN_KILLFOCUS(IDC_STEP_HEIGHT,OnKFStepHeight)//对踏步高度的失去焦点的应用
	ON_BN_CLICKED(IDC_LOCATE_OUT, OnLocate)
	ON_BN_CLICKED(IDC_LOCATE_IN, OnLocate)
	//}}AFX_MSG_MAP
	ON_WM_CLOSE()
	ON_WM_NCDESTROY()
	ON_BN_CLICKED(IDC_LEFT_BEAM, CArcStairCreateDlg::OnBnClickedLeftBeam)
	ON_BN_CLICKED(IDC_RIGHT_BEAM, CArcStairCreateDlg::OnBnClickedRightBeam)
	ON_BN_CLICKED(IDC_NO_PAO, CArcStairCreateDlg::OnBnClickedNoPao)
	ON_BN_CLICKED(IDC_BOTTOM_PAO, CArcStairCreateDlg::OnBnClickedBottomPao)
	ON_BN_CLICKED(IDC_DOUBLE_PAO, CArcStairCreateDlg::OnBnClickedDoublePao)
	ON_BN_CLICKED(IDC_UP_SECT, CArcStairCreateDlg::OnBnClickedUpSect)
	/*ON_BN_CLICKED(IDC_NO_PAO, UpdateImage)
	ON_BN_CLICKED(IDC_BOTTOM_PAO, UpdateImage)
	ON_BN_CLICKED(IDC_DOUBLE_PAO, UpdateImage)
	ON_BN_CLICKED(IDC_UP_SECT, UpdateImage)*/
	ON_BN_CLICKED(IDC_AS_ASCENT, CArcStairCreateDlg::OnBnClickedAsAscent)
	ON_BN_CLICKED(IDC_DEASIL, CArcStairCreateDlg::OnBnClickedDeasil)
	ON_BN_CLICKED(IDC_ANTICLOCKWISE, CArcStairCreateDlg::OnBnClickedAnticlockwise)
	ON_BN_CLICKED(IDC_HAS_SLANT, CArcStairCreateDlg::OnBnClickedHasSlant)
	ON_BN_CLICKED(IDC_ON_GROUND, CArcStairCreateDlg::OnBnClickedOnGround)
	ON_WM_KEYUP()
	ON_BN_CLICKED(IDC_NEED3D, CArcStairCreateDlg::OnBnClickedNeed3d)
	ON_BN_CLICKED(IDC_NEED2D, CArcStairCreateDlg::OnBnClickedNeed2d)
END_MESSAGE_MAP()
void CArcStairCreateDlg::OnChangeStairHeight()
{
}
void CArcStairCreateDlg::OnChangeStepHeight()
{
}
void CArcStairCreateDlg::OnChangeStepNum()
{
//	UpdateEdit(IDC_STEP_NUM,true);
	CString temp;
	this->GetDlgItem(IDC_STEP_NUM)->GetWindowText(temp);
	if (temp!=_T("")&&temp!=_T("1"))
	{
		UpdateEdit(IDC_STEP_NUM,false);
	}
}
void CArcStairCreateDlg::OnKFStairHeight()
{
// 	if (this->CheckENChange(IDC_STAIR_HEIGHT,m_strStairHeight))
// 	{
// 		this->UpdateEdit(IDC_STAIR_HEIGHT,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STAIR_HEIGHT)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strStairHeight))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STAIR_HEIGHT,true);
	}

}
void CArcStairCreateDlg::OnKFStepHeight()
{
// 	if (this->CheckENChange(IDC_STEP_HEIGHT,m_strStepHeight))
// 	{
// 		this->UpdateEdit(IDC_STEP_HEIGHT,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STEP_HEIGHT)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strStepHeight))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STEP_HEIGHT,true);
	}
}
void CArcStairCreateDlg::OnKFStepNum()
{
// 	BOOL bResult;
// 	int x;
// 	x=this->GetDlgItemInt(IDC_STEP_NUM,&bResult,FALSE);
// 	if (x!=m_nStepNum)
// 	{
// 		this->UpdateEdit(IDC_STEP_NUM,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STEP_NUM)->GetWindowText(strText);
		if (fabs(_tstof(strText)-m_nStepNum)<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STEP_NUM,true);
	}
}
void CArcStairCreateDlg::OnKFRadiusIn()
{
// 	if (this->CheckENChange(IDC_STAIR_INRADIUS,m_strInRadius))
// 	{
// 		UpdateEdit(IDC_STAIR_INRADIUS,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STAIR_INRADIUS)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strInRadius))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STAIR_INRADIUS,true);
	}
}
void CArcStairCreateDlg::OnKFRadiusOut()
{
// 	if (this->CheckENChange(IDC_STEP_OUTRADIUS,m_strOutRadius))
// 	{
// 		UpdateEdit(IDC_STEP_OUTRADIUS,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STEP_OUTRADIUS)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strOutRadius))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STEP_OUTRADIUS,true);
	}
}
void CArcStairCreateDlg::OnKFStairWidth()
{
// 	if (this->CheckENChange(IDC_STAIR_WIDTH,m_strStairWidth))
// 	{
// 		UpdateEdit(IDC_STAIR_WIDTH,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STAIR_WIDTH)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strStairWidth))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STAIR_WIDTH,true);
	}
}
void CArcStairCreateDlg::OnKFStartAngle()
{
// 	if (this->CheckENChange(IDC_STARTANGLE,m_strStartAngle))
// 	{
// 		UpdateEdit(IDC_STARTANGLE,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_STARTANGLE)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strStartAngle))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_STARTANGLE,true);
	}
}
void CArcStairCreateDlg::OnKFSweepAngle()
{
// 	if (this->CheckENChange(IDC_SWEEPANGLE,m_strSweepAngle))
// 	{
// 		UpdateEdit(IDC_SWEEPANGLE,true);
// 	}
	if (m_bClickClose)
		return;
	if (GetFocus()!=GetDlgItem(IDCANCEL))
	{
		CString strText;
		GetDlgItem(IDC_SWEEPANGLE)->GetWindowText(strText);
		if (fabs(_tstof(strText)-_tstof(m_strSweepAngle))<_DIST_SNAP)
			return;

		UpdateEdit(IDC_SWEEPANGLE,true);
	}
}
void CArcStairCreateDlg::OnChangeRadiusIn()
{
	//do  nothing
}
void CArcStairCreateDlg::OnChangeRadiusOut()
{
	//do nothing
}
void CArcStairCreateDlg::OnChangeStairWidth()
{
	//do nothing
}
void CArcStairCreateDlg::OnChangeStartAngle()
{
	//do nothing
}
void CArcStairCreateDlg::OnChangeSweepAngle()
{
	//do nothing
}
//数据关系：
//外径变化会引起宽度变化,内径不变；
//内径变化会引起宽度变化,外径不变；
//以外径定位，则宽度变化会引起内径变化；以内径定位，则宽度变化会引起外径变化。
bool CArcStairCreateDlg::UpdateEdit(UINT ctrlID,bool bReportError)
{
	CWnd *pImageBox=GetDlgItem(IDC_PREVIEW);
	if (!pImageBox)
		return false;

	if (GetSafeHwnd()==NULL)
		return false;
	CEdit *pEdit=(CEdit*)GetDlgItem(ctrlID);
	if (pEdit==NULL)
		return false;

	static bool bUpdating=false;
	if (bUpdating)
		return false;
	bUpdating=true;

	CString temp;
	pEdit->GetWindowText(temp);
	bool bContinue=false;
	CDataExchange dxOut(this,false);
	switch(ctrlID)
	{
	case IDC_STAIR_INRADIUS://内圆半径
		{
			if ((_tstof(temp)<_tstof(m_strOutRadius)) && _tstof(temp)>0)//  [9/14/2007 nsh]
			{
				m_strInRadius=temp;
				m_strStairWidth=Dist2Str(_tstof(m_strOutRadius)-_tstof(m_strInRadius));
				DDX_Text(&dxOut,IDC_STAIR_WIDTH,m_strStairWidth);
				UpdateImage();
			}
			else if (bReportError)
			{
				CArcStairCreateDlg::m_bError=TRUE;
				//AfxMessageBox(_T("内半径必须小于外半径!"));
				this->MessageBox(_T("内半径必须小于外半径!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_STAIR_INRADIUS,m_strInRadius);
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}
		}
		break;
	case IDC_STEP_OUTRADIUS://外圆半径
		{
			if (_tstof(temp)>_tstof(m_strInRadius))
			{
				m_strOutRadius=temp;
				m_strStairWidth=Dist2Str(_tstof(m_strOutRadius)-_tstof(m_strInRadius));
				DDX_Text(&dxOut,IDC_STAIR_WIDTH,m_strStairWidth);
				UpdateImage();
			}
			else if (bReportError)
			{
				CArcStairCreateDlg::m_bError=TRUE;
				this->MessageBox(_T("外半径必须大于内半径!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_STEP_OUTRADIUS,m_strOutRadius);
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}
		}
		break;
	case IDC_STAIR_WIDTH://梯段宽度
		{
			if (m_nLocate)
			{
				if (_tstof(temp)<=_tstof(m_strOutRadius))
				{
					m_strStairWidth=temp;
					m_strInRadius=Dist2Str(_tstof(m_strOutRadius)-_tstof(m_strStairWidth));
					DDX_Text(&dxOut,IDC_STAIR_INRADIUS,m_strInRadius);
					UpdateImage();
				}
				else if (bReportError)
				{
					CArcStairCreateDlg::m_bError =TRUE;
					this->MessageBox(_T("宽度超过了外半径!"),_T("AutoCAD"),MB_OK);
					DDX_Text(&dxOut,IDC_STAIR_WIDTH,m_strStairWidth);
					pEdit->SetFocus();
					pEdit->SetSel(0,-1);
				}
			}
			else
			{
				if (_tstof(temp)>0)
				{
					m_strStairWidth=temp;
					m_strOutRadius=Dist2Str(_tstof(m_strInRadius)+_tstof(m_strStairWidth));
					DDX_Text(&dxOut,IDC_STEP_OUTRADIUS,m_strOutRadius);
					UpdateImage();
				}
				else if (bReportError)
				{
					CArcStairCreateDlg ::m_bError =TRUE;
					this->MessageBox(_T("宽度太小!"),_T("AutoCAD"),MB_OK);
					DDX_Text(&dxOut,IDC_STAIR_WIDTH,m_strStairWidth);
					pEdit->SetFocus();
					pEdit->SetSel(0,-1);
				}
			}
		}
		break;
	case IDC_STARTANGLE://起始角度
		{
			m_strStartAngle=temp;
			UpdateImage();
		}
		break;
	case IDC_SWEEPANGLE://圆心角度
		{
			if (fabs(_tstof(temp))>0.1)
			{
				m_strSweepAngle=temp;
				UpdateImage();
			}
			else if (bReportError)
			{
				CArcStairCreateDlg ::m_bError=TRUE;
				this->MessageBox(_T("圆心角太小!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_SWEEPANGLE,m_strSweepAngle);
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}
		}
		break;
	case IDC_STAIR_HEIGHT://梯段高度
		{
			//to deal with the stair-height
			if (_tstof(temp)>=2*_tstof(m_strStepHeight)-_DIST_SNAP)	{//最少当前两踏步高
				m_strStairHeight=temp;
				m_nStepNum=(int)(_tstof(m_strStairHeight)/_tstof(m_strStepHeight)+0.5);
				m_strStepHeight.Format(_T("%.2f"),(_tstof(m_strStairHeight)/m_nStepNum));
				DDX_Text(&dxOut,IDC_STEP_HEIGHT,m_strStepHeight);
				DDX_Text(&dxOut,IDC_STEP_NUM,m_nStepNum);
				UpdateImage();
			}	else if (bReportError)	{
				CArcStairCreateDlg::m_bError=TRUE;
				this->MessageBox(_T("梯段高度太小!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_STAIR_HEIGHT,m_strStairHeight);//还原
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}
		}
		break;
		//以下为踏步的处理函数 ---------------------------------------------------------

	case IDC_STEP_NUM://踏步数目
		{
			//to deal with the step-num
			if (_ttoi(temp)>1)	{
				m_nStepNum=_ttoi(temp);
				m_strStepHeight.Format(_T("%.2f"),_tstof(m_strStairHeight)/m_nStepNum);//modified on 03/07/15 by whl
				DDX_Text(&dxOut,IDC_STEP_HEIGHT,m_strStepHeight);		    
				UpdateImage();
			}	else if (bReportError)	{
				CArcStairCreateDlg::m_bError=TRUE;
				this->MessageBox(_T("踏步数必须大于1!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_STEP_NUM,m_nStepNum);//还原
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}

		}
		break;
	case IDC_STEP_HEIGHT://踏步高度
		{
			//to deal with the step-height
			int num=(int)(_tstof(m_strStairHeight)/_tstof(temp)+0.5);
			if (_tstof(temp)>0&&num>1)	{
				m_nStepNum=num;
				m_strStepHeight.Format(_T("%.2f"),_tstof(m_strStairHeight)/m_nStepNum);//modified on 03/07/15 by whl
				DDX_Text(&dxOut,IDC_STEP_NUM,m_nStepNum);
				if (bReportError)
					DDX_Text(&dxOut,IDC_STEP_HEIGHT,m_strStepHeight);//自动调整			
				UpdateImage();
			}	else if (bReportError)	{
				CArcStairCreateDlg::m_bError=TRUE;
				if (_tstof(temp)<=0)
					this->MessageBox(_T("踏步高度太小!"),_T("AutoCAD"),MB_OK);
				else 
					this->MessageBox(_T("新踏步高度将造成踏步数小于2，请重新输入或先增大梯段高度!"),_T("AutoCAD"),MB_OK);
				DDX_Text(&dxOut,IDC_STEP_HEIGHT,m_strStepHeight);//还原
				pEdit->SetFocus();
				pEdit->SetSel(0,-1);
			}
		}
		break;
		// ------------------------------------------- [9/14/2007 nsh]
	default:
		if (m_bEdit)
			break;
		else
			bContinue=true;
	}
	CArcStairCreateDlg::m_bUpdateEdit=TRUE;
	if (!m_bEdit)
	{
		if (!CArcStairCreateDlg::m_bError)
		{
			acedPostCommand(_T("\33"));
		}
		else
		{
			CArcStairCreateDlg::m_bError=FALSE;
		}
	}
	bUpdating=false;

	return bContinue?CBaseStairDlg::UpdateEdit(ctrlID,bReportError):true;
}
void CArcStairCreateDlg::Dlg2Obj(AcDbEntity *pStep)    //  对话框数据传向实体
{
	CBaseStairDlg::Dlg2Obj(pStep);           //  调用公共部分：
	TDbArcStair *pArcStair=TDbArcStair::cast(pStep);
	ASSERT(pArcStair);

	pArcStair->SetRadiusOut(_tstof(m_strOutRadius));
	pArcStair->SetRadiusIn(_tstof(m_strInRadius));
	pArcStair->SetStartAngle(Ucs2Wcs(_tstof(m_strStartAngle)*PI/180.0));
	if (m_nFace)
		pArcStair->SetSweepAngle(_tstof(m_strSweepAngle) * PI / 180.0);
	else
		pArcStair->SetSweepAngle(- _tstof(m_strSweepAngle) * PI / 180.0);

	if (m_bEdit)
	{
		if (m_pBakObj)
			delete m_pBakObj;
		m_pBakObj=(TDbArcStair*)(pArcStair->clone());
	}
	return;
}
void CArcStairCreateDlg::Obj2Dlg(const AcDbEntity *pStep)    //  实体数据传向对话框
{
	CBaseStairDlg::Obj2Dlg(pStep);           //  调用公共部分	
	TDbArcStair *pArcStair=TDbArcStair::cast(pStep);
	ASSERT(pArcStair);

	m_bEdit=TRUE;
	m_pBakObj=(TDbArcStair*)(pArcStair->clone());

	double nSweepAngle = ( pArcStair->GetSweepAngle()) * 180.0 / PI;
	m_strStairHeight=Dist2Str(m_nStepNum * _tstof(m_strStepHeight));
	m_strInRadius=Dist2Str(pArcStair->GetRadiusIn());
	m_strOutRadius=Dist2Str(pArcStair->GetRadiusOut());

	//modify by xlc on 090630  解决了编辑时梯段宽不正确的问题
	m_strStairWidth=Dist2Str(pArcStair->GetRadiusOut()-pArcStair->GetRadiusIn());

	m_strStartAngle=Dist2Str( Wcs2Ucs(pArcStair->GetStartAngle()) * 180.0 / PI);
	if ( nSweepAngle < 0)
		m_nFace = 0;
	else
		m_nFace = 1;
	m_strSweepAngle=Angle2Str(fabs(nSweepAngle));
	m_ascent=pArcStair->IsAscent();

	return;
}
void CArcStairCreateDlg::OnBtStartangle() 
{//拾取开始角度的操作
	if (m_bEdit)
	{
		double nStartAngle=_tstof(m_strStartAngle);

		BeginEditorCommand();
		adsout << _T("\n起始角度") << (const TCHAR *)m_strStartAngle << _T(": ");
		int nRet=ads_getangle(NULL, _T(""), &nStartAngle);
		CompleteEditorCommand();

		if (nRet==RTNORM)
		{
			CString temp=Angle2Str(nStartAngle * 180.0 / PI);
			CDataExchange dxOut(this,false);
			DDX_Text(&dxOut,IDC_STARTANGLE,temp);
			UpdateEdit(IDC_STARTANGLE,true);
		}
	}
	else
	{
		CArcStairCreateDlg::m_bAngle=TRUE;
		acedGetAcadDwgView()->SetFocus();
		this->ShowWindow(SW_HIDE);
		CArcStairCreateDlg::m_bAng=TRUE;
		acedPostCommand(_T("\33"));
	}
}
void CArcStairCreateDlg::OnPickRadiusIn() 
{//拾取内圆半径的操作
	if (m_bEdit)
	{
		double nRadiusIn = _tstof(m_strInRadius);

		BeginEditorCommand();
		int nRet=GetDist(_T("\n内圆半径"), nRadiusIn, RSG_NONEG|RSG_NOZERO); 
		CompleteEditorCommand();

		if (nRet==RTNORM)
		{
			CString temp=Dist2Str(nRadiusIn);
			CDataExchange dxOut(this,false);
			DDX_Text(&dxOut,IDC_STAIR_INRADIUS,temp);
			UpdateEdit(IDC_STAIR_INRADIUS,true);
		}
	}
	else
	{
		CArcStairCreateDlg::m_bInsideR=TRUE;
		acedGetAcadDwgView()->SetFocus();
		this->ShowWindow(SW_HIDE);
		CArcStairCreateDlg::m_bPRI=TRUE;
		acedPostCommand(_T("\33"));
	}
}
void CArcStairCreateDlg::OnPickRadiusOut() 
{//拾取外圆半径的操作
	if (m_bEdit)
	{
		double nRadiusOut = _tstof(m_strOutRadius);

		BeginEditorCommand();
		int nRet=GetDist(_T("\n外圆半径"), nRadiusOut, RSG_NONEG|RSG_NOZERO);
		CompleteEditorCommand();

		if (nRet==RTNORM)
		{
			CString temp=Dist2Str(nRadiusOut);
			CDataExchange dxOut(this,false);
			DDX_Text(&dxOut,IDC_STEP_OUTRADIUS,temp);
			UpdateEdit(IDC_STEP_OUTRADIUS,true);
		}
	}
	else
	{
		CArcStairCreateDlg::m_bOutsideR=TRUE;
		acedGetAcadDwgView()->SetFocus();
		this->ShowWindow(SW_HIDE);
		CArcStairCreateDlg::m_bPRO =TRUE;
		acedPostCommand(_T("\33"));
	}
}
void CArcStairCreateDlg::OnLocate() 
{
	CDataExchange dxIn(this,true);
	this->UpdateData();
	this->UpdateEdit(IDC_LOCATE_IN,m_nLocate==0?false:true);
}
BOOL CArcStairCreateDlg::OnInitDialog() 
{
	CBaseStairDlg::OnInitDialog();	
	//m_groups.SetMaxExtent(350);
	//this->CheckDlgButton(IDC_DOUBLE_PAO,TRUE);
	this->UpdateImage();
	AddTip(IDC_LOCATE_OUT,_T("当外圆定位时，修改梯段宽度不影响外径"));
	AddTip(IDC_LOCATE_IN,_T("当内圆定位时，修改梯段宽度不影响内径"));
	AddTip(IDC_PICK_RADIUSOUT,_T("外径变化将使梯段宽度随之变化，而内径保持不变"));
	AddTip(IDC_PICK_RADIUSIN,_T("内径变化将使梯段宽度随之变化，而外径保持不变"));
	AddTip(IDC_STAIR_WIDTH_STATIC,_T("梯段宽度始终等于外径减去内径"));

	if (m_bEdit)
	{
		GetDlgItem(IDC_STEP_ELEV)->EnableWindow(TRUE);
	}
	else
	{
		m_strElev="0";
		CRect rect,rect1;
		GetDlgItem(IDC_PREVIEW)->GetWindowRect(rect);
		GetDlgItem(IDOK)->GetWindowRect(rect1);

		ScreenToClient(rect);
		ScreenToClient(rect1);
		rect.bottom = rect1.bottom;
		GetDlgItem(IDC_PREVIEW)->MoveWindow(rect);

		GetDlgItem(IDOK)->ShowWindow(SW_HIDE);
		GetDlgItem(IDCANCEL)->ShowWindow(SW_HIDE);
	}
	return TRUE;
}

void CArcStairCreateDlg::OnClose()
{
	if (m_bEdit)
	{
		GetDlgItem(IDCANCEL)->SetFocus();
	}
	else
	{
		m_bClickClose=TRUE;
		CArcStairCreateDlg::p_selfARC=NULL;
		acedPostCommand(_T("\33"));
	}
	CBaseStairDlg::OnClose();
}

void CArcStairCreateDlg::OnNcDestroy()
{
	if (m_bEdit)
		return;
	CBaseStairDlg::OnNcDestroy();
	acedPostCommand(_T("\33"));
	delete this;
}

void CArcStairCreateDlg::OnBnClickedLeftBeam()
{
	this->UpdateData();
	UpdateImage();
	UpdateEdit(IDC_LEFT_BEAM,true);
}

void CArcStairCreateDlg::OnBnClickedRightBeam()
{
	this->UpdateData();
	UpdateImage();
	UpdateEdit(IDC_RIGHT_BEAM,true);
}

void CArcStairCreateDlg::OnBnClickedNoPao()
{
	this->UpdateImage();
	this->UpdateData();
	UpdateEdit(IDC_NO_PAO,true);
}

void CArcStairCreateDlg::OnBnClickedBottomPao()
{
	UpdateImage();
	this->UpdateData();
	UpdateEdit(IDC_BOTTOM_PAO,true);
}

void CArcStairCreateDlg::OnBnClickedDoublePao()
{
	this->UpdateImage();
	this->UpdateData();
	UpdateEdit(IDC_DOUBLE_PAO,true);
	this->UpdateData(FALSE);
}

void CArcStairCreateDlg::OnBnClickedUpSect()
{
	UpdateImage();
	this->UpdateData();;
	UpdateEdit(IDC_UP_SECT,true);
}

void CArcStairCreateDlg::OnBnClickedAsAscent()
{
	this->UpdateData();
	if (m_ascent==TRUE)
	{
		this->GetDlgItem(IDC_HAS_SLANT)->EnableWindow(TRUE);
		this->GetDlgItem(IDC_ON_GROUND)->EnableWindow(TRUE);
	}
	else
	{
		this->GetDlgItem(IDC_HAS_SLANT)->EnableWindow(FALSE);
		this->GetDlgItem(IDC_ON_GROUND)->EnableWindow(FALSE);
	}
	this->UpdateImage();
	this->UpdateEdit(IDC_AS_ASCENT,true);
}


void CArcStairCreateDlg::OnBnClickedDeasil()
{
	this->UpdateData();
	this->UpdateImage();
	this->UpdateEdit(IDC_DEASIL,true);
}

void CArcStairCreateDlg::OnBnClickedAnticlockwise()
{
	this->UpdateData();
	this->UpdateImage();
	this->UpdateEdit(IDC_ANTICLOCKWISE,true);
}

void CArcStairCreateDlg::OnBnClickedHasSlant()
{
	this->UpdateData();
	this->UpdateImage();
	this->UpdateEdit(IDC_HAS_SLANT,true);
}

void CArcStairCreateDlg::OnBnClickedOnGround()
{
	this->UpdateData();
	this->UpdateImage();
	this->UpdateEdit(IDC_ON_GROUND,true);
}
void CArcStairCreateDlg::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if (nChar==VK_ESCAPE)
	{
		if (!m_bEdit)
		{
			acedPostCommand(_T("\33"));
			CArcStairCreateDlg::p_selfARC=NULL;
			CArcStairCreateDlg::OnCancel();
		}
	}
	CBaseStairDlg::OnKeyUp(nChar, nRepCnt, nFlags);
}

void CArcStairCreateDlg::OnBnClickedNeed3d()
{
	this->UpdateSel();
	this->UpdateEdit(IDC_NEED3D,true);
}

void CArcStairCreateDlg::OnBnClickedNeed2d()
{
	this->UpdateSel();
	this->UpdateEdit(IDC_NEED2D,true);
}
BOOL CArcStairCreateDlg::CheckENChange(UINT ctrlID,const CString pStr)
{//判断是否对编辑框的数值进行了改变，如果改变了，则返回TRUE，没有改变则返回FALSE
	CString temp;
	this->GetDlgItemText(ctrlID,temp);
	if (temp==pStr)
	{
		return FALSE;
	}

	return TRUE;
}