#include "stdafx.h"
#include "KTCADUtilityEx.h"
#include "CoreTools.h"
#include "Equ_MODIFY.h"
#include "DBReactorOfEquMke.h"
#include "aecdbewequipment.h"

namespace
{
	AcGePoint3d getCenterOfReg(AcDbRegion *pReg)
	{
		if (!pReg) return AcGePoint3d::kOrigin;
		AcDbExtents ext;
		pReg->getGeomExtents(ext);
		return CoreTools::MidPt(ext.maxPoint(), ext.minPoint());
	}

	bool getRegionData(AcDbObjectId idPoly, CString &sReg, AcGePoint3d &ptCenter, const AcGeMatrix3d &mat)
	{
		OPENOBJ_BEGIN(idPoly, AcDb::kForWrite, AcDbCurve, pCurve)
		{
			if (!pCurve) return false;

			AcDbPolyline *pPoly(AcDbPolyline::cast(pCurve));
			if (pPoly && !pPoly->isClosed())
				pPoly->setClosed(true);

			AcDbCurve *pNew = (AcDbCurve*)pCurve->clone();
			AcDbRegion *pReg = CoreTools::createRegion(pNew);
			DELETE_PTR(pNew);

			if (!pReg) return false;

			pReg->transformBy(mat);

			CoreTools::RegionToString(pReg, sReg);
			ptCenter = getCenterOfReg(pReg);
			DELETE_PTR(pReg);
		}
		OPENOBJ_END()
		return true;
	}

	bool getRegionData(AcDbObjectId idPoly, AcDbRegion *&pReg, AcGePoint3d &ptCenter)
	{
		OPENOBJ_BEGIN(idPoly, AcDb::kForWrite, AcDbCurve, pCurve)
		{
			if (!pCurve) return false;

			AcDbPolyline *pPoly(AcDbPolyline::cast(pCurve));
			if (pPoly && !pPoly->isClosed())
				pPoly->setClosed(true);

			AcDbCurve *pNew = (AcDbCurve*)pCurve->clone();
			pReg = CoreTools::createRegion(pNew);
			DELETE_PTR(pNew);
			if (pReg) ptCenter = getCenterOfReg(pReg);
		}
		OPENOBJ_END()
		return pReg == NULL ? false: true;
	}

	bool initLayers(const bool &bInit)
	{
		std::set<CString> layers;
		
		if (bInit)
		{
			LayerTools::getAllLayers(layers);
			if (layers.empty())
			{
				acutPrintf(_T("\n获取所有图层失败！"));
				return false;
			}
			LayerTools::lockLayers(layers, true);

			if (!LayerTools::createNewLayer(LayerTools::g_sLayerName))
			{
				acutPrintf(_T("\n新建图层失败！"));
				LayerTools::lockLayers(layers, true);
				return false;
			}

			LayerTools::setCLayer(LayerTools::g_sLayerName);

			return true;
		}
		else
		{
			LayerTools::setCLayer(_T("0"));
			LayerTools::deleteLayer(LayerTools::g_sLayerName);

			LayerTools::getAllLayers(layers);
			if (layers.empty())
			{
				acutPrintf(_T("\n获取所有图层失败！"));
				return false;
			}
			LayerTools::lockLayers(layers, false);
		}
		return true;
	}

	void deleteEntity(AcDbObjectId id)
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
		{
			if (pEnt)
			{
				pEnt->erase();
			}
		}
		OPENOBJ_END()
	}

	AcDbCurve* String2Polyline(LPCTSTR sReg)
	{
		if (!sReg) return NULL;
		AcDbRegion *pReg = CoreTools::StringToRegion(sReg);
		if (!pReg)
		{
			acutPrintf(_T("\n新region失败！"));
			return NULL;
		}
		AcDbVoidPtrArray ar;
		pReg->explode(ar);
		DELETE_PTR(pReg);

		if (ar.length() == 1)
		{
			AcDbEntity *pEnt((AcDbEntity*)ar[0]);
			AcDbCircle *pCir = AcDbCircle::cast(pEnt);
			if (pCir) return (AcDbCurve*)pCir->clone();
		}

		AcDbPolyline *pPoly(NULL);
		std::vector<AcDbPolyline*> polys;
		if (CoreTools::MakePolyline(ar, polys))
			pPoly = polys[0];
		deleteArrayVoidPtrs< AcDbEntity>(ar);
		return pPoly;
	}

	void hideEntity(AcDbObjectId &id, const bool &bHide)
	{
		OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbEntity, pEnt)
		if (pEnt)
		{
			pEnt->setVisibility(bHide ? AcDb::kInvisible : AcDb::kVisible);
		}
		OPENOBJ_END()
	}
}

#pragma region base
IMPLEMENT_DYNAMIC(CDTYG_XG, CDialog)

BEGIN_MESSAGE_MAP(CDTYG_XG, CDialog)
END_MESSAGE_MAP()

CDTYG_XG::CDTYG_XG(UINT idd, CWnd * pParent)
	: CDialog(idd, pParent)
	, m_idReg(AcDbObjectId::kNull)
	, m_idPath(AcDbObjectId::kNull)
	, m_pPrim(NULL)
	, m_sReg(_T(""))
	, m_idEqu(AcDbObjectId::kNull)
{ }

CDTYG_XG::~CDTYG_XG() { }

bool CDTYG_XG::init(AecEqui::XPrimData *pData
	, AcDbObjectId idEqu
	, AcDbObjectId &hlid
	, const AcGePoint3d &ptIns
	, const AcGeVector3d &vtDir
	, const bool &bVert )
{
	AcAxDocLock lock;

#ifdef ZWCAD
	acedPostCommand(_T("_SHADEMODE _2D "));
#else
	acedPostCommand(_T("_vscurrent 2 "));
#endif

	resetLayersAndOverrules();
	DelIntermediaryObj();
	m_interObjs.clear();
	m_idReg = m_idPath = AcDbObjectId::kNull;
	m_sReg = _T("");
	m_idHlight = hlid;
	hideEntity(m_idHlight, true);
	m_pPrim = pData;
	m_idEqu = idEqu;

	m_ptIns = ptIns;
	m_vtDir = vtDir;
	m_bVert = bVert;

	return true;
}

void CDTYG_XG::resetLayersAndOverrules()
{
	CEntityOverrule::delOverrule();

	AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
	pDb->disableUndoRecording(true);
	initLayers(false);
	pDb->disableUndoRecording(false);
}

void CDTYG_XG::AddOverrules()
{
	std::set<AcDbObjectId> _ids;
	_ids.insert(m_interObjs.begin(), m_interObjs.end());
	CEntityOverrule::addOverrule(_ids);
}

void CDTYG_XG::DelIntermediaryObj()
{
	AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
	pDb->disableUndoRecording(true);
	for (size_t i = 0; i < m_interObjs.size(); ++i)
	{
		deleteEntity(m_interObjs[i]);
	}
	LayerTools::deleteLayer(LayerTools::g_sLayerName);
	pDb->disableUndoRecording(false);
}

bool CDTYG_XG::getRegionData(AcDbObjectId &idReg, CString & sReg, AcGePoint3d & ptC)
{
	AcDbRegion *pReg(NULL);
	bool bRel = getRegionData(idReg, pReg, ptC);
	if (pReg)
	 bRel = CoreTools::RegionToString(pReg, sReg);
	DELETE_PTR(pReg);
	return bRel;
}

void CDTYG_XG::TransformEntity(AcDbEntity * pEnt)
{
	return AecDbEwEquipment::TransformEntity(pEnt, m_ptIns, m_vtDir, m_pPrim, m_bVert);
}

void CDTYG_XG::UnTransformEntity(AcDbEntity * pEnt)
{
	return AecDbEwEquipment::UnTransformEntity(pEnt, m_ptIns, m_vtDir, m_pPrim, m_bVert);
}

bool CDTYG_XG::getRegionData(AcDbObjectId &idReg, AcDbRegion *&pReg, AcGePoint3d &ptC)
{
	OPENOBJ_BEGIN(idReg, AcDb::kForWrite, AcDbCurve, pCurve)
	{
		if (!pCurve) return false;

		AcDbPolyline *pPoly(AcDbPolyline::cast(pCurve));
		if (pPoly && !pPoly->isClosed())
			pPoly->setClosed(true);

		AcDbCurve *pNew = (AcDbCurve*)pCurve->clone();
		pReg = CoreTools::createRegion(pNew);
		DELETE_PTR(pNew);
		if (pReg)
		{
			UnTransformEntity(pReg);
			ptC = getCenterOfReg(pReg);
		}
	}
	OPENOBJ_END()
	return pReg == NULL ? false : true;
}

void CDTYG_XG::OnOK()
{
	AcAxDocLock lock;
	resetLayersAndOverrules();
	DelIntermediaryObj();
	//hideEntity(m_idHlight, false);
	//acedPostCommand(_T("r "));
	CDialog::OnOK();
	if (GetParent()) GetParent()->ShowWindow(SW_SHOW);
	if (GetParent()) GetParent()->PostMessage(WM_REFRESH_HLIGHT_ENTITY_MESSAGE);
	OPENOBJ_BEGIN(m_idEqu, AcDb::kForWrite, AecDbEwEquipment, pEqu)
	if (pEqu)
	{
		pEqu->clearGeoBuffer();
	}
	OPENOBJ_END()
}

void CDTYG_XG::OnCancel()
{
	AcAxDocLock lock;
	resetLayersAndOverrules();
	DelIntermediaryObj();
	hideEntity(m_idHlight, false);
	acedPostCommand(_T("r "));
	CDialog::OnCancel();
	if (GetParent()) GetParent()->ShowWindow(SW_SHOW);
}

#pragma endregion

#pragma region EXTRUD
IMPLEMENT_DYNAMIC(CDTYG_XG_EXTRUD, CDTYG_XG)

BEGIN_MESSAGE_MAP(CDTYG_XG_EXTRUD, CDTYG_XG)
	ON_BN_CLICKED(IDOK, &CDTYG_XG_EXTRUD::OnBnClickedOk)
END_MESSAGE_MAP()

CDTYG_XG_EXTRUD::CDTYG_XG_EXTRUD(CWnd* pParent)
	: CDTYG_XG(IDD, pParent)
{ }

CDTYG_XG_EXTRUD::~CDTYG_XG_EXTRUD() { }

bool CDTYG_XG_EXTRUD::init(AecEqui::XPrimData *pData
	, AcDbObjectId idEqu
	, AcDbObjectId &hlid
	, const AcGePoint3d &ptIns
	, const AcGeVector3d &vtDir
	, const bool &bVert )
{
	if (!CDTYG_XG::init(pData, idEqu, hlid, ptIns, vtDir, bVert)) return false;

	NewExtrude ne;
	if (!ne.fromData((byte*)m_pPrim->m_pData, m_pPrim->m_nSize))
		return false;

	m_sReg = ne.m_sRegion;
	m_dHeight = ne.m_dH;
	if(GetParent()) GetParent()->ShowWindow(SW_HIDE);
	UpdateData(FALSE);
	drawRegion();
	return true;
}

void CDTYG_XG_EXTRUD::DoDataExchange(CDataExchange* pDX)
{
	CDTYG_XG::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_MODIFY_HEIGHT, m_dHeight);
}

void CDTYG_XG_EXTRUD::drawRegion()
{
	AcAxDocLock lock;
	
	AcDbCurve *pPoly(String2Polyline(m_sReg));
	if (!pPoly)
	{
		acutPrintf(_T("\npolyline生成失败！"));
		return;
	}

	TransformEntity(pPoly);

	initLayers(true);
	pPoly->setLayer(LayerTools::g_sLayerName);

	CoreTools::AddToModelSpace(pPoly, NULL, true, &m_idReg);
	if (!m_idReg.isValid())
	{
		acutPrintf(_T("\n截面曲线插入失败！"));
		initLayers(false);
		return;
	}

	acedPostCommand(_T("r "));

	// 锁定实体不允许删除
	m_interObjs.push_back(m_idReg);
	AddOverrules();
}

void CDTYG_XG_EXTRUD::OnBnClickedOk()
{
	AcAxDocLock lock;
	UpdateData(TRUE);

	AcGePoint3d pt;
	AcDbRegion *pReg;
	if (getRegionData(m_idReg, pReg, pt))
	{
		NewExtrude ne(!m_pPrim->m_bBoolSubtract, pReg, m_dHeight);
		DELETE_ARR_(m_pPrim->m_pData);
		m_pPrim->m_nSize = 0;
		ne.toData(m_pPrim->m_pData, m_pPrim->m_nSize);
		DELETE_PTR(pReg);
	}

	// 还原环境
	resetLayersAndOverrules();

	CDTYG_XG::OnOK();
}

#pragma endregion

#pragma region REVOLVE
IMPLEMENT_DYNAMIC(CDTYG_XG_REVOLVE, CDTYG_XG)

BEGIN_MESSAGE_MAP(CDTYG_XG_REVOLVE, CDTYG_XG)
	ON_BN_CLICKED(IDOK, &CDTYG_XG_REVOLVE::OnBnClickedOk)
END_MESSAGE_MAP()

CDTYG_XG_REVOLVE::CDTYG_XG_REVOLVE(CWnd* pParent)
	: CDTYG_XG(IDD, pParent)
	, m_ptOrg(AcGePoint3d::kOrigin)
	, m_vt(AcGeVector3d::kIdentity)
	, m_dSweepAngle(.0)
	, m_dStartAngle(.0) { }

CDTYG_XG_REVOLVE::~CDTYG_XG_REVOLVE() { }

bool CDTYG_XG_REVOLVE::init(AecEqui::XPrimData *pData
	, AcDbObjectId idEqu
	, AcDbObjectId &hlid
	, const AcGePoint3d &ptIns
	, const AcGeVector3d &vtDir
	, const bool &bVert)
{
	if (!CDTYG_XG::init(pData, idEqu, hlid, ptIns, vtDir, bVert)) return false;
	NewRevolve nr;
	if (!nr.fromData((byte*)m_pPrim->m_pData, m_pPrim->m_nSize))
		return false;

	m_ptOrg = nr.m_ptOrg;
	m_vt = nr.m_vtDir;
	m_dSweepAngle = nr.m_dSweepAngle;
	m_dStartAngle = nr.m_dStartAngle;
	m_sReg = nr.m_sRegion;
	
	SetWindowText(_T("单体异构-修改旋转体"));
	if (GetDlgItem(IDC_STATIC_TIP))
	{
		GetDlgItem(IDC_STATIC_TIP)->SetWindowText(_T("请直接修改红色截面和黄色旋转轴。"));
	}

	drawRegion();

	if(GetParent()) GetParent()->ShowWindow(SW_HIDE);

	return true;
}

void CDTYG_XG_REVOLVE::drawRegion()
{
	AcAxDocLock lock;

	AcDbCurve *pPoly(String2Polyline(m_sReg));
	if (!pPoly)
	{
		acutPrintf(_T("\npolyline生成失败！"));
		return;
	}

	initLayers(true);
	pPoly->setLayer(LayerTools::g_sLayerName);

	TransformEntity(pPoly);

	CoreTools::AddToModelSpace(pPoly, NULL, true, &m_idReg);
	if (!m_idReg.isValid())
	{
		acutPrintf(_T("\n截面曲线插入失败！"));
		initLayers(false);
		return;
	}

	AcDbRay *pRay = new AcDbRay();
	pRay->setBasePoint(m_ptOrg);
	pRay->setUnitDir(m_vt);
	pRay->setColorIndex(2);
	TransformEntity(pRay);

	CoreTools::AddToModelSpace(pRay, NULL, true, &m_idPath);
	if (!m_idPath.isValid())
	{
		acutPrintf(_T("\n旋转轴插入失败！"));
		initLayers(false);
		return;
	}

	acedPostCommand(_T("r "));

	// 锁定实体不允许删除
	m_interObjs.push_back(m_idReg);
	m_interObjs.push_back(m_idPath);
	AddOverrules();
}

void CDTYG_XG_REVOLVE::OnBnClickedOk()
{
	AcAxDocLock lock;
	AcGePoint3d pt;
	AcDbRegion *pReg(NULL);
	if (getRegionData(m_idReg, pReg, pt))
	{
		OPENOBJ_BEGIN(m_idPath, AcDb::kForWrite, AcDbRay, pRay)
		if (pRay)
		{
			UnTransformEntity(pRay);
			m_ptOrg = pRay->basePoint();
			m_vt = pRay->unitDir();
			NewRevolve nr(!m_pPrim->m_bBoolSubtract, pReg, m_ptOrg, m_vt, m_dSweepAngle, m_dStartAngle);
			DELETE_ARR_(m_pPrim->m_pData);
			m_pPrim->m_nSize = 0;
			nr.toData(m_pPrim->m_pData, m_pPrim->m_nSize);
		}
		OPENOBJ_END()
		DELETE_PTR(pReg);
	}

	// 还原环境
	resetLayersAndOverrules();
	CDTYG_XG::OnOK();
}

#pragma endregion

#pragma region SWEEP
IMPLEMENT_DYNAMIC(CDTYG_XG_SWEEP, CDTYG_XG)

BEGIN_MESSAGE_MAP(CDTYG_XG_SWEEP, CDTYG_XG)
	ON_BN_CLICKED(IDOK, &CDTYG_XG_SWEEP::OnBnClickedOk)
END_MESSAGE_MAP()

CDTYG_XG_SWEEP::CDTYG_XG_SWEEP(CWnd* pParent)
	: CDTYG_XG(IDD, pParent)
	, m_pCurve(NULL)
{ }

CDTYG_XG_SWEEP::~CDTYG_XG_SWEEP()
{
	DELETE_PTR(m_pCurve);
}

bool CDTYG_XG_SWEEP::init(AecEqui::XPrimData *pData
	, AcDbObjectId idEqu
	, AcDbObjectId &hlid
	, const AcGePoint3d &ptIns
	, const AcGeVector3d &vtDir
	, const bool &bVert)
{
	DELETE_PTR(m_pCurve);
	if (!CDTYG_XG::init(pData, idEqu, hlid, ptIns, vtDir, bVert)) return false;

	NewSweep ns;
	if (!ns.fromData((byte*)m_pPrim->m_pData, m_pPrim->m_nSize))
		return false;

	m_sReg = ns.m_sRegion;
	m_pCurve = CoreTools::StringToPolyline(ns.m_sPath);
	if (!m_pCurve)
		return false;

	SetWindowText(_T("单体异构-修改扫掠体"));
	if (GetDlgItem(IDC_STATIC_TIP))
	{
		GetDlgItem(IDC_STATIC_TIP)->SetWindowText(_T("请直接修改红色截面和黄色路径。\n\n请注意：\n\n如要修改扫掠体位置，请修改红色截面位置。\n\n路径只决定扫掠体走向。"));
	}

	drawRegion();

	if(GetParent()) GetParent()->ShowWindow(SW_HIDE);
	return true;
}

void CDTYG_XG_SWEEP::drawRegion()
{
	AcAxDocLock lock;

	AcDbCurve *pPoly(String2Polyline(m_sReg));
	if (!pPoly)
	{
		acutPrintf(_T("\npolyline生成失败！"));
		return;
	}

	initLayers(true);
	pPoly->setLayer(LayerTools::g_sLayerName);
	TransformEntity(pPoly);
	CoreTools::AddToModelSpace(pPoly, NULL, true, &m_idReg);

	if (!m_idReg.isValid())
	{
		acutPrintf(_T("\n截面曲线插入失败！"));
		initLayers(false);
		return;
	}

	AcDbPolyline *pPath = (AcDbPolyline*)m_pCurve->clone();
	DELETE_PTR(m_pCurve);
	pPath->setColorIndex(2);
	pPath->setLayer(LayerTools::g_sLayerName);
	TransformEntity(pPath);
	CoreTools::AddToModelSpace(pPath, NULL, true, &m_idPath);

	if (!m_idPath.isValid())
	{
		acutPrintf(_T("\n旋转轴插入失败！"));
		initLayers(false);
		return;
	}

	acedPostCommand(_T("r "));

	// 锁定实体不允许删除
	m_interObjs.push_back(m_idReg);
	m_interObjs.push_back(m_idPath);
	AddOverrules();
}

void CDTYG_XG_SWEEP::OnBnClickedOk()
{
	AcAxDocLock lock;

	AcGePoint3d pt;
	AcDbRegion *pReg(NULL);
	if (getRegionData(m_idReg, pReg, pt))
	{
		OPENOBJ_BEGIN(m_idPath, AcDb::kForWrite, AcDbPolyline, pPoly)
		if (pPoly)
		{
			UnTransformEntity(pPoly);
			NewSweep ns(!m_pPrim->m_bBoolSubtract, pReg, pPoly);
			DELETE_ARR_(m_pPrim->m_pData);
			m_pPrim->m_nSize = 0;
			ns.toData(m_pPrim->m_pData, m_pPrim->m_nSize);
		}
		OPENOBJ_END()
		DELETE_PTR(pReg);
	}
	
	resetLayersAndOverrules();
	CDTYG_XG::OnOK();
}

#pragma endregion

#pragma region LOFT
IMPLEMENT_DYNAMIC(CDTYG_XG_LOFT, CDTYG_XG)

BEGIN_MESSAGE_MAP(CDTYG_XG_LOFT, CDTYG_XG)
	ON_BN_CLICKED(IDOK, &CDTYG_XG_LOFT::OnBnClickedOk)
	ON_REGISTERED_MESSAGE(WM_XLISTCTRL_EDIT_END, &CDTYG_XG_LOFT::OnEditEnd)
	ON_BN_CLICKED(IDC_CHECK1, &CDTYG_XG_LOFT::OnBnClickedCheck1)
	ON_NOTIFY(NM_CLICK, IDC_LIST, &CDTYG_XG_LOFT::OnNMClickList)
END_MESSAGE_MAP()

CDTYG_XG_LOFT::CDTYG_XG_LOFT(CWnd* pParent)
	: CDTYG_XG(IDD, pParent)
	, m_heights(0)
	, m_regs(0)
	, m_bUseTbl(TRUE)
{ }

CDTYG_XG_LOFT::~CDTYG_XG_LOFT() { }

void CDTYG_XG_LOFT::DoDataExchange(CDataExchange * pDX)
{
	CDTYG_XG::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST, m_lstCtrl);
	DDX_Check(pDX, IDC_CHECK1, m_bUseTbl);
}

BOOL CDTYG_XG_LOFT::OnInitDialog()
{
	CDTYG_XG::OnInitDialog();

	m_lstCtrl.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_SINGLEROW);
	m_lstCtrl.InsertColumn(0, _T("层号"), LVCFMT_LEFT, 125);
	m_lstCtrl.InsertColumn(1, _T("层高"), LVCFMT_LEFT, 125);

	UpdateData(FALSE);

	return TRUE;
}

bool CDTYG_XG_LOFT::init(AecEqui::XPrimData *pData
	, AcDbObjectId idEqu
	, AcDbObjectId &hlid
	, const AcGePoint3d &ptIns
	, const AcGeVector3d &vtDir
	, const bool &bVert)
{
	m_regs.clear();
	m_heights.clear();
	m_bUseTbl = TRUE;
	if (!CDTYG_XG::init(pData, idEqu, hlid, ptIns, vtDir, bVert)) return false;

	NewLoft nl;
	if (!nl.fromData((byte*)m_pPrim->m_pData, m_pPrim->m_nSize))
		return false;

	m_regs = nl.m_regs;

	// 分析截面找到层高
	if (m_regs.size() < 2)
	{
		acutPrintf(_T("\nloft截面小于2！"));
		return false;
	}

	std::vector<AcDbRegion*> regs;
	
	AcGePlane plan;
	AcGeVector3d vt, vtN;
	double dH(.0);
	AcGePoint3d ptM(AcGePoint3d::kOrigin), ptNear(AcGePoint3d::kOrigin);
	for (size_t i = 0; i < m_regs.size() - 1; ++i)
	{
		AcDbRegion *pReg1 = CoreTools::StringToRegion(m_regs[i]);
		AcDbRegion *pReg2 = CoreTools::StringToRegion(m_regs[i+1]);
		if (!pReg1 || !pReg2) continue;

		regs.push_back(pReg1);
		regs.push_back(pReg2);

		pReg1->getPlane(plan);
		vtN = plan.normal();

		ptM = getCenterOfReg(pReg2);
		ptNear = plan.closestPointTo(ptM);

		dH = ptNear.distanceTo(ptM);
		vt = ptM - ptNear;

		if (!vt.isCodirectionalTo(vtN))
			dH *= -1;

		m_heights.push_back(dH);
	}

	deleteContainerOfStd(regs);

	m_lstCtrl.DeleteAllItems();
	CString s(_T(""));
	for (size_t i = 0; i < m_heights.size(); ++i)
	{
		s.Format(_T("%d层"), i + 1);
		m_lstCtrl.InsertItem(i, s);
		s.Format(_T("%.1f"), m_heights[i]);
		m_lstCtrl.SetItemText(i, 1, s);
		m_lstCtrl.SetEdit(i, 1);
	}

	// 直接显示各截面
	drawRegion();

	UpdateData(FALSE);

	if (GetParent()) GetParent()->ShowWindow(SW_HIDE);

	return true;
}

void CDTYG_XG_LOFT::drawRegion()
{
	AcAxDocLock lock;
	AcDbObjectId id;
	initLayers(true);
	for (size_t i = 0; i < m_regs.size(); ++i)
	{
		AcDbCurve *pPoly(String2Polyline(m_regs[i]));
		if (!pPoly) continue;
		pPoly->setLayer(LayerTools::g_sLayerName);
		TransformEntity(pPoly);
		CoreTools::AddToModelSpace(pPoly, NULL, true, &id);
		if (id.isValid())
		{
			m_interObjs.push_back(id);
		}
	}

	acedPostCommand(_T("r "));

	// 锁定实体不允许删除
	AddOverrules();
}

void CDTYG_XG_LOFT::OnBnClickedOk()
{
	AcAxDocLock lock;
	UpdateData(TRUE);

	resetLayersAndOverrules();

	AcGePoint3d ptM(AcGePoint3d::kOrigin);
	std::vector<std::pair<AcDbRegion*, AcGePoint3d>> mp;
	for (size_t i = 0; i < m_interObjs.size(); ++i)
	{
		AcDbRegion *pReg(NULL);
		if (!getRegionData(m_interObjs[i], pReg, ptM)) continue;
		mp.push_back(std::make_pair(pReg, ptM));
	}

	if (mp.empty()) return;

	if (m_bUseTbl)	// 根据数据调整截面
	{
		m_heights.clear();
		CString sV(_T(""));
		for (int i = 0; i < m_lstCtrl.GetItemCount(); i++)
		{
			sV = m_lstCtrl.GetItemText(i, 1);
			m_heights.push_back(TypeConvert::s2f(sV));
		}

		if (m_heights.size() == mp.size() - 1)
		{
			AcGeVector3d vtN;
			AcGePlane plan;
			AcGeMatrix3d mat;
			AcGePoint3d ptM1, ptM2;

			mp[0].first->getPlane(plan);
			vtN = plan.normal();
			ptM1 = mp[0].second;

			double dH(0.);
			for (size_t i(1); i < mp.size(); ++i)
			{
				dH += m_heights[i - 1];
				vtN = plan.normal();
				mat.setToIdentity();
				// 先把所有平面都放到第一层
				AcDbRegion *pReg = mp[i].first;
				ptM2 = mp[i].second;
				double deltaZ(ptM1.z - ptM2.z);
				vtN *= deltaZ;
				mat.setToTranslation(vtN);
				pReg->transformBy(mat);

				vtN = plan.normal();
				vtN *= dH;
				mat.setToIdentity();
				mat.setToTranslation(vtN);
				pReg->transformBy(mat);
			}
		}
	}

	m_regs.clear();
	AcArray<AcDbRegion*> regs;
	for (size_t i = 0; i < mp.size(); ++i)
	{
		regs.append(mp[i].first);
	}

	NewLoft nl(!m_pPrim->m_bBoolSubtract, regs, NULL);
	DELETE_ARR_(m_pPrim->m_pData);
	m_pPrim->m_nSize = 0;
	nl.toData(m_pPrim->m_pData, m_pPrim->m_nSize);

	CDTYG_XG::OnOK();
}

LRESULT CDTYG_XG_LOFT::OnEditEnd(WPARAM nItem, LPARAM nSubItem)
{
	CString sValue = m_lstCtrl.GetItemText(nItem, nSubItem);

	if (!CoreTools::isDigitString<double>(sValue) && !CoreTools::isDigitString<int>(sValue))
	{
		m_lstCtrl.SetItemText(nItem, nSubItem, _T("100.0"));
		AfxMessageBox(_T("请输入数字！"));
		return 0;
	}
	return 0;
}

void CDTYG_XG_LOFT::OnBnClickedCheck1()
{
	UpdateData(TRUE);
	//m_bUseTbl = !m_bUseTbl;
	if (m_bUseTbl)
	{
		m_lstCtrl.EnableWindow(true);
	}
	else
	{
		m_lstCtrl.EnableWindow(false);
	}

}

void CDTYG_XG_LOFT::OnNMClickList(NMHDR *pNMHDR, LRESULT *pResult)
{
	AcAxDocLock lock;
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	*pResult = 0;

	// 先全部还原颜色
	for (size_t i = 0; i < m_interObjs.size(); ++i)
	{
		OPENOBJ_BEGIN(m_interObjs[i], AcDb::kForWrite, AcDbEntity, pEnt)
		{
			if (!pEnt) return;
			pEnt->setColorIndex(256);
		}
		OPENOBJ_END()
	}

	int nItem = pNMItemActivate->iItem;
	if (nItem < m_heights.size() || nItem >= 0)
	{
		if (m_interObjs.empty()) return;

		int nFr(nItem), nEd(nItem + 1);

		if ((nFr < 0 || nFr >= m_interObjs.size())
			|| (nEd < 0 || nEd >= m_interObjs.size()))
			return;

		AcDbObjectId idFr(m_interObjs[nFr]), idEd(m_interObjs[nEd]);
		OPENOBJ_BEGIN(idFr, AcDb::kForWrite, AcDbEntity, pEnt1)
		{
			OPENOBJ_BEGIN(idEd, AcDb::kForWrite, AcDbEntity, pEnt2)
			{
				if (!pEnt1 || !pEnt2) return;
				pEnt1->setColorIndex(2);
				pEnt2->setColorIndex(2);
			}
			OPENOBJ_END()
		}
		OPENOBJ_END()
	}
	
	acedPostCommand(_T("r "));

}
#pragma endregion