// FortifyColumnDlg.cpp : implementation file
//
#include "stdafx.h"
#include "FortifyColumnDlg.h"
  
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

extern int IsPoint2dEqual(XPoint pt1, XPoint pt2);
#define ROUND(x) (fabs(x)-int(fabs(x)) > 0.5 ? (x>0 ? 1 : -1)*(int(fabs(x))+1) : (x>0 ? 1 : -1)*int(fabs(x)))

/////////////////////////////////////////////////////////////////////////////
// CFortifyColumnDlg dialog

IMPLEMENT_DYNAMIC(CFortifyColumnDlg, GlwCAcUiDialog)

CFortifyColumnDlg::CFortifyColumnDlg(CWnd* pParent /*=NULL*/)
	: GlwCAcUiDialog(CFortifyColumnDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CFortifyColumnDlg)
	m_iA = -1;
	m_iD = -1;
	m_bM = FALSE;
	m_csAC = _T("");
	m_csBD = _T("");
	//}}AFX_DATA_INIT
	m_WallCount=0;
}

CFortifyColumnDlg::CFortifyColumnDlg(const AcDbObjectIdArray &idWallArray,XPoint ptRef1,XPoint ptRef2,XPoint ptRef3,XPoint ptRef4,CWnd* pParent/*=NULL*/)
	: GlwCAcUiDialog(CFortifyColumnDlg::IDD, pParent)
{
	m_iA = -1;
	m_iD = -1;
	m_bM = FALSE;
	m_csAC = _T("");
	m_csBD = _T("");

	m_ptRef1=ptRef1; m_ptRef2=ptRef2; m_ptRef3=ptRef3; m_ptRef4=ptRef4;

    int len=idWallArray.length();
    ASSERT(len>0);
    m_idWallArray.setLogicalLength(len);
    for (int i=0; i<len; i++) m_idWallArray[i]=idWallArray[i];

	m_WallCount=0;
	m_ColumnPoly.SetFlag(1);
}

void CFortifyColumnDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFortifyColumnDlg)
	DDX_Control(pDX, IDC_COMBO_BD, m_BD);
	DDX_Control(pDX, IDC_COMBO_AC, m_AC);
	DDX_Radio(pDX, IDC_RADIO_A, m_iA);
	DDX_Radio(pDX, IDC_RADIO_D, m_iD);
	DDX_Check(pDX, IDC_CHECK_M, m_bM);
	DDX_CBString(pDX, IDC_COMBO_AC, m_csAC);
	DDX_CBString(pDX, IDC_COMBO_BD, m_csBD);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CFortifyColumnDlg, GlwCAcUiDialog)
	//{{AFX_MSG_MAP(CFortifyColumnDlg)
	ON_BN_CLICKED(IDC_RADIO_A, OnRadioAC)
	ON_BN_CLICKED(IDC_RADIO_D, OnRadioBD)
	ON_BN_CLICKED(IDC_CHECK_M, OnCheckM)
	ON_CBN_KILLFOCUS(IDC_COMBO_AC, OnKillfocusComboAc)
	ON_CBN_KILLFOCUS(IDC_COMBO_BD, OnKillfocusComboBd)
	ON_BN_CLICKED(IDC_RADIO_B, OnRadioBD)
	ON_BN_CLICKED(IDC_RADIO_C, OnRadioAC)
	ON_WM_PAINT()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFortifyColumnDlg message handlers

BOOL CFortifyColumnDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	
	// TODO: Add extra initialization here
	int len=m_idWallArray.length();
	for (int i=0;i<len;i++) {
		AcDbObjectId id=m_idWallArray[i];
		if (id) m_WallCount+=1;
	}
	if (m_WallCount<3) {
		GetDlgItem(IDC_CHECK_M)->EnableWindow(FALSE);
		if (m_WallCount<2) {
			GetDlgItem(IDC_RADIO_A)->EnableWindow(FALSE);
			GetDlgItem(IDC_RADIO_C)->EnableWindow(FALSE);
		}
	}

    double widthList[]={180,200,240,250,300,360,370};
	int num=ELEMENTS(widthList);
	double maxAC=m_ptRef1.Distance(m_ptRef2),maxBD=m_ptRef1.Distance(m_ptRef4);
    for(i=0;i<num;i++) {
        CString csItem;
        csItem.Format(_T("%d"), AS_INT(widthList[i]));
		if ((widthList[i]-maxBD)<1E-3) m_AC.AddString(csItem);
		if ((widthList[i]-maxAC)<1E-3) m_BD.AddString(csItem);
    }

	if (fabs(maxBD-200)<_DIST_SNAP) m_csAC=_T("200");
	else if ((240.0-maxBD)>1E-3) m_csAC=_T("180"); 
	else m_csAC=_T("240");
	if (fabs(maxAC-200)<_DIST_SNAP) m_csBD=_T("200");
	else if ((240.0-maxAC)>1E-3) m_csBD=_T("180"); 
	else m_csBD=_T("240");
	if (GetDlgItem(IDC_RADIO_A)->IsWindowEnabled()) m_iA=0; else m_iD=0;
	if (GetDlgItem(IDC_CHECK_M)->IsWindowEnabled()) m_bM=TRUE; else m_iD=0;
	UpdateData(FALSE);

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CFortifyColumnDlg::OnRadioAC()
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if ((m_bM)&&(m_iD!=-1)) m_iD=-1;
	UpdateData(FALSE);

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();
}

void CFortifyColumnDlg::OnRadioBD()
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if ((m_bM)&&(m_iA!=-1)) m_iA=-1;
	UpdateData(FALSE);

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();
}

void CFortifyColumnDlg::OnCheckM()
{
	// TODO: Add your control notification handler code here
	UpdateData(TRUE);
	if ((m_bM)&&(m_iA!=-1)&&(m_iD!=-1)) m_iD=-1;
	if (!m_bM) {
		if (m_iA==-1) m_iA=0;
		if (m_iD==-1) m_iD=0;
	}
	UpdateData(FALSE);

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();
}

void CFortifyColumnDlg::OnOK()
{
	CDialog::OnOK();

	// TODO: Add extra validation here
	XPoint ptLoc;
	Midpoint(m_ptRef1,m_ptRef3,ptLoc);

	TDbColumn *column=new TDbColumn;
    column->SetLocation(ptLoc);
	column->SetMaterial(TColumnData::kConcrete);
	column->SetHeight(CFG_LHeight);
	column->SetOutlinePoly(m_ColumnPoly);
	column->SetSectionShape(TColumnData::kPoly);
	column->SetFortifyColumn(TRUE);
	column->SetLayerHatch2d(InitLayer(LAY_HATCH, FALSE));
	column->AddToMSpace(TRUE);

}

void CFortifyColumnDlg::OnKillfocusComboAc()
{
	// TODO: Add your control notification handler code here
	CString s=m_csAC;
	UpdateData(TRUE);
	if ((_tstof(m_csAC)-m_ptRef1.Distance(m_ptRef4))>1E-3) {
		ads_alert(_T("柱子不能超出墙体(A-C)"));
		m_AC.SelectString(-1,s);
	}
	if (m_csAC.IsEmpty()) {
		ads_alert(_T("未选定尺寸(A-C)"));
		m_AC.SelectString(-1,s);
	}
	else if (_tstof(m_csAC)<=0) {
		ads_alert(_T("尺寸不能为零或负值(A-C)"));
		m_AC.SelectString(-1,s);
	}

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();
}

void CFortifyColumnDlg::OnKillfocusComboBd()
{
	// TODO: Add your control notification handler code here
	CString s=m_csBD;
	UpdateData(TRUE);
	if ((_tstof(m_csBD)-m_ptRef1.Distance(m_ptRef2))>1E-3) {
		ads_alert(_T("柱子不能超出墙体(B-D)"));
		m_BD.SelectString(-1,s);
	}
	if (m_csBD.IsEmpty()) {
		ads_alert(_T("未选定尺寸(B-D)"));
		m_BD.SelectString(-1,s);
	}
	else if (_tstof(m_csBD)<=0) {
		ads_alert(_T("尺寸不能为零或负值(B-D)"));
		m_BD.SelectString(-1,s);
	}

	GetColumnPoly();
	HighlightWallColumn();
    UpdateImage();
}

void CFortifyColumnDlg::OnPaint()
{
	CPaintDC dc(this); // device context for painting
	
	// TODO: Add your message handler code here
	CWnd* pImage=GetDlgItem(IDC_IMAGE);
	if (!pImage) return;
	CRect rect;
	pImage->GetClientRect(rect);
	CDC* pDC=pImage->GetDC();
	if (!pDC) return;
	CRgn rgn;
	rgn.CreateRectRgnIndirect(rect);
	pDC->SelectClipRgn(&rgn);
	pImage->Invalidate();
	pImage->UpdateWindow();
	CBrush brush(GetAcadBackColor());
	pDC->FillRect(rect,&brush);

	XPoly2D poly(1);
	poly.InsertNodeAt(0,m_ptRef1);
	poly.InsertNodeAt(1,m_ptRef2);
	poly.InsertNodeAt(2,m_ptRef3);
	poly.InsertNodeAt(3,m_ptRef4);
	XPoint ptLow,ptUp,ptZero;
	poly.GetExtend(ptLow,ptUp);
	ptLow.x-=100; ptLow.y-=100; ptUp.x+=100; ptUp.y+=100;

	ptZero=ptLow; ptZero.y=ptUp.y;
	double nMaxX, nMaxY, nMaxXScl, nMaxYScl;
	nMaxX=ptZero.Distance(ptUp); nMaxY=ptZero.Distance(ptLow);
	nMaxXScl=rect.Width()/nMaxX; nMaxYScl=rect.Height()/nMaxY;
	double Scale=nMaxXScl>nMaxYScl?nMaxYScl:nMaxXScl;
	if (nMaxXScl>nMaxYScl) ptZero.x-=(rect.Width()-nMaxX*Scale)/2/Scale;
	else ptZero.y+=(rect.Height()-nMaxY*Scale)/2/Scale;

	COLORREF c;
	int len=m_idWallArray.length();
	ASSERT(len>0);
	if (m_WallCount>1)
		for (int i=0;i<len;i++) {
			if (i==0) c=acdbGetRGB(1);
			else if (i==1) c=acdbGetRGB(2);
			else if (i==2) c=acdbGetRGB(3);
			else if (i==3) c=acdbGetRGB(4);

		    XDbObject objWall(m_idWallArray[i], AcDb::kForRead);
		    if (!objWall) continue;
		    TDbWall* pWall=TDbWall::cast(objWall.m_pObject);
		    if (!pWall) continue;
			XCurveSegment lCurve,rCurve;
			pWall->GetSideCurve(lCurve,rCurve);
			XPoint pt1,pt2;
			CPoint p1,p2;
			pt1=lCurve.StartPoint(); pt2=lCurve.EndPoint();
			p1=ConvertPoint(ptZero,pt1,Scale); p2=ConvertPoint(ptZero,pt2,Scale);
			DrawLine(pDC,p1,p2,1,c);
			pt1=rCurve.StartPoint(); pt2=rCurve.EndPoint();
			p1=ConvertPoint(ptZero,pt1,Scale); p2=ConvertPoint(ptZero,pt2,Scale);
			DrawLine(pDC,p1,p2,1,c);
		}
	else {// single wall case
		XDbObject objWall(m_idWallArray[0], AcDb::kForRead);
		if (!objWall) return;
		TDbWall* pWall=TDbWall::cast(objWall.m_pObject);
		if (!pWall) return;
		XCurveSegment lCurve,rCurve;
		pWall->GetSideCurve(lCurve,rCurve);
		XPoint pt1,pt2,pt3,pt4,pt14,pt23;
		if (IsPoint2dEqual(lCurve.StartPoint(),lCurve.NearPoint(m_ptRef1))) {
			pt1=lCurve.StartPoint(); pt2=rCurve.StartPoint();
			pt3=rCurve.EndPoint(); pt4=lCurve.EndPoint();
		}
		else {
			pt1=lCurve.EndPoint(); pt2=rCurve.EndPoint();
			pt3=rCurve.StartPoint(); pt4=lCurve.StartPoint();
		}
		Midpoint(m_ptRef1,m_ptRef4,pt14);
		Midpoint(m_ptRef2,m_ptRef3,pt23);
		CPoint p1,p2,p3,p4,p14,p23;
		p1=ConvertPoint(ptZero,pt1,Scale); p2=ConvertPoint(ptZero,pt2,Scale);
		p3=ConvertPoint(ptZero,pt3,Scale); p4=ConvertPoint(ptZero,pt4,Scale);
		p14=ConvertPoint(ptZero,pt14,Scale); p23=ConvertPoint(ptZero,pt23,Scale);
		c=acdbGetRGB(1); DrawLine(pDC,p1,p14,1,c); DrawLine(pDC,p2,p23,1,c);
		c=acdbGetRGB(3); DrawLine(pDC,p3,p23,1,c); DrawLine(pDC,p4,p14,1,c);
	}

	CString szText;
	XPoint ptMid,ptTxt;
	CPoint pTxt;
	XVector3D v1=m_ptRef1-m_ptRef2,v2=m_ptRef1-m_ptRef4;
	((AcGeVector3d &)v1).normalize();
	((AcGeVector3d &)v2).normalize();
	pDC->SetBkMode(TRANSPARENT);
	pDC->SetTextAlign(TA_CENTER|TA_BASELINE);

	Midpoint(m_ptRef1,m_ptRef2,ptMid);
	ptTxt.x=ptMid.x+v2.x*60; ptTxt.y=ptMid.y+v2.y*60;
	pTxt=ConvertPoint(ptZero,ptTxt,Scale);
	szText.Format(_T("%c"), _T('a'));
	CalTextLocate(pDC, pTxt, rect, szText);
	pDC->SetTextColor(acdbGetRGB(1));
	pDC->TextOut(pTxt.x, pTxt.y, szText);

	Midpoint(m_ptRef2,m_ptRef3,ptMid);
	ptTxt.x=ptMid.x-v1.x*60; ptTxt.y=ptMid.y-v1.y*60;
	pTxt=ConvertPoint(ptZero,ptTxt,Scale);
	szText.Format(_T("%c"), _T('b'));
	CalTextLocate(pDC, pTxt, rect, szText);
	pDC->SetTextColor(acdbGetRGB(2));
	pDC->TextOut(pTxt.x, pTxt.y, szText);

	Midpoint(m_ptRef3,m_ptRef4,ptMid);
	ptTxt.x=ptMid.x-v2.x*60; ptTxt.y=ptMid.y-v2.y*60;
	pTxt=ConvertPoint(ptZero,ptTxt,Scale);
	szText.Format(_T("%c"), _T('c'));
	CalTextLocate(pDC, pTxt, rect, szText);
	pDC->SetTextColor(acdbGetRGB(3));
	pDC->TextOut(pTxt.x, pTxt.y, szText);

	Midpoint(m_ptRef4,m_ptRef1,ptMid);
	ptTxt.x=ptMid.x+v1.x*60; ptTxt.y=ptMid.y+v1.y*60;
	pTxt=ConvertPoint(ptZero,ptTxt,Scale);
	szText.Format(_T("%c"), _T('d'));
	CalTextLocate(pDC, pTxt, rect, szText);
	pDC->SetTextColor(acdbGetRGB(4));
	pDC->TextOut(pTxt.x, pTxt.y, szText);

	XPointList ptList=GetColumnPoint();
	XPoint pt1=*ptList[0],pt2=*ptList[1],pt4=*ptList[3];
	XVector3D v=pt4-pt1;
	((AcGeVector3d &)v).normalize();
	len=AS_INT(pt1.Distance(pt4));
	for (int i=0;i<len;i++) {
		XPoint q1,q2;
		q1.x=pt1.x+v.x*i; q1.y=pt1.y+v.y*i;
		q2.x=pt2.x+v.x*i; q2.y=pt2.y+v.y*i;
		CPoint p1=ConvertPoint(ptZero,q1,Scale),p2=ConvertPoint(ptZero,q2,Scale);
		DrawLine(pDC,p1,p2,1,acdbGetRGB(7));
	}

	pImage->ReleaseDC(pDC);
	// Do not call CDialog::OnPaint() for painting messages
}

BOOL CFortifyColumnDlg::IsFullSize() {
	if ((fabs(m_ptRef1.Distance(m_ptRef2)-_tstof(m_csBD))<1E-3)&&(fabs(m_ptRef1.Distance(m_ptRef4)-_tstof(m_csAC))<1E-3))
		return TRUE;
	else
		return FALSE;
}

XPointList CFortifyColumnDlg::GetColumnPoint() {
	XPoint p1,p2,p3,p4;

	if (IsFullSize()) {// column points are the same as ref. points
		p1=m_ptRef1; p2=m_ptRef2; p3=m_ptRef3; p4=m_ptRef4;
	}
	else {// get 4 column points according to sizes and options
		double dAC=m_ptRef1.Distance(m_ptRef4),dBD=m_ptRef1.Distance(m_ptRef2);// wall distance
		double s12=_tstof(m_csBD),s14=_tstof(m_csAC);// column size
		double o12=(dBD-_tstof(m_csBD))/2,o14=(dAC-_tstof(m_csAC))/2;// position offset
		XVector3D v12=m_ptRef1-m_ptRef2,v14=m_ptRef1-m_ptRef4;
		((AcGeVector3d &)v12).normalize();
		((AcGeVector3d &)v14).normalize();

		if (!m_bM) {
			if (m_iA==0) {
				if (m_iD==0) {//A+D
					p1=m_ptRef1;
					p2.x=p1.x-v12.x*s12; p2.y=p1.y-v12.y*s12;
					p4.x=p1.x-v14.x*s14; p4.y=p1.y-v14.y*s14;
					p3.x=p4.x-v12.x*s12; p3.y=p4.y-v12.y*s12;
				}
				else {//A+B
					p2=m_ptRef2;
					p1.x=p2.x+v12.x*s12; p1.y=p2.y+v12.y*s12;
					p3.x=p2.x-v14.x*s14; p3.y=p2.y-v14.y*s14;
					p4.x=p3.x+v12.x*s12; p4.y=p3.y+v12.y*s12;
				}
			}
			else if (m_iA==1) {
				if (m_iD==0) {//C+D
					p4=m_ptRef4;
					p3.x=p4.x-v12.x*s12; p3.y=p4.y-v12.y*s12;
					p1.x=p4.x+v14.x*s14; p1.y=p4.y+v14.y*s14;
					p2.x=p1.x-v12.x*s12; p2.y=p1.y-v12.y*s12;
				}
				else {//C+B
					p3=m_ptRef3;
					p4.x=p3.x+v12.x*s12; p4.y=p3.y+v12.y*s12;
					p2.x=p3.x+v14.x*s14; p2.y=p3.y+v14.y*s14;
					p1.x=p2.x+v12.x*s12; p1.y=p2.y+v12.y*s12;
				}
			}
			else {// single wall case
				if (m_iD==0) {//D
					p1.x=m_ptRef1.x-v14.x*o14; p1.y=m_ptRef1.y-v14.y*o14;
					p4.x=m_ptRef4.x+v14.x*o14; p4.y=m_ptRef4.y+v14.y*o14;
					p2.x=p1.x-v12.x*s12; p2.y=p1.y-v12.y*s12;
					p3.x=p4.x-v12.x*s12; p3.y=p4.y-v12.y*s12;
				}
				else {//B
					p2.x=m_ptRef2.x-v14.x*o14; p2.y=m_ptRef2.y-v14.y*o14;
					p3.x=m_ptRef3.x+v14.x*o14; p3.y=m_ptRef3.y+v14.y*o14;
					p1.x=p2.x+v12.x*s12; p1.y=p2.y+v12.y*s12;
					p4.x=p3.x+v12.x*s12; p4.y=p3.y+v12.y*s12;
				}
			}
		}
		else if (m_iA!=-1) {
			if (m_iA==0) {//M+A
				p1.x=m_ptRef1.x-v12.x*o12; p1.y=m_ptRef1.y-v12.y*o12;
				p2.x=m_ptRef2.x+v12.x*o12; p2.y=m_ptRef2.y+v12.y*o12;
				p4.x=p1.x-v14.x*s14; p4.y=p1.y-v14.y*s14;
				p3.x=p2.x-v14.x*s14; p3.y=p2.y-v14.y*s14;
			}
			else {//M+C
				p4.x=m_ptRef4.x-v12.x*o12; p4.y=m_ptRef4.y-v12.y*o12;
				p3.x=m_ptRef3.x+v12.x*o12; p3.y=m_ptRef3.y+v12.y*o12;
				p1.x=p4.x+v14.x*s14; p1.y=p4.y+v14.y*s14;
				p2.x=p3.x+v14.x*s14; p2.y=p3.y+v14.y*s14;
			}
		}
		else {
			if (m_iD==0) {//M+D
				p1.x=m_ptRef1.x-v14.x*o14; p1.y=m_ptRef1.y-v14.y*o14;
				p4.x=m_ptRef4.x+v14.x*o14; p4.y=m_ptRef4.y+v14.y*o14;
				p2.x=p1.x-v12.x*s12; p2.y=p1.y-v12.y*s12;
				p3.x=p4.x-v12.x*s12; p3.y=p4.y-v12.y*s12;
			}
			else {//M+B
				p2.x=m_ptRef2.x-v14.x*o14; p2.y=m_ptRef2.y-v14.y*o14;
				p3.x=m_ptRef3.x+v14.x*o14; p3.y=m_ptRef3.y+v14.y*o14;
				p1.x=p2.x+v12.x*s12; p1.y=p2.y+v12.y*s12;
				p4.x=p3.x+v12.x*s12; p4.y=p3.y+v12.y*s12;
			}
		}
	}

	XPointList ptList;
	ptList.NewAppend(p1);
	ptList.NewAppend(p2);
	ptList.NewAppend(p3);
	ptList.NewAppend(p4);
	return ptList;
}

void CFortifyColumnDlg::GetColumnPoly() {
	XPointList ptList;
	ptList=GetColumnPoint();
	m_ColumnPoly.Reset();
	ptList.AsPoly2D(m_ColumnPoly);
}

void CFortifyColumnDlg::HighlightWallColumn() {
	ads_redraw(NULL, 0);

	XScreenDc dc;
	dc.SetColor(7);
	XVector3D v=m_ptRef1-m_ptRef4;
	((AcGeVector3d &)v).normalize();
	XPointList ptList;
	ptList=GetColumnPoint();
	XPoint p1=*ptList[0],p2=*ptList[1];
	int len=AS_INT(_tstof(m_csAC));
	for (int i=0;i<len;i++) {
		XPoint q1,q2;
		q1.x=p1.x-v.x*i; q1.y=p1.y-v.y*i;
		q2.x=p2.x-v.x*i; q2.y=p2.y-v.y*i;
		XLine l(Wcs2Ucs(q1),Wcs2Ucs(q2)); dc << l;
	}

	len=m_idWallArray.length();
	ASSERT(len>0);
	if (m_WallCount>1)
		for (int i=0;i<len;i++) {
			if (i==0) dc.SetColor(1);
			else if (i==1) dc.SetColor(2);
			else if (i==2) dc.SetColor(3);
			else if (i==3) dc.SetColor(4);

		    XDbObject objWall(m_idWallArray[i], AcDb::kForRead);
		    if (!objWall) continue;
		    TDbWall* pWall=TDbWall::cast(objWall.m_pObject);
		    if (!pWall) continue;
			XCurveSegment lCurve,rCurve;
			pWall->GetSideCurve(lCurve,rCurve);
			XPoint p1,p2;
			double b;
			p1=Wcs2Ucs(lCurve.StartPoint()); p2=Wcs2Ucs(lCurve.EndPoint()); b=lCurve.GetBulge();
			dc << XCurveSegment(p1,p2,b);
			p1=Wcs2Ucs(rCurve.StartPoint()); p2=Wcs2Ucs(rCurve.EndPoint()); b=rCurve.GetBulge();
			dc << XCurveSegment(p1,p2,b);
		}
	else {// single wall case
		XDbObject objWall(m_idWallArray[0], AcDb::kForRead);
		if (!objWall) return;
		TDbWall* pWall=TDbWall::cast(objWall.m_pObject);
		if (!pWall) return;
		XCurveSegment lCurve,rCurve;
		pWall->GetSideCurve(lCurve,rCurve);

		XPoint p1,p2,p3,p4,p14,p23;
		if (IsPoint2dEqual(lCurve.StartPoint(),lCurve.NearPoint(m_ptRef1))) {
			p1=Wcs2Ucs(lCurve.StartPoint()); p2=Wcs2Ucs(rCurve.StartPoint());
			p3=Wcs2Ucs(rCurve.EndPoint()); p4=Wcs2Ucs(lCurve.EndPoint());
		}
		else {
			p1=Wcs2Ucs(lCurve.EndPoint()); p2=Wcs2Ucs(rCurve.EndPoint());
			p3=Wcs2Ucs(rCurve.StartPoint()); p4=Wcs2Ucs(lCurve.StartPoint());
		}
		double b1=lCurve.GetBulge(),b2=rCurve.GetBulge();
		Midpoint(m_ptRef1,m_ptRef4,p14);
		Midpoint(m_ptRef2,m_ptRef3,p23);
		dc.SetColor(1);
		dc << XCurveSegment(p1,Wcs2Ucs(p14),b1);
		dc << XCurveSegment(p2,Wcs2Ucs(p23),b2);
		dc.SetColor(3);
		dc << XCurveSegment(p3,Wcs2Ucs(p23),b2);
		dc << XCurveSegment(p4,Wcs2Ucs(p14),b1);
	}

	acedUpdateDisplay();
}

void CFortifyColumnDlg::UpdateImage() {
	CRect rect;
	CWnd* pImage=GetDlgItem(IDC_IMAGE);
	if (pImage) {
		pImage->GetWindowRect(rect);
		ScreenToClient(rect);
		InvalidateRect(rect);
	}
}

CPoint CFortifyColumnDlg::ConvertPoint(XPoint ptZero, XPoint pt, double Scale)
{
    CPoint p;
    p.x=ROUND((pt.x-ptZero.x)*Scale);
    p.y=ROUND((ptZero.y-pt.y)*Scale);
    return p;
}

void CFortifyColumnDlg::CalTextLocate(CDC* pDC, CPoint& pTxt, CRect rect, CString szText)
{
    CFont* pFont=GetFont();
    CFont* pOldFont=pDC->SelectObject(pFont);
    CSize size=pDC->GetTextExtent(szText);
    pDC->SelectObject(pOldFont);

    if (pTxt.x<0) pTxt.x=0;
    if (pTxt.y<0) pTxt.y=0;
    if (pTxt.x+size.cx>rect.right) pTxt.x=rect.right-size.cx;
    if (pTxt.y+size.cy>rect.bottom) pTxt.y=rect.bottom-size.cy;
}

void CFortifyColumnDlg::DrawLine(CDC* pDC, CPoint pt1, CPoint pt2, int nWidth, COLORREF clr)
{
	CPen pen(PS_SOLID, nWidth, clr);
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(pt1);
	pDC->LineTo(pt2);
	pDC->SelectObject(pOldPen);
}