#include "stdafx.h"
#include "DbFireExtinguisher.h"
#include "globalFunc.h"
#include "GeCurveInline.h"
#include "AecDbText.h"
#include "pushproperty.h"

ACRX_DXF_DEFINE_MEMBERS(CDbFireExtinguisher, AecXDbEntityBaseEx, AcDb::kDHL_CURRENT,
                        AcDb::kMReleaseCurrent, 1, AEC_ZT_FIRE_EXTINGUISHER,
						"AEC_ZT_FIRE_EXTINGUISHER, 请下载上华软件|网址: www.shanghuasoft.com");

// 图块大小
void GetBlkSize(const AcDbObjectId &idBlk, const AcGeScale3d &scale, double &dWidth, double &dHeight)
{
	AcGePoint3d ptIns = AcGePoint3d::kOrigin;
	AcDbBlockReference blkRef(ptIns, idBlk);
	blkRef.setScaleFactors(scale);
	AcDbExtents extent;
	blkRef.getGeomExtents(extent);
	AcGePoint3d ptMin = extent.minPoint();
	AcGePoint3d ptMax = extent.maxPoint();
	dWidth = ptMax.x - ptMin.x;
	dHeight = ptMax.y - ptMin.y;
}

bool GetBlkSize(const CString &sBlkName, const AcGeScale3d &scale, double &dWidth, double &dHeight)
{
	AcDbObjectId idBlk = GlobalFunc::GetBlockIdFromString(sBlkName);
	if (idBlk.isNull())
	{
		// 加载灭火器图块
		CString sDwbPath = g_csDwbPath;
		CString sDwb = sDwbPath + _T("TwtSys");
		CString sBlkNum;
		int nIndex = sBlkName.ReverseFind(_T('$'));
		if (nIndex != -1)
		{
			int nSize = sBlkName.GetLength();
			sBlkNum = sBlkName.Right(nSize - nIndex - 1);
		}
		XString xsTmp;
		if(GlobalFunc::LoadDwbBlock(sDwb, sBlkNum, xsTmp) != RTNORM)
		{
			return false;
		}
		
		// 重新获取图块id
		idBlk = GlobalFunc::GetBlockIdFromString(sBlkName);
		if (idBlk.isNull())
		{
			return false;
		}
	}
	GetBlkSize(idBlk, scale, dWidth, dHeight);
	return true;
}

CDbFireExtinguisher::CDbFireExtinguisher()
{
	m_bUp = true;
	m_nLayType = 0;
	m_dProtectRadius = 0.0;
	m_dScale = 1;
	m_nMirror = 0;
}


Acad::ErrorStatus
CDbFireExtinguisher::GetGripText(int idx, CString &cs) const
{
    Acad::ErrorStatus es = Acad::eOk;
    switch(idx)	{
    case 0:	cs=_T("移动灭火器"); break;
    case 1:	cs=_T("移动标注"); break;
    default: es=Acad::eInvalidInput;
    }
    return es;
}

Acad::ErrorStatus 
CDbFireExtinguisher::subGetGripPoints(AcGePoint3dArray& gripPoints,
                            AcDbIntArray&  osnapModes,
                            AcDbIntArray&  geomIds) const
{
    assertReadEnabled();
    Acad::ErrorStatus es=Acad::eOk;
    gripPoints.append((AcGePoint3d)m_ptLocation);
    gripPoints.append((AcGePoint3d)m_ptLabel);
    return es;
}

Acad::ErrorStatus 
CDbFireExtinguisher::subMoveGripPointsAt(const AcDbIntArray& indices,
                               const AcGeVector3d& offset)
{
    assertWriteEnabled();
    Acad::ErrorStatus es=Acad::eOk;
	AcGeMatrix3d mat;
	mat.setToTranslation(offset);
	for(int i=0; i<indices.length();i++)
	{
		int index=indices[i];
		if(index == 0)
		{
			m_ptLocation.TransformBy(mat);
			m_ptLabel.transformBy(mat);
		}
		else if (index == 1)
		{
			m_ptLabel.transformBy(mat);
		}
	}
    return es;
}

Acad::ErrorStatus CDbFireExtinguisher::Draw2d( AcGiDraw &dc ) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	Acad::ErrorStatus st = Acad::eOk;	
	// 灭火器数量
	if (m_nNum <= 0)
	{
		return st;
	}

	// 灭火器大小
	double dScale = m_dScale;
	if (m_nScaleType == 0)
	{
		dScale *= (GetPScale() / 100);
	}
	AcGeScale3d scale(dScale);
	double dWidth = 0.0, dHeight = 0.0;
	GetBlkSize(m_idBlock2d, scale, dWidth, dHeight);
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	//插入点
	AcGePoint3dArray arrPts;
	if (m_nLayType == 0) // 按数量进行布置并标注规格
	{
		// 图块出入点
		int nMod = m_nNum % 2;
		if (nMod == 1) // 奇数个灭火器
		{
			arrPts.append(m_ptLocation);
		}

		int nNum = m_nNum;
		nNum /= 2;
		vtDir.rotateBy(GetAngle(), AcGeVector3d::kZAxis);
		double dDist = 0.0;
		for (int i = 0; i < nNum; ++i)
		{
			if (i == 0 && nMod == 0)
			{
				dDist += dWidth * 0.5;
			} 
			else
			{
				dDist += dWidth;
			}
			arrPts.append(m_ptLocation + vtDir * dDist);
			arrPts.append(m_ptLocation - vtDir * dDist);
		}
	}
	else // 单布标注数量与规格
	{
		arrPts.append(m_ptLocation);
	}

	int nLen = arrPts.length();
	for (int j = 0; j < nLen; ++j)
	{
		CDbEquipment pEquip;
		pEquip.SetBlock2d(m_idBlock2d);
		pEquip.SetLocation(arrPts[j]);
		pEquip.SetInsert(arrPts[j]);
		pEquip.SetAngle(GetAngle());
		pEquip.SetScale(dScale);
		pEquip.setPropertiesFrom(this);
		pEquip.SetAutoScale(false);
		pEquip.MirrorByX(IsMirrorByX());
		pEquip.MirrorByY(IsMirrorByY());
		//if(dc.IsFullExplode()) 
		//	pEquip.ExplodeOrDraw2d(dc);
		//else
			dc.DrawEntity(pEquip);

		double dRadius = m_dProtectRadius;
		if (!GlobalFunc::DocGetCurMeterUnitDraw())
		{
			dRadius *= 1000;
		}
		
		if (id() == NULL)
		{
			//dc << XCircle(XPoint(arrPts[j]), dRadius);
			dc.DrawCircle(arrPts[j], dRadius, AcGeVector3d::kZAxis);
		}
	}

	// 添加文字
	if (m_bDim)
	{
		CString sText, sSpec = (LPCTSTR)m_sSpec;
		// 剔除规格中的注视文字
		int nDel = sSpec.Find(_T("("));
		if (nDel != -1)
		{
			sSpec = sSpec.Left(nDel);
		}
		
		if (m_nLayType == 0) // 按数量布置
		{
			sText = sSpec;
		}
		else  // 单布
		{
//			cet 2014.7.23 modify 单布时根据文字格式类型确定标注文字
// 			sText.Format(_T("%d-"), m_nNum);
// 			sText += sSpec;
			sText = GetDimText();
		}
		AecXDbText text;
		text.setPropertiesFrom(this);
		text.setLayer(m_idTextLayer);	
		text.SetStyleId(m_idTextStyle);
		text.SetText((const TCHAR*)sText);
		text.SetLocation(m_ptLabel);
		text.SetPScale(GetPScale());
		text.SetHeight(m_dTextHeight);
		
		text.SetRotation(m_dTextAngle);
		text.SetAlignment(m_align);
		AcDbObjectId idLayerOld=dc.GetLayerId();
		if(m_idTextLayer.isValid())
			dc.SetLayer(m_idTextLayer);

		PushProperty vProp(&text, dc);
		//if(dc.IsFullExplode()) 
		//{
		//	text.ExplodeOrDraw2d(dc);
		//}
		//else
		{
			dc.DrawEntity(text);
		}
		dc.SetLayer(idLayerOld);
	}
	return st;
}

void CDbFireExtinguisher::SetLabelLoc(AcGePoint3d pt)
{
	assertWriteEnabled();
	m_ptLabel = pt;
}

void CDbFireExtinguisher::SetTextLayer(AcDbObjectId id)
{
	m_idTextLayer = id;
}

void CDbFireExtinguisher::SetDimTextPos( bool bUp /*= true*/ )
{
	assertWriteEnabled();
	m_bUp = bUp;
}

void CDbFireExtinguisher::SetLayType( int nLayType )
{
	m_nLayType = nLayType;
}

void CDbFireExtinguisher::SetProtectRadius( double dRadius )
{
	assertWriteEnabled();
	m_dProtectRadius = dRadius;
}

void CDbFireExtinguisher::SetTextHeight( double dHeight )
{
	assertWriteEnabled();
	m_dTextHeight = dHeight;
}

// 文字样式
void CDbFireExtinguisher::SetTextStyleId(AcDbObjectId id)
{
	assertWriteEnabled();
	m_idTextStyle = id;
}
// 灭火器数量
void CDbFireExtinguisher::SetNum(int nNum)
{
	assertWriteEnabled();
	m_nNum = nNum;
}
void CDbFireExtinguisher::SetIsDim(bool bDim)
{
	assertWriteEnabled();
	m_bDim = bDim;
}
// 规格
void CDbFireExtinguisher::SetSpec(CString sSpec)
{
	assertWriteEnabled();
	m_sSpec = sSpec;
}
void CDbFireExtinguisher::SetGrade(CString sGrade)
{
	assertWriteEnabled();
	m_sGrade = sGrade;
}

void CDbFireExtinguisher::SetScaleType(int nType)
{
	assertWriteEnabled();
	m_nScaleType = nType;
}

void CDbFireExtinguisher::SetTextRotation(double dAngle)
{
	assertWriteEnabled();
	m_dTextAngle = dAngle;
}
void CDbFireExtinguisher::SetTextAlignment(AcGiViewDraw::TextAlignment align)
{
	assertWriteEnabled();
	m_align = align;
}

void CDbFireExtinguisher::CopyPropertiesFrom(AcDbEntity *pSrc,unsigned gMatchFlag)
{
    assertWriteEnabled();
	CDbFireExtinguisher *pSect = CDbFireExtinguisher::cast(pSrc);
    if(pSect != NULL) 
	{		
		m_bUp = pSect->m_bUp;			
		m_dTextHeight = pSect->m_dTextHeight;	
		m_idTextStyle = pSect->m_idTextStyle;	
		m_nLayType = pSect->m_nLayType;		
		m_dProtectRadius = pSect->m_dProtectRadius;
		m_nNum = pSect->m_nNum;				
		m_bDim = pSect->m_bDim;			
		m_sSpec = pSect->m_sSpec;		
		m_sGrade = pSect->m_sGrade;		
		m_nScaleType = pSect->m_nScaleType;		
    }
	AecXDbEntityBaseEx::CopyPropertiesFrom(pSrc, gMatchFlag);
}

// 从DWG读入数据:
Acad::ErrorStatus CDbFireExtinguisher::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();
	Acad::ErrorStatus es = AecXDbEntityBaseEx::dwgInFields(pFiler);
	if(es != Acad::eOk) return es;
    GlobalFunc::ReadString(pFiler, m_sSpec);
	GlobalFunc::ReadString(pFiler, m_sGrade);
	pFiler->readItem(&m_ptLabel);
    pFiler->readItem(&m_bUp);
    pFiler->readItem(&m_dTextHeight);
    pFiler->readItem(&m_nLayType);
    pFiler->readItem(&m_dProtectRadius);
    pFiler->readItem(&m_nNum);
    pFiler->readItem(&m_bDim);
	pFiler->readItem(&m_nScaleType);
	pFiler->readItem(&m_idTextLayer);
	pFiler->readItem(&m_idTextStyle);
	pFiler->readItem(&m_dTextAngle);
	Adesk::Int16 nAlign = 0;
	pFiler->readItem(&nAlign);
	m_align = (AcGiViewDraw::TextAlignment)nAlign;
	pFiler->readItem((AcGePoint3d *)&m_ptLocation);
	pFiler->readItem(&m_dScale);
	pFiler->readItem(&m_idBlock2d);
	pFiler->readItem((AcGeVector3d *)&m_vtDirection);
	pFiler->readItem(&m_nMirror);
    return pFiler->filerStatus();
}

Acad::ErrorStatus CDbFireExtinguisher::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();
	Acad::ErrorStatus es = AecXDbEntityBaseEx::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
    pFiler->writeItem((const TCHAR *)m_sSpec);
	pFiler->writeItem((const TCHAR *)m_sGrade);
	pFiler->writeItem(m_ptLabel);
    pFiler->writeItem(m_bUp);
    pFiler->writeItem(m_dTextHeight);
    pFiler->writeItem(m_nLayType);
    pFiler->writeItem(m_dProtectRadius);
    pFiler->writeItem(m_nNum);
    pFiler->writeItem(m_bDim);
	pFiler->writeItem(m_nScaleType);
	pFiler->writeItem(m_idTextLayer);
	pFiler->writeItem(m_idTextStyle);
	pFiler->writeItem(m_dTextAngle);
	Adesk::Int16 nAlign = (int)m_align;
	pFiler->writeItem(nAlign);
	pFiler->writeItem((const AcGePoint3d &)m_ptLocation);
	pFiler->writeItem(m_dScale);
	pFiler->writeItem(m_idBlock2d);
	pFiler->writeItem((const AcGeVector3d &)m_vtDirection);
	pFiler->writeItem(m_nMirror);
    return pFiler->filerStatus();
}

Acad::ErrorStatus CDbFireExtinguisher::dxfInFields(AcDbDxfFiler* pFiler)
{
    return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CDbFireExtinguisher::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    return Acad::eNotImplementedYet;
}

Acad::ErrorStatus CDbFireExtinguisher::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	((AcGeVector3d &)m_vtDirection).transformBy(xform);
	m_ptLocation.TransformBy(xform);
	m_ptLabel.transformBy(xform);
	if (GlobalFunc::IsMirrorMatrix(xform))
	{
		MirrorByX(!IsMirrorByX());
	}
	double dAngle = GetAngle();
	m_dTextAngle = dAngle;
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(dAngle, AcGeVector3d::kZAxis);
	vtDir.normalize();
	AcGeVector3d vtLab = m_ptLabel - (AcGePoint3d)m_ptLocation;
	vtLab.normalize();
	// 旋转时调整文字角度
	if (GlobalFunc::Wcs2Ucs(dAngle) > 2 * PI / 3 && GlobalFunc::Wcs2Ucs(dAngle) < 5 * PI / 3)
	{
		m_dTextAngle += PI;
		if (m_nLayType == 1)
		{
			m_align = AcGiViewDraw::kTopRight;
			if (vtLab != vtDir)
			{
				m_align = AcGiViewDraw::kTopLeft;
			}
		}
		else
		{
			m_align = AcGiViewDraw::kTopCenter;
		}
	}
	else
	{
		if (m_nLayType == 1)
		{
			m_align = AcGiViewDraw::kBottomLeft;
			if (vtLab != vtDir)
			{
				m_align = AcGiViewDraw::kBottomRight;
			}
		}
		else
		{
			m_align = AcGiViewDraw::kBottomCenter;
		}
	}
	// 镜像时调整文字角度
	if (IsMirrorByX())
	{
		if (m_nLayType == 0)
		{
			if (GlobalFunc::Wcs2Ucs(dAngle) > 2 * PI / 3 && GlobalFunc::Wcs2Ucs(dAngle) < 5 * PI / 3)
			{
				m_align = AcGiViewDraw::kBottomCenter;
			}
			else
			{
				m_align = AcGiViewDraw::kTopCenter;
			}
		}
		else
		{
			if (GlobalFunc::Wcs2Ucs(dAngle) > 2 * PI / 3 && GlobalFunc::Wcs2Ucs(dAngle) < 5 * PI / 3)
			{
				m_align = AcGiViewDraw::kBottomRight;
				if (vtLab != vtDir)
				{
					m_align = AcGiViewDraw::kBottomLeft;
				}
			}
			else
			{
				m_align = AcGiViewDraw::kTopLeft;
				if (vtLab != vtDir)
				{
					m_align = AcGiViewDraw::kTopRight;
				}
			}
		}
	}
    return Acad::eOk;
}

int CDbFireExtinguisher::GetTextFormatType() const
{
	assertReadEnabled();
	const EntityFields &fd = GetFields();
	Adesk::Int8 nType = 0;
	fd.GFD(_T("TEXT_FORMAT_TYPE"), nType);
	return static_cast<int>(nType);
}

void CDbFireExtinguisher::SetTextFormatType(int nType)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("TEXT_FORMAT_TYPE"), static_cast<Adesk::Int8>(nType));
}

CString CDbFireExtinguisher::GetDimText() const
{
	CString sSpec = (LPCTSTR)m_sSpec;
	// 剔除规格中的注释文字
	int nDel = sSpec.Find(_T("("));
	if (nDel != -1)
	{
		sSpec = sSpec.Left(nDel);
	}

	CString sText;
	switch(GetTextFormatType())
	{
	case 0:
		{
			sText.Format(_T("%d-%s"), m_nNum, sSpec);
			break;
		}
	case 1:
		{
			sText.Format(_T("%s×%d"), sSpec, m_nNum);
			break;
		}
	}
	return sText;
}

void CDbFireExtinguisher::MirrorByX(BOOL bFlag)
{
	assertWriteEnabled();
	if(bFlag)
		m_nMirror |= MIRROR_XAXIS;
	else 
		m_nMirror &= ~MIRROR_XAXIS;
}

void CDbFireExtinguisher::MirrorByY(BOOL bFlag)
{
	assertWriteEnabled();
	if(bFlag)
		m_nMirror |= MIRROR_YAXIS;
	else 
		m_nMirror &= ~MIRROR_YAXIS;
}