#include "StdAfx.h"
#include "WallPartDlg.h"

BOOL CWallPartDlg::m_bChkLeft = 1;			
BOOL CWallPartDlg::m_bChkRight = 1;			
BOOL CWallPartDlg::m_bChkHeight = 1;		
BOOL CWallPartDlg::m_bChkElev = 0;			
BOOL CWallPartDlg::m_bChkMaterial = 1;		
BOOL CWallPartDlg::m_bChkUsing = 0;			
BOOL CWallPartDlg::m_bChkLeftKeep = 0;		
BOOL CWallPartDlg::m_bChkRightKeep = 0;	
BOOL CWallPartDlg::m_bgroupStatus = FALSE;
BOOL CWallPartDlg::m_bChkTwoSide = 0;
CString CWallPartDlg::m_strHeight = _T("当前层高");
CString CWallPartDlg::m_strElev = _T("0");		
int CWallPartDlg::m_iMaterial = 2;	
int CWallPartDlg::m_iUsing = 1;		
int CWallPartDlg::m_iLeftKeep = 80;	
int CWallPartDlg::m_iRigntKeep = 80;	
int CWallPartDlg::m_iLeft = 120;				
int CWallPartDlg::m_iRight = 120;			

IMPLEMENT_DYNAMIC(CWallPartDlg, WGroupDlg)
CWallPartDlg::CWallPartDlg(CWnd* pParent)
: WGroupDlg(CWallPartDlg::IDD, pParent)
{
}

CWallPartDlg::~CWallPartDlg()
{
}

BEGIN_MESSAGE_MAP(CWallPartDlg, WGroupDlg)
ON_BN_CLICKED(IDC_CHK_LEFTWIDTH, OnBlkLeftWidth)
ON_BN_CLICKED(IDC_CHK_RIGHTWIDTH, OnBlkRightWidth)
ON_BN_CLICKED(IDC_CHK_USING, OnBlkUsing)
ON_BN_CLICKED(IDC_CHK_MATERIAL, OnBlkMaterial)
ON_BN_CLICKED(IDC_CHK_ELEV, OnBlkElevation)
ON_BN_CLICKED(IDC_CHK_HEIGHT, OnBlkHeight)
ON_BN_CLICKED(IDC_CHK_LEFTKEEP, OnBlkLeftKeep)
ON_BN_CLICKED(IDC_CHK_RIGHTKEEP, OnBlkRightKeep)
ON_WM_CTLCOLOR()
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_LEFTWIDTH, OnDeltaposSpinLeftwidth)
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_RIGHTWIDTH, OnDeltaposSpinRightwidth)
END_MESSAGE_MAP()

BOOL CWallPartDlg::OnInitDialog()
{
	WGroupDlg::OnInitDialog();
	
	m_spinLeft.SetBuddy(&m_edtLeft);
	m_spinRight.SetBuddy(&m_edtRight);
	m_spinLeft.SetRange(0, UD_MAXVAL);
	m_spinRight.SetRange(0, UD_MAXVAL);
	

	CComboBox *pBox = (CComboBox*)GetDlgItem(IDC_CMB_PARTMATERIAL);
	pBox->ResetContent();
	pBox->AddString(WALLMATE_Concrete);
	pBox->AddString(WALLMATE_Concrete1);
	pBox->AddString(WALLMATE_Brick);
	pBox->AddString(WALLMATE_Brick1);
	pBox->AddString(WALLMATE_Rocket);
	pBox->AddString(WALLMATE_Rocket1);
	pBox->AddString(WALLMATE_Fill);
	pBox->AddString(WALLMATE_Fill1);
	pBox->AddString(WALLMATE_Fill2);
	pBox->AddString(WALLMATE_Divider);
	pBox->AddString(WALLMATE_Curtain);

	pBox->SetCurSel(m_iMaterial);

	GetDlgItem(IDC_CHK_WALLTOP)->EnableWindow(FALSE);
	OnBlkLeftWidth();
	OnBlkRightWidth();
	OnBlkHeight();
	OnBlkElevation();
	OnBlkMaterial();
	OnBlkUsing();
	OnBlkLeftKeep();
	OnBlkRightKeep();

	CComboBox *pBox1 = (CComboBox*)GetDlgItem(IDC_CMB_USING);
	pBox1->ResetContent();
	pBox1->AddString(_T("外墙"));
	pBox1->AddString(_T("内墙"));
	pBox1->AddString(_T("分户墙"));
	pBox1->AddString(_T("虚墙"));
	pBox1->AddString(_T("矮墙"));
	pBox1->AddString(_T("卫生隔断"));

	pBox1->SetCurSel(m_iUsing);
	return TRUE;
}

void CWallPartDlg::DoDataExchange(CDataExchange* pDX)
{
	WGroupDlg::DoDataExchange(pDX);
	DDX_Check(pDX, IDC_CHK_LEFTWIDTH, m_bChkLeft);
	DDX_Check(pDX, IDC_CHK_RIGHTWIDTH, m_bChkRight);
	DDX_Check(pDX, IDC_CHK_HEIGHT, m_bChkHeight);
	DDX_Check(pDX, IDC_CHK_MATERIAL, m_bChkMaterial);
	DDX_Check(pDX, IDC_CHK_ELEV, m_bChkElev);
	DDX_Check(pDX, IDC_CHK_USING, m_bChkUsing);
	DDX_Check(pDX, IDC_CHK_LEFTKEEP, m_bChkLeftKeep);
	DDX_Check(pDX, IDC_CHK_RIGHTKEEP, m_bChkRightKeep);
	DDX_Check(pDX, IDC_CHK_WALLTOP, m_bChkTwoSide);
	DDX_Text(pDX, IDC_EDT_LEFTWIDTH, m_iLeft);
	DDX_Text(pDX, IDC_EDT_RIGHTWIDTH, m_iRight);
	DDX_Text(pDX, IDC_CMB_PARTHEIGHT, m_strHeight);
	DDX_Text(pDX, IDC_CMB_PARTELEV, m_strElev);
	DDX_Text(pDX, IDC_CMB_PARTHEIGHT, m_strHeight);
	DDX_CBIndex(pDX, IDC_CMB_USING, m_iUsing);
	DDX_CBIndex(pDX, IDC_CMB_PARTMATERIAL, m_iMaterial);
	DDX_Text(pDX, IDC_EDT_LEFTKEEP, m_iLeftKeep);
	DDX_Text(pDX, IDC_EDT_RIGHTKEEP, m_iRigntKeep);
	DDX_Control(pDX, IDC_SPIN_LEFTWIDTH, m_spinLeft);
	DDX_Control(pDX, IDC_SPIN_RIGHTWIDTH, m_spinRight);
	DDX_Control(pDX, IDC_EDT_LEFTWIDTH, m_edtLeft);
	DDX_Control(pDX, IDC_EDT_RIGHTWIDTH, m_edtRight);
	DDV_MinMaxInt(pDX, m_iLeft, 0, INT_MAX);
	DDV_MinMaxInt(pDX, m_iRight, 0, INT_MAX);
	DDX_Control(pDX, IDC_STATIC_GROUP, m_group);
	DDX_GroupStatus(pDX,IDC_STATIC_GROUP,m_bgroupStatus);
}

void CWallPartDlg::OnBlkLeftWidth()
{
	UpdateData(TRUE);
	if (!m_bChkLeft)
	{
		GetDlgItem(IDC_EDT_LEFTWIDTH)->EnableWindow(FALSE);
		GetDlgItem(IDC_SPIN_LEFTWIDTH)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_EDT_LEFTWIDTH)->EnableWindow(TRUE);
		GetDlgItem(IDC_SPIN_LEFTWIDTH)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkRightWidth()
{
	UpdateData(TRUE);
	if (!m_bChkRight)
	{
		GetDlgItem(IDC_EDT_RIGHTWIDTH)->EnableWindow(FALSE);
		GetDlgItem(IDC_SPIN_RIGHTWIDTH)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_EDT_RIGHTWIDTH)->EnableWindow(TRUE);
		GetDlgItem(IDC_SPIN_RIGHTWIDTH)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkHeight()
{
	UpdateData(TRUE);
	if (!m_bChkHeight)
	{
		GetDlgItem(IDC_CMB_PARTHEIGHT)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_CMB_PARTHEIGHT)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkElevation()
{
	UpdateData(TRUE);
	if (!m_bChkElev)
	{
		GetDlgItem(IDC_CMB_PARTELEV)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_CMB_PARTELEV)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkMaterial()
{
	UpdateData(TRUE);
	if (!m_bChkMaterial)
	{
		GetDlgItem(IDC_CMB_PARTMATERIAL)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_CMB_PARTMATERIAL)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkUsing()
{
	UpdateData(TRUE);
	if (!m_bChkUsing)
	{
		GetDlgItem(IDC_CMB_USING)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_CMB_USING)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkLeftKeep()
{
	UpdateData(TRUE);
	if (m_bChkRightKeep || m_bChkLeftKeep)
	{
		GetDlgItem(IDC_CHK_WALLTOP)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_CHK_WALLTOP)->EnableWindow(FALSE);
	}

	if (!m_bChkLeftKeep)
	{
		GetDlgItem(IDC_EDT_LEFTKEEP)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_EDT_LEFTKEEP)->EnableWindow(TRUE);
	}
}

void CWallPartDlg::OnBlkRightKeep()
{
	UpdateData(TRUE);

	if (m_bChkRightKeep || m_bChkLeftKeep)
	{
		GetDlgItem(IDC_CHK_WALLTOP)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_CHK_WALLTOP)->EnableWindow(FALSE);
	}

	if (!m_bChkRightKeep)
	{
		GetDlgItem(IDC_EDT_RIGHTKEEP)->EnableWindow(FALSE);
	}
	else
	{
		GetDlgItem(IDC_EDT_RIGHTKEEP)->EnableWindow(TRUE);
	}
}

HBRUSH  CWallPartDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = WGroupDlg::OnCtlColor(pDC, pWnd, nCtlColor);
	if (pWnd->GetDlgCtrlID() == IDC_STATIC_PARTLEFTWIDTH)
	{
		pDC->SetTextColor(RGB(0,255,0)); //设置字体颜色
		pDC->SetBkMode(TRANSPARENT);     //设置背景透明

	}
	else if (pWnd->GetDlgCtrlID() == IDC_STATIC_PARTRIGHTWIDTH)
	{
		pDC->SetTextColor(RGB(255, 0, 255)); //设置字体颜色
		pDC->SetBkMode(TRANSPARENT);     //设置背景透明
	}
	return hbr;
}

void CWallPartDlg::OnDeltaposSpinLeftwidth(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
	UpdateData(TRUE);
	if (pNMUpDown->iDelta == 1)
	{
		m_iLeft += 10;
	}
	else if (pNMUpDown->iDelta == -1)
	{
		m_iLeft -= 10;
	}
	UpdateData(FALSE);
	*pResult = 0;	
}

void CWallPartDlg::OnDeltaposSpinRightwidth(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMUPDOWN pNMUpDown = reinterpret_cast<LPNMUPDOWN>(pNMHDR);
	UpdateData(TRUE);
	if (pNMUpDown->iDelta == 1)
	{
		m_iRight += 10;
	}
	else if (pNMUpDown->iDelta == -1)
	{
		m_iRight -= 10;
	}
	UpdateData(FALSE);
	*pResult = 0;	
}

double CWallPartDlg::GetLeftWidth()
{
	UpdateData(TRUE);
	if (!m_bChkLeft)
	{
		return m_pWall->GetWidth(0);
	}
	return m_iLeft;
}

double CWallPartDlg::GetRightWidth()
{
	UpdateData(TRUE);
	if (!m_bChkRight)
	{
		return m_pWall->GetWidth(1);
	}
	return m_iRight;
}

double CWallPartDlg::GetHeight()
{
	UpdateData(TRUE);
	if (!m_bChkHeight)
	{
		return m_pWall->GetHeight();
	}

	if (m_strHeight == _T("当前层高"))
	{
		return DocGetLHeight();
	}
	return _tstof(m_strHeight);
}

double CWallPartDlg::GetElevation()
{
	UpdateData(TRUE);
	if (!m_bChkElev)
	{
		//m_pWall->GetElevation();
		return m_pWall->GetElevation();
	}
	return _tstof(m_strElev);
}

TWallData::TWallStyle CWallPartDlg::GetMaterialStyle(CString &sT20Mat)
{
	UpdateData(TRUE);
	TWallData::TWallStyle st = TWallData::kBrick; // 砖墙
	st = TWallData::kBrick;
	if (!m_bChkMaterial)
	{
		st = m_pWall->GetStyle();
		return st;
	}
	switch(m_iMaterial)
	{
	case 0: 
		sT20Mat = WALLMATE_Concrete;
		st = TWallData::kConcrete;
		break;
	case 1: 
		sT20Mat = WALLMATE_Concrete1;
		st = TWallData::kConcrete;
		break;
	case 2:
		sT20Mat = WALLMATE_Brick;
		st = TWallData::kBrick;
		break;
	case 3: 
		sT20Mat = WALLMATE_Brick1;
		st = TWallData::kBrick;
		break;
	case 4: 
		sT20Mat = WALLMATE_Rocket;
		st = TWallData::kRocket;
		break;
	case 5: 
		sT20Mat = WALLMATE_Rocket1;
		st = TWallData::kRocket;
		break;
	case 6: 
		sT20Mat = WALLMATE_Fill;
		st = TWallData::kFill;
		break;
	case 7: 
		sT20Mat = WALLMATE_Fill1;
		st = TWallData::kFill1;
		break;
	case 8: 
		sT20Mat = WALLMATE_Fill2;
		st = TWallData::kFill2;
		break;
	case 9: 
		sT20Mat = WALLMATE_Divider;
		st = TWallData::kDivider;
		break;
	case 10: 
		sT20Mat = WALLMATE_Curtain;
		st = TWallData::kCurtain;
		break;	}
	return st;
}

TWallData::UsageFlag CWallPartDlg::GetUsage()
{
	UpdateData(TRUE);
	TWallData::UsageFlag us=TWallData::kNormal;
	if (!m_bChkUsing)
	{
		us = m_pWall->GetUsageFlag();
		return us;
	}
	switch(m_iUsing)
	{
	case 0: 
		{
			us=TWallData::kNormal;
			break;
		}
	case 1: 
		{
			us=TWallData::kApartment;
			break;
		}
	case 2: 
		{
			us=TWallData::kVirtual;
			break;
		}
	case 3: 
		{
			us=TWallData::kParapet;
			break;
		}
	}
	return us;
}

int CWallPartDlg::GetLeftKeep()
{
	UpdateData(TRUE);
	return m_iLeftKeep;
}

int CWallPartDlg::GetRightKeep()
{
	UpdateData(TRUE);
	return m_iRigntKeep;
}

BOOL CWallPartDlg::GetIsLeft()
{
	UpdateData(TRUE);
	return m_bChkLeftKeep;
}

BOOL CWallPartDlg::GetIsRight()
{
	UpdateData(TRUE);
	return m_bChkRightKeep;
}

BOOL CWallPartDlg::GetIsTwoSide()
{
	UpdateData(TRUE);
	return m_bChkTwoSide;
}

void CWallPartDlg::SetWallPoint(TDbWall *pWall)
{
	m_pWall = pWall;
}

AcDbObjectId Curtain2Wall(Entity entWall, CString csLayer = _T(""));
AcDbObjectId Curtain2Wall(Entity entWall, CString csLayer)
{
	XDbObject obj(entWall, AcDb::kForWrite);
	if (!obj)
	{
		return AcDbObjectId::kNull;
	}

	TDbCurtainWall *pWall = TDbCurtainWall::cast(obj.m_pObject);
	
	if (pWall == NULL)
	{
		return AcDbObjectId::kNull;
	}

	AcDbObjectId idSurf = pWall->GetLayerSurf2d();
	if (!idSurf.isValid())
		pWall->SetLayerSurf2d(InitLayer(LAY_SURFACE));

	AcDbCurve *pCv = pWall->GetAcDbCurve(0);
	if (pCv ==	NULL)
	{
		return AcDbObjectId::kNull;
	}

	TDbWall *pCWall = (TDbWall*)TDbWall::desc()->create();

	if (pCWall == NULL)
	{
		return AcDbObjectId::kNull;
	}

	pCWall->SetFromCurve((*pCv));
	pCWall->copyFrom(pWall);

	DList<AcDbSoftPointerId> listBindWinid, idlist;

	for (int i=0; i<pWall->GetOpeningIdList().Length(); i++)

	{
		AcDbEntity *pEnt = NULL;
		AcDbSoftPointerId id = pWall->GetOpeningIdList()[i];
		Acad::ErrorStatus es = acdbOpenAcDbEntity(pEnt, id, AcDb::kForRead);
		if (pEnt == NULL)
			continue;

		if (pEnt->isKindOf(TDbBandWin::desc())) // 判断是否是带形窗
		{
			TDbBandWin *pBandWin = TDbBandWin::cast(pEnt);
			if (pBandWin != NULL)
			{
				long nNum = pBandWin->GetWallNum();
				for (int j=0; j<nNum; j++)
				{
					AcDbObjectId idTem = pBandWin->GetWallId(j);
					if (idTem == pWall->objectId())
					{
						pWall->RemoveReferenceOpening(id);
						i--;
					}
				}
			}
			listBindWinid.Append(&id);
		}
		pEnt->close();
	}

	pWall->MoveOpeningTo(*pCWall);
	pWall->MovePatchTo(*pCWall);

	pCWall->ChangeElevation(pWall->GetElevation(), FALSE);
	pCWall->SetHeight(pWall->GetHeight());
	pCWall->SetWidth(0, pWall->GetWidth(0));
	pCWall->SetWidth(1, pWall->GetWidth(1));

	pCWall->SetStyle(TWallData::kBrick);

	pCWall->SetUsageFlag(pWall->GetUsageFlag());

	AcDbObjectId idNew = pCWall->AddToMSpace(Adesk::kTrue),
		idOld = pWall->objectId();
	for (i=0; i<listBindWinid.Length(); i++)
	{
		AcDbEntity *pEnt = NULL;
		AcDbSoftPointerId id = *listBindWinid[i];
		Acad::ErrorStatus es = acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite);
		if (pEnt == NULL)
			continue;

		TDbBandWin *pBandWin = TDbBandWin::cast(pEnt);
		if (pBandWin != NULL)
		{
			long nNum = pBandWin->GetWallNum();
			for (int j=0; j<nNum; j++)
			{
				AcDbObjectId idTem = pBandWin->GetWallId(j);
				if (idTem == idOld)
				{
					pBandWin->SetWallId(j, idNew);
				}
			}
		}
		pEnt->close();
	}
	return idNew;
}