#include "stdafx.h"
#include "SBZWDlg.h"
#include "NozzDlg.h"
#include "AecDbEwEquipment.h"
#include "KTSetting.h"

#define LAY_PIPE_CENTER		_T("PIPE_CEN")
#define LAY_PIPE_OUTSIDE	_T("PIPE_OUT")
#define LAY_PIPE_SINGLE		_T("PIPE_SIG")
#define LAY_PIPE_DASH		_T("PIPE_DSH")

#ifndef LAY_FITN_CENTER
#define LAY_FITN_CENTER		_T("FITN_CEN")
#endif

#define LAY_FITN_OUTSIDE	_T("FITN_OUT")
#define LAY_FITN_SINGLE		_T("FITN_SIG")
#define LAY_FITN_DASH		_T("FITN_DSH")

#ifndef LAY_EQU_CENTER
#define LAY_EQU_CENTER		_T("EQU_CEN")
#define LAY_EQU_DASH		_T("EQU_DSH")
#define LAY_EQU				_T("EQU")
#endif

extern CString IDCreate();

//同 CEquipmentMakeDlg namespace
namespace
{
	template <typename T>
	void setData(AecEqui::XPrimData *pXPData, void *pData)
	{
		pXPData->m_nID = ::_time32(NULL);
		switch (pXPData->m_eType)
		{
		case AecEqui::kExtrude:
		case AecEqui::kRevolve:
			pXPData->m_nSize = ((AecEqui::XBuffer*)pData)->nSize;
			if (pXPData->m_nSize > 0)
			{
				pXPData->m_pData = new byte[pXPData->m_nSize];
				::memcpy(pXPData->m_pData, ((AecEqui::XBuffer*)pData)->pData, pXPData->m_nSize);
			}
			break;
		default:
			pXPData->m_pData = new T;
			::memcpy(pXPData->m_pData, pData, sizeof(T));
			pXPData->m_nSize = sizeof(T);
			break;
		}
	}

	void GetTransformbyXform(AcGePoint3d &ptRotation, AcGeVector3d &vtMove, AcGePoint3d& ptPos)
	{
		//x旋转轴旋转
		AcGeMatrix3d xform;
		xform.setToRotation(ptRotation.x, AcGeVector3d::kXAxis);
		ptPos.transformBy(xform);

		//Y旋转轴旋转
		xform.setToIdentity();
		xform.setToRotation(ptRotation.y, AcGeVector3d::kYAxis);
		ptPos.transformBy(xform);

		//z旋转轴旋转
		xform.setToIdentity();
		xform.setToRotation(ptRotation.z, AcGeVector3d::kZAxis);
		ptPos.transformBy(xform);

		//x方向移动
		xform.setToIdentity();
		xform.setToTranslation(AcGeVector3d(vtMove.x, 0.0, 0.0));
		ptPos.transformBy(xform);

		//y方向移动
		xform.setToIdentity();
		xform.setToTranslation(AcGeVector3d(0.0, vtMove.y, 0.0));
		ptPos.transformBy(xform);

		//z方向移动
		xform.setToIdentity();
		xform.setToTranslation(AcGeVector3d(0.0, 0.0, vtMove.z));
		ptPos.transformBy(xform);
	}

	void GetTransformbyXform(AcGePoint3d &ptRotation, AcGeVector3d& vtDir)
	{
		//x旋转轴旋转
		AcGeMatrix3d xform;
		xform.setToRotation(ptRotation.x, AcGeVector3d::kXAxis);
		vtDir.transformBy(xform);

		//Y旋转轴旋转
		xform.setToIdentity();
		xform.setToRotation(ptRotation.y, AcGeVector3d::kYAxis);
		vtDir.transformBy(xform);

		//z旋转轴旋转
		xform.setToIdentity();
		xform.setToRotation(ptRotation.z, AcGeVector3d::kZAxis);
		vtDir.transformBy(xform);
	}

	short GetInfFaceCount(AecEqui::Primitive type)
	{
		switch (type)
		{
		case AecEqui::kPyramid:
		case AecEqui::kBox:
			return 6;
		case AecEqui::kCylinder:
		case AecEqui::kCone:
		case AecEqui::kCirTorus:
		case AecEqui::kRectTorus:
		case AecEqui::kExtrude:
		case AecEqui::kRevolve:
		case AecEqui::kTydf:
		case AecEqui::kNozz:
			return 2;
		case AecEqui::kDish:
		case AecEqui::kSphere:
			return 1;
		default: break;
		}
		return 0;
	}

	void GetInfFaceInf(AecEqui::XPrimData *pXPData, short nIndex, AcGeVector3d& vtDir, AcGePoint3d& ptGe)
	{
		AcGePoint3d ptGeT[4], ptGeB[4], ptMid, ptMid2;
		AcGeVector3d vt1, vt2;

		if (nIndex < GetInfFaceCount((AecEqui::Primitive)pXPData->m_eType) && nIndex > -1 && pXPData->m_pData != NULL)
		{
			switch (pXPData->m_eType)
			{
			case AecEqui::kBox:
				{
					AecEqui::XBox* pBox = (AecEqui::XBox*)pXPData->m_pData;
					ptGe = AcGePoint3d::kOrigin;
					switch (nIndex)
					{
					case 0://下
						{
							ptGe = AcGePoint3d::kOrigin;//-= pBox->dH / 2.0;
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 1://上
						{
							ptGe.z += pBox->dH;
							vtDir = AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 2://左
						{
							ptGe.z += pBox->dH / 2.0;
							ptGe.x -= pBox->dL / 2.0;
							vtDir = -AcGeVector3d::kXAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 3://右
						{
							ptGe.z += pBox->dH / 2.0;
							ptGe.x += pBox->dL / 2.0;
							vtDir = AcGeVector3d::kXAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 4://前
						{
							ptGe.z += pBox->dH / 2.0;
							ptGe.y += pBox->dW / 2.0;
							vtDir = -AcGeVector3d::kYAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 5://后
						{
							ptGe.z += pBox->dH / 2.0;
							ptGe.y -= pBox->dW / 2.0;
							vtDir = AcGeVector3d::kYAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kCylinder:
				{
					AecEqui::XCylinder* pCli = (AecEqui::XCylinder*)pXPData->m_pData;
					ptGe = AcGePoint3d::kOrigin;
					switch (nIndex)
					{
					case 0:
						{
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							ptGe.z += pCli->dH;
							vtDir = AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kCone:
				{
					AecEqui::XCone* pCone = (AecEqui::XCone*)pXPData->m_pData;
					ptGe = AcGePoint3d::kOrigin;
					switch (nIndex)
					{
					case 0:
						{
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							ptGe.z += pCone->dH;
							vtDir = AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kPyramid:
				{
					AecEqui::XPyramid* pPyramid = (AecEqui::XPyramid*)pXPData->m_pData;
					ptGe = AcGePoint3d::kOrigin;

					ptGeB[0] = ptGe;
					ptGeB[0].x += pPyramid->dBX / 2.0;
					ptGeB[0].y += pPyramid->dBY / 2.0;

					ptGeB[1] = ptGeB[0];
					ptGeB[1].x -= pPyramid->dBX;

					ptGeB[2] = ptGeB[1];
					ptGeB[2].y -= pPyramid->dBY;

					ptGeB[3] = ptGeB[2];
					ptGeB[3].x += pPyramid->dBX;

					//顶
					ptGeT[0] = ptGe;
					ptGeT[0].z += pPyramid->dH;

					ptGeT[0].x += pPyramid->dTX / 2.0;
					ptGeT[0].y += pPyramid->dTY / 2.0;

					ptGeT[1] = ptGeT[0];
					ptGeT[1].x -= pPyramid->dTX;

					ptGeT[2] = ptGeT[1];
					ptGeT[2].y -= pPyramid->dTY;

					ptGeT[3] = ptGeT[2];
					ptGeT[3].x += pPyramid->dTX;

					switch (nIndex)
					{
					case 0:
						{
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							Midpoint(ptGeT[0], ptGeT[1], ptMid);
							vt1 = ptMid - ptGeB[0];
							vt2 = ptMid - ptGeB[1];
							vtDir = vt1.crossProduct(vt2);
							Midpoint(ptGeB[0], ptGeB[1], ptMid2);
							Midpoint(ptMid, ptMid2, ptGe);

							vt2 = ptGe.asVector();
							if (vt2.dotProduct(vtDir) < 0)
								vtDir.negate();
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 2:
						{
							Midpoint(ptGeT[1], ptGeT[2], ptMid);
							vt1 = ptMid - ptGeB[1];
							vt2 = ptMid - ptGeB[2];
							vtDir = vt1.crossProduct(vt2);
							Midpoint(ptGeB[1], ptGeB[2], ptMid2);
							Midpoint(ptMid, ptMid2, ptGe);

							vt2 = ptGe.asVector();
							if (vt2.dotProduct(vtDir) < 0)
								vtDir.negate();
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 3:
						{
							Midpoint(ptGeT[2], ptGeT[3], ptMid);
							vt1 = ptMid - ptGeB[2];
							vt2 = ptMid - ptGeB[3];
							vtDir = vt1.crossProduct(vt2);
							Midpoint(ptGeB[2], ptGeB[3], ptMid2);
							Midpoint(ptMid, ptMid2, ptGe);

							vt2 = ptGe.asVector();
							if (vt2.dotProduct(vtDir) < 0)
								vtDir.negate();
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 4:
						{
							Midpoint(ptGeT[3], ptGeT[0], ptMid);
							vt1 = ptMid - ptGeB[3];
							vt2 = ptMid - ptGeB[0];
							vtDir = vt1.crossProduct(vt2);
							Midpoint(ptGeB[3], ptGeB[0], ptMid2);
							Midpoint(ptMid, ptMid2, ptGe);

							vt2 = ptGe.asVector();
							if (vt2.dotProduct(vtDir) < 0)
								vtDir.negate();
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);

							break;
						}
					case 5:
						{
							vtDir = AcGeVector3d::kZAxis;
							ptGe = AcGePoint3d::kOrigin;
							ptGe.z += pPyramid->dH;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kCirTorus:
				{
					AecEqui::XCirtorus* pCirtor = (AecEqui::XCirtorus*)pXPData->m_pData;
					AcDbArc arc(AcGePoint3d::kOrigin, (pCirtor->dOutR + pCirtor->dInr) / 2.0,
						pCirtor->dStaAngle, pCirtor->dEndAngle);
					switch (nIndex)
					{
					case 0:
						{
							arc.getStartPoint(ptGe);
							vtDir = ptGe - arc.center();
							vtDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);

							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							arc.getEndPoint(ptGe);
							vtDir = ptGe - arc.center();
							vtDir.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kRectTorus:
				{
					AecEqui::XRecttorus* pRcTor = (AecEqui::XRecttorus*)pXPData->m_pData;
					AcDbArc arc(AcGePoint3d::kOrigin, (pRcTor->dOutR + pRcTor->dInr) / 2.0,
						pRcTor->dStaAngle, pRcTor->dEndAngle);

					switch (nIndex)
					{
					case 0:
						{
							arc.getStartPoint(ptGe);
							vtDir = ptGe - arc.center();
							vtDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);

							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							arc.getEndPoint(ptGe);
							vtDir = ptGe - arc.center();
							vtDir.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);

							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kDish:
				{
					ptGe = AcGePoint3d::kOrigin;
					vtDir = -AcGeVector3d::kZAxis;
					GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
					GetTransformbyXform(pXPData->m_ptRotation, vtDir);
					break;
				}
			case AecEqui::kSphere:
				{
					ptGe = AcGePoint3d::kOrigin;
					GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
					vtDir.set(1.0, 0.0, 0.0);
					break;
				}
			case AecEqui::kExtrude:
				{
					AecEqui::XVertex* pVert = (AecEqui::XVertex*)pXPData->m_pData;
					double dH = pVert->dVal[0];

					switch (nIndex)
					{
					case 0:
						{
							ptGe = AcGePoint3d::kOrigin;
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							ptGe = AcGePoint3d::kOrigin;
							ptGe.z += dH;
							vtDir = AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kRevolve:
				{
					//前两个为旋转轴
					AecEqui::XVertex* pVert = (AecEqui::XVertex*)pXPData->m_pData;
					AecEqui::XVertex* pVertAxFr = pVert;
					AecEqui::XVertex* pVertAxTo = pVert;
					pVertAxTo += 1;

					AcGePoint3d ptGeFr = asPnt3d((double*)pVertAxFr);
					AcGePoint3d ptGeTo = asPnt3d((double*)pVertAxTo);
					AcGeVector3d vt = ptGeTo - ptGeFr;

					switch (nIndex)
					{
					case 0:
						{
							ptGe = ptGeFr;
							vtDir = -vt;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							ptGe = ptGeTo;
							vtDir = vt;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kTydf:
				{
					AecEqui::XTydf* pTydf = (AecEqui::XTydf*)pXPData->m_pData;
					switch (nIndex)
					{
					case 0:
						{
							ptGe = AcGePoint3d::kOrigin;
							vtDir = -AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					case 1:
						{
							ptGe = AcGePoint3d::kOrigin;
							ptGe.z += pTydf->dH;
							vtDir = AcGeVector3d::kZAxis;
							GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
							GetTransformbyXform(pXPData->m_ptRotation, vtDir);
							break;
						}
					default:
						break;
					}
					break;
				}
			case AecEqui::kNozz:
				{
					AecEqui::XNozz* pNozz = (AecEqui::XNozz*)pXPData->m_pData;
					if (pNozz->nType == 0)
					{
						switch (nIndex)
						{
						case 0:
							{
								ptGe = AcGePoint3d::kOrigin;
								vtDir = -AcGeVector3d::kZAxis;
								GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
								GetTransformbyXform(pXPData->m_ptRotation, vtDir);
								break;
							}
						case 1:
							{
								double dH = pNozz->dVal5;

								//接口尺寸表 DN D N C
								double nDn = pNozz->dVal1;
								double nD = pNozz->dVal2;
								double nN = pNozz->dVal3;
								double nC = pNozz->dVal4;

								double dDx = nDn + (nN - nDn) / 4.0;
								double dTx = (nN - dDx) / 2.0;
								double dh = dTx * tan(75.0 * PI / 180.0);
								double dYMinh = 1.0 * int(dh + nC + 0.5);
								dH += dYMinh;

								ptGe = AcGePoint3d::kOrigin;
								ptGe.z = dYMinh;
								vtDir = AcGeVector3d::kZAxis;
								GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
								GetTransformbyXform(pXPData->m_ptRotation, vtDir);

								break;
							}
						default:
							break;
						}
					}
					else
					{
						switch (nIndex)
						{
						case 0:
							{
								ptGe = AcGePoint3d::kOrigin;
								vtDir = -AcGeVector3d::kZAxis;
								GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
								GetTransformbyXform(pXPData->m_ptRotation, vtDir);
								break;
							}
						case 1:
							{
								ptGe = AcGePoint3d::kOrigin;
								ptGe.z = pNozz->dVal3;
								vtDir = AcGeVector3d::kZAxis;
								GetTransformbyXform(pXPData->m_ptRotation, pXPData->m_vtMove, ptGe);
								GetTransformbyXform(pXPData->m_ptRotation, vtDir);
								break;
							}
						default:
							break;
						}
					}
					break;
				}
			default:
				break;
			}
		}
	}

	void MoveToInfFace(AecEqui::XPrimData *pXPData, AcGeVector3d &vtDirTo, AcGePoint3d &ptGeTo)
	{
		if (pXPData->m_nActiveInf == -1) return;
		AcGePoint3d ptGeThis;
		AcGeVector3d vtThis;
		GetInfFaceInf(pXPData, pXPData->m_nActiveInf, vtThis, ptGeThis);

		AcGeVector3d vtMove = ptGeTo - ptGeThis;

		double dDot = vtDirTo.dotProduct(vtThis);
		if (dDot < 0)
			vtDirTo.negate();

		//两个面吻合,this 旋转
		AcGeVector3d vtNorm = vtDirTo.crossProduct(vtThis);
		double dRotate = vtThis.angleTo(vtDirTo);
		//dRotate *= -1.0;//右旋方向

		AcGeMatrix3d xform1;
		xform1.setToRotation(dRotate, vtNorm, ptGeThis);

		AcGeMatrix3d xform2;
		xform2.setToTranslation(vtMove);

		pXPData->m_arMatrix.append(xform1);
		pXPData->m_arMatrix.append(xform2);
	}
}

IMPLEMENT_DYNAMIC(CSBZWDlg, CDialog)

CSBZWDlg::CSBZWDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CSBZWDlg::IDD, pParent)
	, m_sName(_T(""))
	, m_sProvider(_T("*"))
	, m_sType(_T("*"))
	, m_sRem(_T("*"))
	, m_dX(1200)
	, m_dY(800)
	, m_dZ(900)
	, m_nPos(0)
	, m_clr(256)
	, m_sNo(_T(""))
	, m_sPosNo(_T(""))
{
	m_pWEquip = new AecDbEwEquipment; 

	m_boxData.m_eType = AecEqui::kBox;
	m_boxData.m_nID = ::_time32(NULL);
	m_boxData.m_pData = new AecEqui::XBOX;
	m_boxData.m_iClr = m_clr;

	AecEqui::XBox box;
	box.dL = m_dX;
	box.dW = m_dY;
	box.dH = m_dZ;
	m_dBomEl = 0.0;
	m_sNo = IDCreate();
	::memcpy(m_boxData.m_pData, &box, sizeof(AecEqui::XBox));
	m_boxData.m_nSize = sizeof(AecEqui::XBOX);
	m_pWEquip->AddSubPrimObj(&m_boxData);

	GET_CACHE(CSBZWDlg
		, %s%s%s%s%f%f%f%f%d
		, &m_sName
		, &m_sProvider
		, &m_sType
		, &m_sRem
		, &m_dX
		, &m_dY
		, &m_dZ
		, &m_dBomEl
		, &m_nPos );
}

CSBZWDlg::CSBZWDlg(double dX, double dY, double dZ, CWnd *pParent /*=NULL*/)
	: CDialog(CSBZWDlg::IDD, pParent)
, m_sName(_T(""))
, m_sProvider(_T("*"))
, m_sType(_T("*"))
, m_sRem(_T("*"))
, m_dX(dX)
, m_dY(dY)
, m_dZ(dZ)
, m_nPos(0)
, m_clr(256)
, m_sNo(_T(""))
{
	m_pWEquip = new AecDbEwEquipment;

	m_boxData.m_eType = AecEqui::kBox;
	m_boxData.m_nID = ::_time32(NULL);
	m_boxData.m_pData = new AecEqui::XBOX;
	m_boxData.m_iClr = m_clr;

	AecEqui::XBox box;
	box.dL = m_dX;
	box.dW = m_dY;
	box.dH = m_dZ;
	m_dBomEl = 0.0;
	m_sNo = IDCreate();
	::memcpy(m_boxData.m_pData, &box, sizeof(AecEqui::XBox));
	m_boxData.m_nSize = sizeof(AecEqui::XBOX);
	m_pWEquip->AddSubPrimObj(&m_boxData);
}

CSBZWDlg::~CSBZWDlg()
{

}

void CSBZWDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT18, m_sName);
	DDX_Text(pDX, IDC_EDIT4, m_sProvider);
	DDX_Text(pDX, IDC_EDIT5, m_sType);
	DDX_Text(pDX, IDC_EDIT6, m_sRem);
	DDX_Text(pDX, IDC_EDIT1, m_dX);
	DDX_Text(pDX, IDC_EDIT2, m_dY);
	DDX_Text(pDX, IDC_EDIT3, m_dZ);
	DDX_Text(pDX, IDC_EDIT12, m_dBomEl);
	DDX_Radio(pDX, IDC_RADIO1, m_nPos);
	DDX_Text(pDX, IDC_EDIT28, m_sNo);
	DDX_Text(pDX, IDC_EDIT31, m_sPosNo);
}

BEGIN_MESSAGE_MAP(CSBZWDlg, CDialog)
	ON_BN_CLICKED(IDC_BUTTONADDNOZ, &CSBZWDlg::OnBnClickedButtonaddnoz)
	ON_BN_CLICKED(IDOK, &CSBZWDlg::OnBnClickedOk)
	ON_BN_CLICKED(IDC_STATIC_COLOR, &CSBZWDlg::OnStaticColor)
	ON_WM_CTLCOLOR()
END_MESSAGE_MAP()

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

	UpdateData(FALSE);

	return TRUE;
}

void CSBZWDlg::OnStaticColor()
{
	AcCmColor clr;
#if ARX < 24
	clr.setColorMethod(AcCmEntityColor::kByACI);
#endif
	clr.setColorIndex(256);
	if (acedSetColorDialogTrueColor(clr, Adesk::kTrue, clr, AcCm::kACITab) == Adesk::kFalse) return;
	m_clr = clr.colorIndex();
	Invalidate();
}

HBRUSH CSBZWDlg::OnCtlColor(CDC * pDC, CWnd * pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
	if (nCtlColor == CTLCOLOR_STATIC)
	{
		if (pWnd != NULL && pWnd->GetDlgCtrlID() == IDC_STATIC_COLOR)
		{
			CRect rc;
			pWnd->GetClientRect(rc);
			pDC->FillSolidRect(rc, acedGetRGB(m_clr));

		}
	}
	return hbr;
}

void CSBZWDlg::GetBoxInf(AcGeVector3d& vtDir,AcGePoint3d& ptGe,int nPos)
{
	//X,Y,Z
	switch(nPos)
	{
	case 0://底面
		{
			ptGe.set(0,0,0);
			vtDir = -AcGeVector3d::kZAxis;
			break;
		}
	case 1://顶面
		{
			ptGe.set(0,0,m_dZ);
			vtDir = AcGeVector3d::kZAxis;

			break;
		}
	case 2://左面
		{
			ptGe.set(-0.5 * m_dX,0,0.5 * m_dZ);
			vtDir = -AcGeVector3d::kXAxis;

			break;
		}
	case 3://右面
		{
			ptGe.set(0.5 * m_dX,0,0.5 * m_dZ);
			vtDir = AcGeVector3d::kXAxis;

			break;
		}
	case 4://前面
		{
			ptGe.set(0,-0.5 * m_dY,0.5 * m_dZ);
			vtDir = -AcGeVector3d::kYAxis;

			break;
		}
	case 5://后面
		{
			ptGe.set(0,0.5 * m_dY,0.5 * m_dZ);
			vtDir = AcGeVector3d::kYAxis;

			break;
		}
	default:
		break;
	}
}

void CSBZWDlg::GetInfTransform(int nPos,AcGePoint3d& ptRotation)
{
	//X,Y,Z
	switch(nPos)
	{
	case 0://底面
		{
			ptRotation.set(PI,0,0);
			break;
		}
	case 1://顶面
		{
			ptRotation.set(0,0,0);
			break;
		}
	case 2://左面
		{
			ptRotation.set(0,0,0);

			break;
		}
	case 3://右面
		{
			ptRotation.set(0,0,0);

			break;
		}
	case 4://前面
		{
			ptRotation.set(0,0,0);

			break;
		}
	case 5://后面
		{
			ptRotation.set(0,0,0);

			break;
		}
	default:
		break;
	}
}

void CSBZWDlg::OnBnClickedButtonaddnoz()
{
	UpdateData();
	
	DWORD_PTR dwSubiD = (DWORD_PTR)m_boxData.m_nID;
	m_boxData.m_nActiveInf = m_nPos;//设置活动面

	AcGeVector3d vtDir;
	AcGePoint3d ptGe;
	GetBoxInf(vtDir,ptGe,m_nPos);//计算面中心位置向量

	AcGePoint3d ptRotation;
	GetInfTransform(m_nPos,ptRotation);

	CNozzDlg nozzDlg;
	if ( IDOK == nozzDlg.DoModal() )
	{
		//偏移
		AcGeVector3d vtOff;
		vtOff.set(nozzDlg.m_dX,nozzDlg.m_dY,nozzDlg.m_dZ);
		ptGe += vtOff;

		//加入, 可以加入多个管嘴
		AecEqui::XNozz* pNozzData = nozzDlg.GetNozzData();
		Adesk::Int32 nID = AddNozz(dwSubiD,vtDir,ptGe,pNozzData, nozzDlg.m_clr);

		AecEqui::XPrimData data;
		data.m_ptRotation = ptRotation;
		m_pWEquip->ModifyPrimData(nID,data,3);
	}
}

Adesk::Int32 CSBZWDlg::AddNozz(DWORD dwSubiD, AcGeVector3d& vtDir, AcGePoint3d& ptGe, AecEqui::XNozz* pNozzData, const int &clr)
{
	//圆型管觜 接口尺寸表 DN D N C H
	// 	AecDb3dSolid* pSolid = new AecDb3dSolid;
	// 	pSolid->SetData(AecEqui::kNozz,pNozzData);
	AecEqui::XPrimData data;
	data.m_eType = AecEqui::kNozz;
	data.m_nID = ::_time32(NULL);
	data.m_iClr = clr;

	data.m_pData = new AecEqui::XNozz;
	::memcpy(data.m_pData, pNozzData, sizeof(AecEqui::XNozz));
	data.m_nSize = sizeof(AecEqui::XNozz);
	data.m_nActiveInf = -1;

	//变换
	// 	pSolid->SetActiveInfPos(0);
	// 	pSolid->MoveToInfFace(vtDir,ptGe);
	MoveToInfFace(&data, vtDir, ptGe);
	m_pWEquip->AddSubPrimObj(&data);

	return data.m_nID;
}

void CSBZWDlg::OnBnClickedOk()
{
	UpdateData();

	if (m_sName.IsEmpty() || m_sNo.IsEmpty() || m_sPosNo.IsEmpty() )
	{
		AfxMessageBox(_T("占位设备名称或编号或位号不能为空!"));
		return;
	}

	if (m_dX < 100.0 || m_dY < 100.0 || m_dZ < 100.0)
	{
		AfxMessageBox(_T("占位设备尺寸过小!,至少大于100毫米!"));
		return;
	}

	AecDbObjXDataMap* pXDataMap = m_pWEquip->GetSpecialtyData();
	pXDataMap->SetAt(KEY_NAME, m_sName);
	pXDataMap->SetAt(KEY_NO, m_sNo);
	pXDataMap->SetAt(KEY_POSNO, m_sPosNo);
	pXDataMap->SetAt(KEY_FACTORY,m_sProvider);
	pXDataMap->SetAt(KEY_TYPE,m_sType);
	pXDataMap->SetAt(KEY_REM,m_sRem);
	pXDataMap->SetAt(KEY_FITSRV, KEY_FITWPIPE);
	pXDataMap->SetAt(KEY_RUNTIME, eEquipment);
	//pWEquip->ReCreateByXDataMap();

	//设置图层
	m_pWEquip->setLayer(KTSetting::InitLayer(LAY_PIPE_OUTSIDE));
	m_pWEquip->SetDashLayer(KTSetting::InitLayer(LAY_FITN_DASH));
	m_pWEquip->SetCenterLayer(KTSetting::InitLayer(LAY_FITN_CENTER));

	AecEqui::XBox box;
	box.dL = m_dX;
	box.dW = m_dY;
	box.dH = m_dZ;
	::memcpy(m_boxData.m_pData, &box, sizeof(AecEqui::XBox));

	AecEqui::XPrimData* pData = m_pWEquip->GetSubPrimObj(0);
	if (pData != NULL)
	{
		memcpy(pData->m_pData,&box, sizeof(AecEqui::XBox));
	}

	AecEqui::XPrimData data;
	//memset(&data,0,sizeof(AecEqui::XPrimData));
	m_pWEquip->ModifyPrimData(0,data,10,FALSE);

	SET_CACHE(CSBZWDlg
		, %s%s%s%s%f%f%f%f%d
		, m_sName
		, m_sProvider
		, m_sType
		, m_sRem
		, m_dX
		, m_dY
		, m_dZ
		, m_dBomEl
		, m_nPos);

	OnOK();
}