envi-code/SourceCode/Code2026/CoreLibrary/AecDbXDormerWindow.cpp

#include "stdafx.h"
#include "AecDbXDormerWindow.h"
#include "MFCDbDwgFiler.h"
#include "dbgrip.h"
#include "dbobjptr.h"
#include "Geom.h"
#include "EarThwormDef.h"
#include "AcDbX3dSolid.h"

extern BOOL GetDocScale(double& dPScale);

ACRX_DXF_DEFINE_MEMBERS(AecDbXDormerWindow, AecDbEntityBase,
						AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
						AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
						AEC_XDORMERWIN,
						"AecDbXDormerWindow"
						"|Product Desc:     shanghua earthworm app obj"
						"|Company:          shanghua inc"
						"|WEB Address:      www.shanghuasoft.com")

Adesk::UInt32 AecDbXDormerWindow::kCurrentVersionNumber = 1;

AecDbXDormerWindow::AecDbXDormerWindow(void)
{
	m_pXDormerWindowImpl = new XDormerWindow;
}

AecDbXDormerWindow::~AecDbXDormerWindow(void)
{
	if (NULL != m_pXDormerWindowImpl)
	delete (XDormerWindow*)m_pXDormerWindowImpl;
}

//老虎窗基点
void AecDbXDormerWindow::SetDormerBase(const AcGePoint3d& ptBase)
{
	AssertWriteEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->SetDormerBase(ptBase);
	}
}

AcGePoint3d	AecDbXDormerWindow::GetDormerBase() const
{
	assertReadEnabled();
	AcGePoint3d ptGe(0,0,0);
	if (NULL != m_pXDormerWindowImpl)
	{
		ptGe = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerBase().AsAcGePoint3d();
	}
	return ptGe;
}

//老虎窗方向
void AecDbXDormerWindow::SetDormerDir(const AcGeVector3d& vtDormerDir)
{
	AssertWriteEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->SetDormerDir(vtDormerDir);

		AcGePoint3d ptOn = GetDormerBase();
		ptOn += vtDormerDir * 3.5 * 100.0;
		m_mapSpecXData.SetAt(KEY_NOPOS,ptOn);
	}
}

AcGeVector3d AecDbXDormerWindow::GetDormerDir() const
{
	assertReadEnabled();
	AcGeVector3d vtDir(1,0,0);
	if (NULL != m_pXDormerWindowImpl)
	{
		vtDir = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerDir().AsAcGeVector3d();
	}
	return vtDir;
}

//老虎窗参数
void AecDbXDormerWindow::SetDormerPar(const DormerParam& dormerPar)
{
	AssertWriteEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		XDormerPar xPar;
		xPar.SetDormerType((XDormerPar::XDormerType)dormerPar.m_dormerType);
		xPar.m_dWallHeight=dormerPar.m_dWallHeight;
		xPar.m_dWallWidth=dormerPar.m_dWallWidth;
		xPar.m_dWallThickness=dormerPar.m_dWallThickness;
		xPar.m_dSlopeGrade=dormerPar.m_dSlopeGrade;
		xPar.m_dSlopeHeight=dormerPar.m_dSlopeHeight;
		xPar.m_dSlopeThickness=dormerPar.m_dSlopeThickness;
		xPar.m_dExtendEaves=dormerPar.m_dExtendEaves;
		xPar.m_dExtendHill=dormerPar.m_dExtendHill;
		xPar.m_dWindowHeight=dormerPar.m_dWindowHeight;
		xPar.m_dWindowWidth=dormerPar.m_dWindowWidth;

		/*
		//必须外部已经创建,此处不负责创建
		m_id3DRoof = _InitLayer(_T("LAY_ROOF"));
		m_id3DFloor = _InitLayer(_T("LAY_FLOOR"));
		m_id3DWall = _InitLayer(_T("LAY_WALL"));
		m_id3DEaves = _InitLayer(_T("LAY_EAVES"));
		m_id3DGlass = _InitLayer(_T("LAY_3DGLASS"));
		m_id3DWindow = _InitLayer(_T("LAY_3DFRAME"));
		*/

		//layer
		xPar.SetRoof(dormerPar.m_sz3DRoof);
		xPar.SetFloor(dormerPar.m_sz3DFloor);
		xPar.SetWall(dormerPar.m_sz3DWall);
		xPar.SetEaves(dormerPar.m_sz3DEaves);
		xPar.SetGlass(dormerPar.m_sz3DGlass);
		xPar.SetWindow(dormerPar.m_sz3DWindow);

		((XDormerWindow*)m_pXDormerWindowImpl)->SetDormerPar( xPar );
	}
}

bool AecDbXDormerWindow::GetDormerPar(DormerParam& dormerPar) const
{
	assertReadEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		const XDormerPar& xPar = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar();
		dormerPar.m_dormerType = (DormerParam::DormerType)xPar.m_dormerType;
		dormerPar.m_dWallHeight = xPar.m_dWallHeight;
		dormerPar.m_dWallWidth = xPar.m_dWallWidth;
		dormerPar.m_dWallThickness = xPar.m_dWallThickness;
		dormerPar.m_dSlopeGrade = xPar.m_dSlopeGrade;
		dormerPar.m_dSlopeHeight = xPar.m_dSlopeHeight;
		dormerPar.m_dSlopeThickness = xPar.m_dSlopeThickness;
		dormerPar.m_dExtendEaves = xPar.m_dExtendEaves;
		dormerPar.m_dExtendHill = xPar.m_dExtendHill;
		dormerPar.m_dWindowHeight = xPar.m_dWindowHeight;
		dormerPar.m_dWindowWidth = xPar.m_dWindowWidth;

		_tcscpy(dormerPar.m_sz3DEaves,xPar.GetEavesName());
		_tcscpy(dormerPar.m_sz3DFloor,xPar.GetFloorName());
		_tcscpy(dormerPar.m_sz3DGlass,xPar.GetGlassName());
		_tcscpy(dormerPar.m_sz3DRoof,xPar.GetRoofName());
		_tcscpy(dormerPar.m_sz3DWall,xPar.GetWallName());
		_tcscpy(dormerPar.m_sz3DWindow,xPar.GetWindowName());

		return true;
	}
	return false;
}

//显示窗户
void AecDbXDormerWindow::ShowWindow(BOOL bShow/* = TRUE*/)
{
	AssertWriteEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->ShowWindow(bShow);
	}
}

BOOL AecDbXDormerWindow::IsShowWindow() const
{
	assertReadEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		return ((XDormerWindow*)m_pXDormerWindowImpl)->IsShowWindow();
	}
	return FALSE;
}

//老虎窗类型
LPCTSTR	AecDbXDormerWindow::GetDormerType() const
{
	assertReadEnabled();

	const TCHAR* sDormerType = NULL;
	if (NULL != m_pXDormerWindowImpl)
	{
		int nType = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetDormerType();
		DormerParam::DormerType eType = (DormerParam::DormerType)nType;

		switch (eType)
		{
		case DormerParam::kSLOPE_TRIANGLE:
			sDormerType = _T("三角坡");
			break;
		case DormerParam::kSLOPE_TWO:
			sDormerType = _T("双坡");
			break;
		case DormerParam::kSLOPE_THREE:
			sDormerType = _T("三坡");
			break;
		case DormerParam::kSLOPE_TRAPEZIA:
			sDormerType = _T("梯形坡");
			break;
		case DormerParam::kSLOPE_FLAT:
			sDormerType = _T("平顶窗");
			break;
		}
	}
	return sDormerType;
}

void AecDbXDormerWindow::subList() const
{
	assertReadEnabled();
	AecDbEntityBase::subList();
	acutPrintf(_T("\n老虎窗"));

	acutPrintf( _T("\n对象类型:%s"),_T("老虎窗") );
	acutPrintf( _T("\n型式:%s"),GetDormerType() );

	if (NULL != m_pXDormerWindowImpl)
	{
		int nType = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetDormerType();
		DormerParam::DormerType dormerType = (DormerParam::DormerType)nType;

		if (dormerType != DormerParam::kSLOPE_FLAT)
		{
			acutPrintf(_T("\n坡度:%.2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetSlopeGrade());
			acutPrintf(_T("\n坡顶高:%.2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetSlopeHeight());
		}

		acutPrintf(_T("\n檐板厚:%.2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetSlopeThickness());
		if (dormerType != DormerParam::kSLOPE_TRIANGLE)
		{
			acutPrintf(_T("\n出檐长:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetExtendEaves());
		}

		acutPrintf(_T("\n出山长:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetExtendHill());
		acutPrintf(_T("\n墙高:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetWallHeight());
		acutPrintf(_T("\n墙宽:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetWallWidth());
		acutPrintf(_T("\n墙厚:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetWallThickness());

		if (IsShowWindow())
		{
			acutPrintf(_T("\n窗高:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetWindowHeight());
			acutPrintf(_T("\n窗宽:%2f"), ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerPar().GetWindowWidth());
		}
	}
}

Acad::ErrorStatus AecDbXDormerWindow::copyFrom(const AcRxObject* pSrc)
{
	assertWriteEnabled();
	if (pSrc != NULL)
	{
		AecDbXDormerWindow* pXDWin = AecDbXDormerWindow::cast(pSrc);
		if (pXDWin != NULL)
		{
			DormerParam dormerPar;
			pXDWin->GetDormerPar(dormerPar);

			SetDormerPar(dormerPar);

			SetDormerDir(pXDWin->GetDormerDir());

			SetDormerBase(pXDWin->GetDormerBase());

			ShowWindow(pXDWin->IsShowWindow());

			m_mapSpecXData.CopyFrom(&pXDWin->m_mapSpecXData);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();
	//同步
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->transformBy(xform);

		AcGePoint3d ptOn;
		if ( m_mapSpecXData.GetAt(KEY_NOPOS,ptOn) )
		{
			ptOn.transformBy(xform);
			m_mapSpecXData.SetAt(KEY_NOPOS,ptOn);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::subGetGripPoints (AcGePoint3dArray&  gripPoints,AcDbIntArray&  osnapModes,AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->getGripPoints(gripPoints,osnapModes,geomIds);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::subGetGripPoints( AcDbGripDataPtrArray& grips,
								   const double curViewUnitSize,
								   const int gripSize,
								   const AcGeVector3d& curViewDir,
								   const int bitflags) const
{
	assertReadEnabled();
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXDormerWindow::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbXDormerWindow::subMoveGripPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	AssertWriteEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->moveGripPointsAt(indices,offset);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		AcGePoint3d ptPos = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerBase().AsAcGePoint3d();
		stretchPoints.append(ptPos);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	AssertWriteEnabled();
	if (!indices.isEmpty() && m_pXDormerWindowImpl != NULL)
	{
		AcGePoint3d ptPos = ((XDormerWindow*)m_pXDormerWindowImpl)->GetDormerBase().AsAcGePoint3d();
		ptPos += offset;
		((XDormerWindow*)m_pXDormerWindowImpl)->SetDormerBase(ptPos);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgInFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be read first
	Adesk::UInt32 version =0 ;
	if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
		return (es) ;

	if ( version > AecDbXDormerWindow::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->dwgInFields(pFiler);
	}

	m_mapSpecXData.dwgInFields(pFiler);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgOutFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be saved first
	if ( (es =pFiler->writeUInt32 (AecDbXDormerWindow::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	if (NULL != m_pXDormerWindowImpl)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->dwgOutFields(pFiler);
	}

	m_mapSpecXData.dwgOutFields(pFiler);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

BOOL AecDbXDormerWindow::IsValid() const
{
	assertReadEnabled();
	if (NULL != m_pXDormerWindowImpl)
	{
		return ((XDormerWindow*)m_pXDormerWindowImpl)->IsValid();
	}
	return FALSE;
}

Acad::ErrorStatus AecDbXDormerWindow::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();
	if (!IsValid())
		return Acad::eNotApplicable;

	//管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	AcDbObjectId idCurLay = dc.GetLayerId();
	Adesk::UInt16 nCrBk = dc.GetColor();

	dc.SetLayer(layerId());
	dc.SetColor(colorIndex());
	if (Has2DBuffer())
	{
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar2D = Get2DBuffer();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);
			pEnt->setLayer(layerId());
			pEnt->setColorIndex(colorIndex());
			dc.DrawEntity(*pEnt);
		}
		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);

		return Acad::eOk;
	}

	XDraw xDc;
	if (m_pXDormerWindowImpl != NULL)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->Draw2d(xDc);

		AcDbVoidPtrArray entSet;
		xDc.GetDraw(entSet);

		AcDbEntity* pEnt = NULL;
		for (int i = 0;i < entSet.length();i++)
		{
			pEnt = (AcDbEntity*)entSet.at(i);
			pEnt->setLayer(layerId());
			pEnt->setColorIndex(colorIndex());
			dc.DrawEntity(pEnt);
			Add2DBuffer(pEnt);
		}
	}

	//绘制编号
	CString sLable = GetLabel();
	sLable.TrimRight(_T(" "));
	if (!sLable.IsEmpty() && sLable.CompareNoCase(_T("No")) != 0 )
	{
		if ( sLable.GetLength() < 36)//<IDCreate
			DrawLabel(dc,sLable);
	}

	dc.SetColor(nCrBk);
	dc.SetLayer(idCurLay);

	return Acad::eOk;
}

CString AecDbXDormerWindow::GetLabel() const
{
	assertReadEnabled();

	CString sLab;
	m_mapSpecXData.GetAt(KEY_NO,sLab);
	return sLab;
}

Acad::ErrorStatus AecDbXDormerWindow::DrawLabel(AcGiDraw &dc,LPCTSTR pszLab) const
{
	BOOL bHideNo = FALSE;
	m_mapSpecXData.GetAt(KEY_HIDENO,bHideNo);
	if (bHideNo)
		return Acad::eOk;

	AcDbObjectId id = acdbCurDwg()->textstyle();

	AcDbText* pText = new AcDbText;
	pText->setTextStyle(id);
	pText->setLayer(layerId());
	pText->setWidthFactor(0.75);
	double dScale = 100.0;
	GetDocScale(dScale);
	pText->setHeight(2.5 * dScale);
	pText->setTextString(pszLab);

	AcGePoint3d ptOn;
	m_mapSpecXData.GetAt(KEY_NOPOS,ptOn);
	pText->setPosition(ptOn);
	pText->setHorizontalMode(AcDb::kTextCenter);
	pText->setAlignmentPoint(ptOn);

	dc.DrawEntity(*pText);
	Add2DBuffer(pText);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbXDormerWindow::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	if (!IsValid())
		return Acad::eNotApplicable;

	//管线系统屏蔽掉
	if ( dc.IsDragging() )
	{
		//return Acad::eOk;
	}

	//图层
	AcDbObjectId idLay = dc.GetLayerId();
	dc.SetLayer(layerId());

	int nCrBk = dc.GetColor();

	if (Has3DBuffer())
	{
		//Clean3DBuffer();
		AcDbEntity* pEnt = NULL;
		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			dc.SetLayer(pEnt->layerId());
			dc.SetColor(pEnt->colorIndex());
			dc.DrawEntity(*pEnt);
		}
		dc.SetLayer(idLay);
		dc.SetColor(nCrBk);
		return Acad::eOk;
	}

	XDraw xDc;
	if (m_pXDormerWindowImpl != NULL)
	{
		((XDormerWindow*)m_pXDormerWindowImpl)->Draw3d(xDc);

		AcDbVoidPtrArray entSet;
		xDc.GetDraw(entSet);

		//DrawEntsToSolid(dc,entSet);

		AcDbEntity* pEnt = NULL;
		for (int i = 0;i < entSet.length();i++)
		{
			pEnt = (AcDbEntity*)entSet.at(i);

			dc.SetLayer(pEnt->layerId());
			dc.SetColor(pEnt->colorIndex());

			dc.DrawEntity(pEnt);
			Add3DBuffer(pEnt);
		}
	}

	dc.SetLayer(idLay);
	dc.SetColor(nCrBk);

	return Acad::eOk;
}

extern AcDb3dSolid* FaceToSolid(AcDbFace* pFace, std::vector<AcDbX3dSolid *> *pSos = NULL);
extern AcDb3dSolid* SubDMeshToSolid(AcDbSubDMesh* pSDMesh, std::vector<AcDbX3dSolid*> *pSos = NULL);
Acad::ErrorStatus AecDbXDormerWindow::DrawEntsToSolid(AcGiDraw& dc,AcDbVoidPtrArray& arEntPtrs) const
{
	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;
	for (int i = 0;i < arEntPtrs.length();i++)
	{
		pEnt = (AcDbEntity*)arEntPtrs.at(i);

		//Face,SubMesh To Solid !!!
		AcDbFace* pFace = AcDbFace::cast(pEnt);
		if (pFace != NULL)
		{
			pSolid = FaceToSolid(pFace);
			if (pSolid != NULL)
			{
				pSolid->setLayer(pEnt->layerId());
				pSolid->setColorIndex(pEnt->colorIndex());

				dc.SetLayer(pEnt->layerId());
				dc.SetColor(pEnt->colorIndex());

				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
		}

		AcDbSubDMesh* pSDMesh = AcDbSubDMesh::cast(pEnt);
		if (pSDMesh != NULL)
		{
			pSolid = SubDMeshToSolid(pSDMesh);
			if (pSolid != NULL)
			{
				pSolid->setLayer(pEnt->layerId());
				pSolid->setColorIndex(pEnt->colorIndex());

				dc.SetLayer(pEnt->layerId());
				dc.SetColor(pEnt->colorIndex());

				dc.DrawEntity(pSolid);
				Add3DBuffer(pSolid);
			}
		}
		if (pEnt != NULL) delete pEnt;
	}
	return Acad::eOk;
}

AecDbObjXDataMap* AecDbXDormerWindow::GetSpecialtyData(AcDb::OpenMode bMode/* = AcDb::kForWrite*/)
{
	switch(bMode)
	{
	case AcDb::kForRead:
		{
			assertReadEnabled();
			break;
		}
	case AcDb::kForWrite:
		{
			if (!isWriteEnabled())
			{
				upgradeOpen();
			}
			assertWriteEnabled();
			break;
		}
	case AcDb::kForNotify:
		{
			if (!isWriteEnabled())
			{
				upgradeOpen();
			}
		}
	default:
		break;
	}
	return &m_mapSpecXData;
}

const AecDbObjXDataMap* AecDbXDormerWindow::GetSpecialtyData() const
{
	assertReadEnabled();
	return &m_mapSpecXData;
}