#include "stdafx.h"
#ifdef TASD
#include "TDbStruReinBar.h"

const Adesk::UInt8 TDbStruReinBar::g_nVersion = 1;

IMPLEMENT_TENTBASE(TDbStruReinBar);
ACRX_DXF_DEFINE_MEMBERS(ATSStruReinBar, ATSStruEntityBase, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent, 1, ATS_STRUREINBAR,
						"ATS_STRUREINBAR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");

TDbStruReinBar::TDbStruReinBar()
{
	TDbStruEntityBase::SetAt(KEY_KIND, (int)TDbStruReinBar::kNormal);
	SetStartHook(TStruHookInfo::kNone, 1);
	SetEndHook(TStruHookInfo::kNone, 2);
	m_dWidth = g_dReinbarWidth;
	m_dLengthS = g_dReinbarLenS;
	m_dLengthO = g_dReinbarLenO;
	m_dLengthB = g_dReinbarLenB;
	m_dDiaB = g_dReinbarDiaB;
}

TDbStruReinBar::~TDbStruReinBar()
{

}

Acad::ErrorStatus TDbStruReinBar::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;
	es = TDbStruEntityBase::dwgInFields(pFiler);
	if (Acad::eOk != es)
	{
		return es;
	}
	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer>g_nVersion) 
	{
		return Acad::eMakeMeProxy;
	}	
	pFiler->readItem(&m_dWidth);
	pFiler->readItem(&m_dLengthS);
	pFiler->readItem(&m_dLengthO);
	pFiler->readItem(&m_dLengthB);
	pFiler->readItem(&m_dDiaB);
	ReadPoly2D(pFiler, m_polyOutline);

	return es;
}

Acad::ErrorStatus TDbStruReinBar::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es;
	es = TDbStruEntityBase::dwgOutFields(pFiler);
	if (Acad::eOk != es)
	{
		return es;
	}
	pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_dWidth);
	pFiler->writeItem(m_dLengthS);
	pFiler->writeItem(m_dLengthO);
	pFiler->writeItem(m_dLengthB);
	pFiler->writeItem(m_dDiaB);
	WritePoly2D(pFiler, m_polyOutline);

	return es;
}

Acad::ErrorStatus TDbStruReinBar::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	return TDbStruEntityBase::dxfInFields(pFiler);
}
Acad::ErrorStatus TDbStruReinBar::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	return TDbStruEntityBase::dxfOutFields(pFiler);
}

Acad::ErrorStatus TDbStruReinBar::GetGripText(int i, CString &cs) const
{
	if (i >= 0 &&
		i <= m_polyOutline.Length()-1)
	{
		cs = _T("移动钢筋对象或移动该路径点");
	}
	else
	{
		cs = _T("更改钩子方向");
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::ExplodeOrDraw2d(TGGiExplodeDrawBase &dc) const
{
	assertReadEnabled();

	// 钢筋类别-点钢筋
	EType type;
	if (TDbStruEntityBase::GetAt(KEY_KIND, (int&)type) &&
		type == kDot)
	{
		if (m_polyOutline.Length() >=1 )
		{
			AcGePoint3d ptCenter = m_polyOutline.GetPointListAt(0);
			AcGePoint3d ptSolid1(ptCenter[X]-m_dWidth/2, ptCenter[Y], 0);
			AcGePoint3d ptSolid2(ptCenter[X]+m_dWidth/2, ptCenter[Y], 0);
			TGGePoly2D poly, polyDisperse;
			poly.InsertNodeAt(0, ptSolid1, PI);
			poly.InsertNodeAt(1, ptSolid2, PI);
			poly.InsertNodeAt(2, ptSolid1);
			poly.SetClosed();
			poly.Disperse(polyDisperse);
			dc << TGGeSolid(polyDisperse);
		}

		return Acad::eOk;
	}
	
	// 钢筋类别-普通钢筋
	// 钢筋
	AcDbPolyline plBar;
	for (int i=0; i<m_polyOutline.Length(); i++)
	{
		plBar.addVertexAt(i, m_polyOutline.GetPointListAt(i), 
			tan(m_polyOutline.GetBulge(i)/4), m_dWidth, m_dWidth);
	}

	// 起始端钩子
	AcDbPolyline  plHook;
	TStruHookInfo hook;
	BOOL bRet;
	double dBulge = 0;
	bool bBent = false;
	bRet = GetAt(KEY_HOOKS, hook);
	if (bRet && 
		GetHookOutLine(hook, plHook))
	{
		if (hook.eType == TStruHookInfo::kBent)
		{
			bBent = true;
		}
		AcGePoint3d ptTemp;
		for (UINT j=1; j<plHook.numVerts(); j++)
		{
			plHook.getPointAt(j, ptTemp);
			if(j==1 && bBent)
			{
				if (hook.nQuadrant == 1 || hook.nQuadrant ==3)
				{
					dBulge = PI*0.25;
				}
				else
				{
					dBulge = -PI*0.25;
				}
			}
			else
			{
				dBulge = 0;
			}
			plBar.addVertexAt(0, AcGePoint2d(ptTemp[X], ptTemp[Y]), 
				dBulge, m_dWidth, m_dWidth);
		}
	}
	
	// 终止端钩子
	bRet = GetAt(KEY_HOOKE, hook);
	if (bRet && 
		GetHookOutLine(hook, plHook))
	{
		AcGePoint3d ptTemp;	

		// 修改路径最后一个点的凸度
		if (hook.eType == TStruHookInfo::kBent)
		{
			if (hook.nQuadrant == 1 || hook.nQuadrant ==3)
			{
				dBulge = -PI*0.25;
			}
			else
			{
				dBulge = PI*0.25;
			}
		}
		else 
		{
			dBulge = 0;
		}
		plBar.setBulgeAt(plBar.numVerts()-1, dBulge);
		
		for (UINT j=1; j<plHook.numVerts(); j++)
		{
			plHook.getPointAt(j, ptTemp);
			plBar.addVertexAt(plBar.numVerts(), AcGePoint2d(ptTemp[X], ptTemp[Y]), 
				0, m_dWidth, m_dWidth);
		}
	}
	dc.DrawEntity(plBar);

	// 中间钩子
	CArray<TStruHookInfo, TStruHookInfo&> arHooks;
	if (GetAt(KEY_HOOK, arHooks))
	{
		for (int j=0; j<arHooks.GetSize(); j++)
		{
			GetHookOutLine(arHooks[j], plHook);
			dc.DrawEntity(plHook);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::ExplodeOrDraw3d(TGGiExplodeDrawBase &dc) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus TDbStruReinBar::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	// 钢筋路径
	m_polyOutline.TransformBy(xform);

	EType eType;
	if (TDbStruEntityBase::GetAt(KEY_KIND, (int&)eType) && 
		eType == kNormal)
	{
		// 起始端钩子
		TStruHookInfo hook;
		if (GetAt(KEY_HOOKS, hook))
		{
			hook.ptPos.transformBy(xform);
			SetAt(KEY_HOOKS, hook);
		}

		// 终止端钩子
		if (GetAt(KEY_HOOKE, hook))
		{
			hook.ptPos.transformBy(xform);
			SetAt(KEY_HOOKE, hook);
		}

		// 中间钩子
		CArray<TStruHookInfo, TStruHookInfo&> arHooks;
		if (GetAt(KEY_HOOK, arHooks))
		{
			for (int i=0; i<arHooks.GetSize(); i++)
			{
				arHooks[i].ptPos.transformBy(xform);
			}
			SetAt(KEY_HOOK, arHooks);
		}
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::subGetGripPoints(AcGePoint3dArray& gripPoints,
											       AcDbIntArray&	 osnapModes,
										           AcDbIntArray&	 geomIds) const
{
	assertReadEnabled();
	// 点钢筋
	EType type;
	if (TDbStruEntityBase::GetAt(KEY_KIND, (int&)type) &&
		type == kDot)
	{
		if (m_polyOutline.Length() >= 1)
		{
			gripPoints.append(m_polyOutline.GetPointListAt(0));
		}

		return Acad::eOk;
	}

	// 普通钢筋
	// 钢筋路径
	for (int i=0; i<m_polyOutline.Length(); i++)
	{
		gripPoints.append(m_polyOutline.GetPointListAt(i));
	}

	// 起始端钩子
	TStruHookInfo hook;
	if (GetAt(KEY_HOOKS, hook) &&
		hook.eType != TStruHookInfo::kNone)
	{
		gripPoints.append(GetGripPoint(hook));
	}

	// 终止端钩子
	if (GetAt(KEY_HOOKE, hook) &&
		hook.eType != TStruHookInfo::kNone)
	{
		gripPoints.append(GetGripPoint(hook));
	}

	// 中间钩子
	CArray<TStruHookInfo, TStruHookInfo&> arHooks;
	if (GetAt(KEY_HOOK, arHooks))
	{
		for (int i=0; i<arHooks.GetSize(); i++)
		{
			if (arHooks[i].eType != TStruHookInfo::kNone)
			{
				gripPoints.append(GetGripPoint(arHooks[i]));
			}
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::subMoveGripPointsAt(const AcDbIntArray& indices,
									                  const AcGeVector3d& offset)
{
	assertWriteEnabled();
	for (int i=0; i<indices.length(); i++)
	{
		if (indices[i] >= 0 &&
			indices[i] <= m_polyOutline.Length()-1)
		{
			TADSGePoint3d ptMove;
			if (indices[i] == 0)
			{
				if (GetNumsOfHooksAt(0) <= 0)
				{
					// 移动路径点
					ptMove = *m_polyOutline.GetPointListAt(0);
					ptMove += offset;
					m_polyOutline.SetPointListAt(0, ptMove);

					// 移动起始点钩子
					TStruHookInfo hook;
					if (GetAt(KEY_HOOKS, hook) &&
						hook.eType != TStruHookInfo::kNone)
					{
						hook.ptPos += offset;
						SetAt(KEY_HOOKS, hook);
					}
					return Acad::eOk;
				}
			}
			else
			{
				if (GetNumsOfHooksAt(indices[i]-1) <= 0 &&
					GetNumsOfHooksAt(indices[i]) <= 0)
				{
					// 移动路径点
					ptMove = *m_polyOutline.GetPointListAt(indices[i]);
					ptMove += offset;
					m_polyOutline.SetPointListAt(indices[i], ptMove);

					if (indices[i] == m_polyOutline.Length()-1)
					{
						// 移动终止点钩子
						TStruHookInfo hook;
						if (GetAt(KEY_HOOKE, hook) &&
							hook.eType != TStruHookInfo::kNone)
						{
							hook.ptPos += offset;
							SetAt(KEY_HOOKE, hook);
						}
					}
					return Acad::eOk;
				}
			}
			AcGeMatrix3d xform;
			xform.setToTranslation(offset);
			subTransformBy(xform);
			break;
		}
		else
		{
			// 改变钩子的象限
			// 获得该夹点处的钩子
			TStruHookInfo hook;
			int index = indices[i] - m_polyOutline.Length();
			hook = GetHookFromGripPt(index);

			// 移动后的夹点位置
			AcGePoint3d ptMoved = GetGripPoint(hook) + offset;

			// 获得该钩子的方向向量
			AcGeVector3d vtDir1, vtDir2;
			GetAxisX(hook, vtDir1, vtDir2);

			hook.nQuadrant = GetNewQuadrant(hook, ptMoved, vtDir1, vtDir2);
			UpdateHookFromGripPt(index, hook);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	return TDbStruEntityBase::subGetStretchPoints(stretchPoints);
}

Acad::ErrorStatus TDbStruReinBar::subMoveStretchPointsAt(const AcDbIntArray& indices,
														 const AcGeVector3d& offset)
{
	return subMoveGripPointsAt(indices, offset);
}

Acad::ErrorStatus TDbStruReinBar::subGetOsnapPoints(
 	AcDb::OsnapMode		osnapMode,
 	INT_PTR				gsSelectionMark,
 	const AcGePoint3d&  pickPoint,
	const AcGePoint3d&  lastPoint,
	const AcGeMatrix3d& viewXform,
	AcGePoint3dArray&   snapPoints,
	AcDbIntArray&		geomIds) const
{
	return TDbStruEntityBase::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint,
		viewXform, snapPoints, geomIds);
}

Acad::ErrorStatus TDbStruReinBar::subGetTransformedCopy(
	const AcGeMatrix3d& xform, 
	AcDbEntity*&		pEnt) const
{
	return TDbStruEntityBase::subGetTransformedCopy(xform, pEnt);
}

Acad::ErrorStatus TDbStruReinBar::copyFrom(const AcRxObject* pSrc)
{
	assertWriteEnabled();
	if (pSrc->isKindOf(TDbStruReinBar::desc()))
	{
		TDbStruReinBar* pSrcReinBar = (TDbStruReinBar*)pSrc;
		
		GetSpecialtyData()->Empty();
		GetSpecialtyData()->CopyFrom(pSrcReinBar->GetSpecialtyData());

		m_polyOutline = pSrcReinBar->GetOutline();  // 钢筋路径
		m_dWidth      = pSrcReinBar->GetWidth();    // 宽度
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::subGetClassID(CLSID* pClsid) const
{
#if (ADS >= 17)
	assertReadEnabled();
#endif
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruReinBar::subWblockClone(
 	AcRxObject*			pOwner,
	AcDbObject*&		pClonedObject,
	AcDbIdMapping&		idMap,
	Adesk::Boolean		isPrimary) const
{
	return TDbStruEntityBase::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus TDbStruReinBar::subDeepClone(
	AcDbObject*         pOwner,
	AcDbObject*&	    pClonedObject,
	AcDbIdMapping&      idMap,
	Adesk::Boolean      isPrimary) const
{
	return TDbStruEntityBase::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
}

// 获得二维包围盒
Acad::ErrorStatus TDbStruReinBar::GetExtents2d(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
{
	assertReadEnabled();
	EType eType;
	if (TDbStruEntityBase::GetAt(KEY_KIND, (int&)eType))
	{
		if (eType == kNormal)
		{
			m_polyOutline.GetExtend(ptLow, ptUp);
		}
		else
		{
			TADSGePoint3d ptCenter = m_polyOutline.GetPointListAt(0);
			ptLow = TADSGePoint3d(ptCenter.x - m_dWidth / 2, ptCenter.y - m_dWidth / 2, 0);
			ptUp  = TADSGePoint3d(ptCenter.x + m_dWidth / 2, ptCenter.y + m_dWidth / 2, 0);
		}
	}
	return Acad::eOk;
}

// 获得三维包围盒
Acad::ErrorStatus TDbStruReinBar::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
{
	return Acad::eNotImplementedYet;
}

//取动态属性显示数据
void TDbStruReinBar::GetTips(TDPtrList<TObjInfoUnit>& lstInfo) const
{
	TDbStruEntityBase::GetTips(lstInfo);
}

const TCHAR* TDbStruReinBar::GetDefaultLayer() const
{
	return LAY_S_BEAM_RBAR_LINE;
}

BOOL TDbStruReinBar::IsValid() const
{
	EType eType;
	TDbStruEntityBase::GetAt(KEY_KIND, (int&)eType);
	if (eType == kDot &&
		m_polyOutline.Length() < 1)
	{
		return FALSE;
	}
	else if (eType == kNormal &&
			 m_polyOutline.Length() < 2)
	{
		return FALSE;
	}
	return TRUE;
}

// 支持夹点ctrl功能切换
int TDbStruReinBar::GetCtrlToggleIndex()const
{
	return TDbStruEntityBase::GetCtrlToggleIndex();
}

// 属性匹配
void TDbStruReinBar::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbStruEntityBase::CopyPropertiesFrom(pSrcEntity, gMatchFlag);

	TDbStruReinBar* pSrc = TDbStruReinBar::cast(pSrcEntity);
	if (pSrc != NULL)
	{
		m_dWidth = pSrc->m_dWidth;
	}
}

// 获得标准三维面
bool TDbStruReinBar::GetStandardFaceBody(AcDbVoidPtrArray& arFacePtrs) const
{
	return TDbStruEntityBase::GetStandardFaceBody(arFacePtrs);
}

// 获得安全保护区
bool TDbStruReinBar::GetSafeProtectedSpace(AcDbVoidPtrArray& arFacePtrs) const
{
	return TDbStruEntityBase::GetSafeProtectedSpace(arFacePtrs);
}

// 获得剖面
bool TDbStruReinBar::GetSection(
	const AcDbFace &face, 
	const AcGeVector3d& vtPlaneSecDir, 
	std::vector<TObjSectionRecord> &sectionRecords, 
	AcDbVoidPtrArray& arFillPtrs) const
{
	return TDbStruEntityBase::GetSection(face, vtPlaneSecDir, sectionRecords, arFillPtrs);
}

// 获得XML
CString TDbStruReinBar::GetXml(const AcGeMatrix3d& mat) const
{
	return TDbStruEntityBase::GetXml(mat);
}

TStruHookInfo TDbStruReinBar::GetHookFromGripPt(int index)
{
	assertWriteEnabled();
	CArray<SHook, SHook&> arHooks;
	GetHooksOrderByGrip(arHooks);

	return arHooks[index].hook;
}

void TDbStruReinBar::GetHooksOrderByGrip(CArray<SHook, SHook&>& arHooks)
{
	assertReadEnabled();
	SHook sHook;
	TStruHookInfo hook;
	if (GetAt(KEY_HOOKS, hook) &&
		hook.eType != TStruHookInfo::kNone)
	{
		sHook.hook = hook;
		sHook.bIsStartOrEnd = 1;
		arHooks.Add(sHook);
	}
	if (GetAt(KEY_HOOKE, hook) &&
		hook.eType != TStruHookInfo::kNone)
	{
		sHook.hook = hook;
		sHook.bIsStartOrEnd = -1;
		arHooks.Add(sHook);
	}
	CArray<TStruHookInfo, TStruHookInfo&> arHooksMid;
	if (GetAt(KEY_HOOK, arHooksMid))
	{
		for (int i=0; i<arHooksMid.GetSize(); i++)
		{
			if (arHooksMid[i].eType != TStruHookInfo::kNone)
			{
				sHook.hook = arHooksMid[i];
				sHook.bIsStartOrEnd = FALSE;
				sHook.nIndex = i;
				arHooks.Add(sHook);
			}
		}
	}
}

void TDbStruReinBar::UpdateHookFromGripPt(int index, TStruHookInfo hook)
{
	assertWriteEnabled();
	CArray<SHook, SHook&> arHooks;
	GetHooksOrderByGrip(arHooks);
	if (index >= arHooks.GetSize())
	{
		return;
	}
	SHook sHook = arHooks[index];
	if (sHook.bIsStartOrEnd > 0)
	{
		SetAt(KEY_HOOKS, hook);
	}
	else if (sHook.bIsStartOrEnd < 0)
	{
		SetAt(KEY_HOOKE, hook);
	}
	else
	{
		CArray<TStruHookInfo, TStruHookInfo&> arHooksMid;
		GetAt(KEY_HOOK, arHooksMid);
		if (sHook.nIndex < arHooksMid.GetSize())
		{
			arHooksMid[sHook.nIndex] = hook;
			SetAt(KEY_HOOK, arHooksMid);
		}
	}
}

int  TDbStruReinBar::GetNewQuadrant(TStruHookInfo hook, AcGePoint3d ptMoved, 
									AcGeVector3d vtAxis)
{
	int nRet = hook.nQuadrant;

	// 钩子位置点到新夹点位置的向量
	AcGeVector3d vtHookDir = ptMoved - hook.ptPos;

	vtHookDir.rotateBy(-AcGeVector2d(vtAxis.x, vtAxis.y).angle(), AcGeVector3d(0, 0, 1));
	if (vtHookDir[X] > 0 && vtHookDir[Y] > 0)  // 第一象限
	{
		nRet =  1;
	}
	else if (vtHookDir[X] <=0 && vtHookDir[Y] > 0) // 第二象限
	{
		nRet = 2;
	}
	else if (vtHookDir[X] > 0 && vtHookDir[Y] < 0) // 第四象限
	{
		nRet = 4;
	}
	else  // 第三象限
	{
		nRet = 3;
	}

	if (IsStartHook(hook.ptPos))
	{
		nRet = 4;
		if (vtHookDir[Y] > 0)
		{
			nRet = 1;
		}
	}
	else if (IsEndHook(hook.ptPos))
	{
		nRet = 3;
		if (vtHookDir[Y] > 0)
		{
			nRet = 2;
		}
	}

	return nRet;
}

int  TDbStruReinBar::GetNewQuadrant(TStruHookInfo hook, AcGePoint3d ptMoved, 
					                AcGeVector3d vtAxis1, AcGeVector3d vtAxis2)
{
	int nRet = hook.nQuadrant;
	vtAxis1.normalize();
	vtAxis2.normalize();

	if (vtAxis1 == vtAxis2)
	{
		return GetNewQuadrant(hook, ptMoved, vtAxis1);
	}

	int nQua2 = GetNewQuadrant(hook, ptMoved, vtAxis2); // 基于第二条方向向量的象限位置
	switch (GetNewQuadrant(hook, ptMoved, vtAxis1))
	{
	case 1:  // 第一象限
		if (nQua2 == 1 ||
			nQua2 == 4)
		{
			nRet = nQua2;
		}
		break;
	case 2:  // 第二象限
		if (nQua2 != 1 &&
			nQua2 != 4)
		{
			nRet = 2;
		}
		break;
	case 3:  // 第三象限
		if (nQua2 != 1 &&
			nQua2 != 4)
		{
			nRet = 3;
		}
		break;
	case 4:  // 第四象限
		if (nQua2 == 1 ||
			nQua2 == 4)
		{
			nRet = nQua2;
		}
		break;
	default:
		break;
	}
	return nRet;
}

BOOL TDbStruReinBar::SetAt(LPCTSTR pszKey, const TStruHookInfo& hook)
{
	assertWriteEnabled();
	if (TDbStruEntityBase::SetAt(CString(pszKey)+_T("1"), hook.ptPos) &&
		TDbStruEntityBase::SetAt(CString(pszKey)+_T("2"), hook.nQuadrant) &&
		TDbStruEntityBase::SetAt(CString(pszKey)+_T("3"), (int)hook.eType))
	{
		return TRUE;
	}
	return FALSE;
}

BOOL TDbStruReinBar::GetAt(LPCTSTR pszKey, TStruHookInfo& hook) const
{
	assertReadEnabled();
	if (TDbStruEntityBase::GetAt(CString(pszKey)+_T("1"), hook.ptPos) &&
		TDbStruEntityBase::GetAt(CString(pszKey)+_T("2"), hook.nQuadrant) &&
		TDbStruEntityBase::GetAt(CString(pszKey)+_T("3"), (int&)hook.eType))
	{
		return TRUE;
	}

	return FALSE;
}

BOOL TDbStruReinBar::SetAt(LPCTSTR pszKey, const CArray<TStruHookInfo, TStruHookInfo&>& hooks)
{
	assertWriteEnabled();
	if (!TDbStruEntityBase::SetAt(pszKey, (int)hooks.GetSize()))
	{
		return FALSE;
	}
	for (int i=0; i<hooks.GetSize(); i++)
	{
		CString sKey;
		sKey.Format(_T("%s%d"), pszKey, i+1);
		if (!SetAt(sKey, hooks[i]))
		{
			return FALSE;
		}
	}
	return TRUE;
}

BOOL TDbStruReinBar::GetAt(LPCTSTR pszKey, CArray<TStruHookInfo, TStruHookInfo&>& hooks) const
{
	assertReadEnabled();
	int nSize;
	if (!TDbStruEntityBase::GetAt(pszKey, nSize))
	{
		return FALSE;
	}
	TStruHookInfo hook;
	for (int i=0; i<nSize; i++)
	{
		CString sKey;
		sKey.Format(_T("%s%d"), pszKey, i+1);
		if (!GetAt(sKey, hook))
		{
			return FALSE;
		}
		hooks.Add(hook);
	}
	return TRUE;
}

// 设置/获取线宽
void TDbStruReinBar::SetWidth(double dWidth)
{
	assertWriteEnabled();
	m_dWidth = dWidth;
}
double TDbStruReinBar::GetWidth() const
{
	assertReadEnabled();
	return m_dWidth;
}

// 点钢筋，设置点钢筋的位置
BOOL TDbStruReinBar::SetDotPos(AcGePoint3d ptPos)
{
	assertWriteEnabled();
	EType eType;
	if (TDbStruEntityBase::GetAt(KEY_KIND, (int&)eType) &&
		eType == kDot)
	{
		m_polyOutline.Reset();
		m_polyOutline.InsertNodeAt(0, ptPos);
		return TRUE;
	}
	return FALSE;
}

// 设置钢筋路径
BOOL TDbStruReinBar::SetOutline(const TGGePoly2D& outline)
{
	assertWriteEnabled();
	if (outline.Length() < 1)
	{
		return FALSE;
	}
	m_polyOutline = outline;

	// 重新计算起始和终止端钩子的位置
	ReCalcPointHook();
	return TRUE;
}

TGGePoly2D TDbStruReinBar::GetOutline()
{
	return m_polyOutline;
}

// 设置起始/终止钩子
BOOL TDbStruReinBar::SetStartHook(TStruHookInfo::EType eType, 
								  int nQuadrant)
{
	assertWriteEnabled();

	TStruHookInfo hook;
	hook.eType     = eType;
	hook.nQuadrant = nQuadrant;
	hook.ptPos     = AcGePoint3d(0, 0, 0);
	BOOL bRet = SetStartHook(hook);
	return bRet;
}
BOOL TDbStruReinBar::SetEndHook(TStruHookInfo::EType eType, 
								int nQuadrant)
{
	assertWriteEnabled();

	TStruHookInfo hook;
	hook.eType     = eType;
	hook.nQuadrant = nQuadrant;
	hook.ptPos     = AcGePoint3d(0, 0, 0);
	BOOL bRet = SetEndHook(hook);
	return bRet;
}

BOOL TDbStruReinBar::SetStartHook(TStruHookInfo hook)
{
	assertWriteEnabled();
	if (m_polyOutline.Length() > 0)
	{
		hook.ptPos = *m_polyOutline.GetPointListAt(0);
	}
	BOOL bRet = SetAt(KEY_HOOKS, hook);
	return bRet;
}

BOOL TDbStruReinBar::SetEndHook(TStruHookInfo hook)
{
	assertWriteEnabled();
	if (m_polyOutline.Length() > 1)
	{
		hook.ptPos = *m_polyOutline.GetPointListAt(m_polyOutline.Length()-1);
	}
	BOOL bRet = SetAt(KEY_HOOKE, hook);
	return bRet;
}

BOOL TDbStruReinBar::GetStartHook(TStruHookInfo& hookS)
{
	assertReadEnabled();
	return GetAt(KEY_HOOKS, hookS);
}
BOOL TDbStruReinBar::GetEndHook(TStruHookInfo& hookE)
{
	return GetAt(KEY_HOOKE, hookE);
}

// 添加一个中间钩子
BOOL TDbStruReinBar::AddMidHook(const TStruHookInfo& hook)
{
	assertWriteEnabled();
	if (!IsValid())
	{
		return FALSE;
	}

	if (!m_polyOutline.HitTestOnCurve(hook.ptPos))
	{
		return FALSE;
	}
	CArray<TStruHookInfo, TStruHookInfo&> arHooks;
	GetAt(KEY_HOOK, arHooks);

	// 检测是否含有相同位置的钩子
	for (int i=0; i<arHooks.GetSize(); i++)
	{
		if (arHooks[i].ptPos == hook.ptPos)
		{
			return FALSE;
		}
	}

	// 检测是否是起始或终止位置
	if (*m_polyOutline.GetPointListAt(0) == TADSGePoint3d(hook.ptPos) ||
		*m_polyOutline.GetPointListAt(m_polyOutline.Length()-1) == TADSGePoint3d(hook.ptPos))
	{
		return FALSE;
	}

	arHooks.Add((TStruHookInfo)hook);
	BOOL bRet = SetAt(KEY_HOOK, arHooks);
	return bRet;
}

// 判断是否是起始或终止端钩子
BOOL TDbStruReinBar::IsStartOrEndHook(AcGePoint3d ptPos) const
{
	if (IsStartHook(ptPos) ||
		IsEndHook(ptPos))
	{
		return TRUE;
	}
	return FALSE;
}

BOOL TDbStruReinBar::IsStartHook(AcGePoint3d ptPos) const
{
	return TADSGePoint3d(ptPos) == m_polyOutline.GetPointListAt(0);
}
BOOL TDbStruReinBar::IsEndHook(AcGePoint3d ptPos) const
{
	return TADSGePoint3d(ptPos) == m_polyOutline.GetPointListAt(m_polyOutline.Length()-1);
}

void TDbStruReinBar::GetStraightOutline(const TStruHookInfo& hook, 
										AcGeVector3d vtAxistX, 
										AcDbPolyline& plOutline) const
{
	AcGeVector3d vtDir;
	AcGePoint3d  ptOutline;

	// 将位置点添加到多段线
	plOutline.addVertexAt(plOutline.numVerts(), 
		AcGePoint2d(hook.ptPos[X], hook.ptPos[Y]),
		0, m_dWidth, m_dWidth);

	vtDir = vtAxistX;
	switch (hook.nQuadrant)
	{
	case 1:
	case 2:
		vtDir.rotateBy(PI/2, AcGeVector3d(0, 0, 1));
		break;
	case 3:
	case 4:
		vtDir.rotateBy(-PI/2, AcGeVector3d(0, 0, 1));
		break;
	default:
		break;
	}

	vtDir.normalize();
	//ptOutline = hook.ptPos +  vtDir * 3.0f * m_dWidth;
	ptOutline = hook.ptPos +  vtDir * m_dLengthS;
	plOutline.addVertexAt(plOutline.numVerts(), AcGePoint2d(ptOutline[X], ptOutline[Y]),
		0, m_dWidth, m_dWidth);
}

void TDbStruReinBar::GetBentOutline(const TStruHookInfo& hook, 
									AcGeVector3d vtAxistX, 
									AcDbPolyline& plOutline) const
{
	AcGeVector3d vtDir1, vtDir2;
	AcGePoint3d  ptOutline;

	// 将位置点添加到多段线
	plOutline.addVertexAt(plOutline.numVerts(), 
		AcGePoint2d(hook.ptPos[X], hook.ptPos[Y]),
		0, m_dWidth, m_dWidth);

	vtDir1 = vtDir2 = vtAxistX;
	switch (hook.nQuadrant)
	{
	case 1:
		vtDir1.rotateBy(PI/2.0f, AcGeVector3d(0, 0, 1));
		break;
	case 2:
		vtDir1.rotateBy(PI/2.0f, AcGeVector3d(0, 0, 1));
		vtDir2.rotateBy(PI, AcGeVector3d(0, 0, 1));
		break;
	case 3:
		vtDir1.rotateBy(-PI/2.0f, AcGeVector3d(0, 0, 1));
		vtDir2.rotateBy(PI, AcGeVector3d(0, 0, 0));
		break;
	case 4:
		vtDir1.rotateBy(-PI/2.0f, AcGeVector3d(0, 0, 1));
		break;
	default:
		break;
	}

	vtDir1.normalize();
	vtDir2.normalize();
	//ptOutline = hook.ptPos + vtDir1 * 3.0f * m_dWidth;
	ptOutline = hook.ptPos + vtDir1 * m_dDiaB;
	plOutline.addVertexAt(plOutline.numVerts(), AcGePoint2d(ptOutline[X], ptOutline[Y]),
		0, m_dWidth, m_dWidth);
	//ptOutline +=  vtDir2 * 3.0f * m_dWidth;
	ptOutline +=  vtDir2 * m_dLengthB;
	plOutline.addVertexAt(plOutline.numVerts(), AcGePoint2d(ptOutline[X], ptOutline[Y]),
		0, m_dWidth, m_dWidth);
}

void TDbStruReinBar::GetObliqueOutline(const TStruHookInfo& hook, 
									   AcGeVector3d vtAxistX, 
									   AcDbPolyline& plOutline) const
{
	AcGeVector3d vtDir;
	AcGePoint3d  ptOutline;

	// 将位置点添加到多段线
	plOutline.addVertexAt(plOutline.numVerts(), 
		AcGePoint2d(hook.ptPos[X], hook.ptPos[Y]),
		0, m_dWidth, m_dWidth);

	vtDir = vtAxistX;
	switch (hook.nQuadrant)
	{
	case 1:
		vtDir.rotateBy(PI/4, AcGeVector3d(0, 0, 1));
		break;
	case 2:
		vtDir.rotateBy(PI/4*3, AcGeVector3d(0, 0, 1));
		break;
	case 3:
		vtDir.rotateBy(-PI/4*3, AcGeVector3d(0, 0, 1));
		break;
	case 4:
		vtDir.rotateBy(-PI/4, AcGeVector3d(0, 0, 1));
		break;
	default:
		break;
	}

	vtDir.normalize();
	//ptOutline = hook.ptPos + vtDir * 3.0f * m_dWidth;
	ptOutline = hook.ptPos + vtDir * m_dLengthO;
	plOutline.addVertexAt(plOutline.numVerts(), AcGePoint2d(ptOutline[X], ptOutline[Y]),
		0, m_dWidth, m_dWidth);
}

// 获取钩子的轮廓线
BOOL TDbStruReinBar::GetHookOutLine(const TStruHookInfo& hook, AcDbPolyline& plOutline) const
{
	// 将多段线置为空
	plOutline.reset(Adesk::kFalse, 0);

	// 获得局部坐标系的x轴
	AcGeVector3d vtAxisX1, vtAxisX2, vtAxisX;
	GetAxisX(hook, vtAxisX1, vtAxisX2);
	vtAxisX = vtAxisX2;
	if (hook.nQuadrant == 2 ||
		hook.nQuadrant == 3)
	{
		vtAxisX = vtAxisX1;
	}

	// 获取各种类型钩子的轮廓线
	switch (hook.eType)
	{
	case TStruHookInfo::kStraight:
		GetStraightOutline(hook, vtAxisX, plOutline);
		break;
	case TStruHookInfo::kOblique:
		GetObliqueOutline(hook, vtAxisX, plOutline);
		break;
	case TStruHookInfo::kBent:
		GetBentOutline(hook, vtAxisX, plOutline);
		break;
	default:
		return FALSE;
	}
	return TRUE;
}

// 获取用于确定象限的局部坐标系x轴，如果在两条线段的转折点上，存在两条x轴
void TDbStruReinBar::GetAxisX(const TStruHookInfo& hook, AcGeVector3d& vtAxis1, 
							  AcGeVector3d& vtAxis2) const
{
	int nPos = m_polyOutline.HitTestOnCurve(hook.ptPos);
	AcGeVector3d vtDir(1, 0, 0);
	if (nPos>0) // 在顶点上
	{
		if ((TADSGePoint3d)hook.ptPos == m_polyOutline.GetPointListAt(0))
		{
			TGGeCurveSegment curve;
			m_polyOutline.Nth(nPos-1, curve);
			
			vtAxis1 = vtDir;
			vtAxis2 = vtAxis1.rotateBy(curve.Direction(hook.ptPos), AcGeVector3d(0, 0, 1));

			if (m_polyOutline.GetBulge(nPos-1) < -_DIST_SNAP)
			{
				vtAxis1 = vtAxis2.rotateBy(PI,  AcGeVector3d(0, 0, 1));
			}
		}
		else if ((TADSGePoint3d)hook.ptPos == 
			m_polyOutline.GetPointListAt(m_polyOutline.Length()-1))
		{
			TGGeCurveSegment curve;
			m_polyOutline.Nth(nPos-2, curve);

			vtAxis1 = vtDir;
			vtAxis2 = vtAxis1.rotateBy(curve.Direction(hook.ptPos), AcGeVector3d(0, 0, 1));

			if (m_polyOutline.GetBulge(nPos-2) < -_DIST_SNAP)
			{
				vtAxis1 = vtAxis2.rotateBy(PI,  AcGeVector3d(0, 0, 1));
			}
		}
		else
		{
			TGGeCurveSegment curve1, curve2;
			m_polyOutline.Nth(nPos - 2, curve1);
			m_polyOutline.Nth(nPos - 1, curve2);
			double dAngle = curve1.Direction(hook.ptPos);
			vtAxis1 = vtDir;
			vtAxis1.rotateBy(dAngle, AcGeVector3d(0, 0, 1));

			if (m_polyOutline.GetBulge(nPos-2) < -_DIST_SNAP)
			{
				vtAxis1.rotateBy(PI,  AcGeVector3d(0, 0, 1));
			}

			dAngle = curve2.Direction(hook.ptPos);
			vtAxis2 = vtDir;
			vtAxis2.rotateBy(dAngle, AcGeVector3d(0, 0, 1));

			if (m_polyOutline.GetBulge(nPos-1) < -_DIST_SNAP)
			{
				vtAxis2.rotateBy(PI,  AcGeVector3d(0, 0, 1));
			}
		}
	}
	else if (nPos<0) // 在线上
	{
		nPos = abs(nPos);
		TGGeCurveSegment curve;
		m_polyOutline.Nth(nPos - 1, curve);
		double dAngle = curve.Direction(hook.ptPos);
		vtAxis1 = vtAxis2 = vtDir.rotateBy(dAngle, AcGeVector3d(0, 0, 1));
		if (m_polyOutline.GetBulge(nPos-1) < -_DIST_SNAP)
		{
			vtAxis1 = vtAxis2 .rotateBy(PI,  AcGeVector3d(0, 0, 1));
		}
	}
}

// 获取路径点处的切线
void TDbStruReinBar::GetAxisX(int nIndex, AcGeVector3d& vtAxis1, AcGeVector3d& vtAxis2) const
{
	TStruHookInfo hookTemp = TStruHookInfo(m_polyOutline.GetPointListAt(nIndex),
		TStruHookInfo::kNone, 1);
	GetAxisX(hookTemp, vtAxis1, vtAxis2);
}

// 获取夹点位置
AcGePoint3d TDbStruReinBar::GetGripPoint(const TStruHookInfo& hook) const
{
	AcDbPolyline plOutline;
	GetHookOutLine(hook, plOutline);
	AcGePoint3d ptRet;
	plOutline.getPointAt(plOutline.numVerts()-1, ptRet);
	return ptRet;
}

int TDbStruReinBar::GetNumsOfHooksAt(int nIndex)
{
	int nNums = 0;
	// 遍历中间钩子
	CArray<TStruHookInfo, TStruHookInfo&> arHooks;
	if (GetAt(KEY_HOOK, arHooks))
	{
		int nRet;
		for (int i=0; i<arHooks.GetSize(); i++)
		{
			nRet = m_polyOutline.HitTestOnCurve(arHooks[i].ptPos);
			nRet = abs(nRet);
			if (nRet == 0)
			{
				continue;
			}
			nRet--;
			if (nRet == nIndex)
			{
				nNums++;
			}
		}
	}
	return nNums;
}

// 颠倒钢筋路径点的顺序
void TDbStruReinBar::ReverseOutline()
{
	assertWriteEnabled();
	m_polyOutline.Reverse();
	ReCalcPointHook();
}

// 清楚所有中间钩子
void TDbStruReinBar::ClearAllMidHook()
{
	assertWriteEnabled();
	CArray<TStruHookInfo, TStruHookInfo&> hooks;
	if (GetAt(KEY_HOOK, hooks))
	{
		hooks.RemoveAll();
		SetAt(KEY_HOOK, hooks);
	}
}

// 重新设置起点和终点的钩子位置，使其始终和路径的起点和终点保持一致
void TDbStruReinBar::ReCalcPointHook()
{
	assertWriteEnabled();
	TStruHookInfo hook;
	if (GetAt(KEY_HOOKS, hook))
	{
		hook.ptPos = *m_polyOutline.GetPointListAt(0);
		SetAt(KEY_HOOKS, hook);
	}

	if (GetAt(KEY_HOOKE, hook))
	{
		hook.ptPos = *m_polyOutline.GetPointListAt(m_polyOutline.Length()-1);
		SetAt(KEY_HOOKE, hook);
	}
}

double TDbStruReinBar::GetLenS() const
{
	assertReadEnabled();
	return m_dLengthS;
}
void TDbStruReinBar::SetLenS(double dVal)
{
	assertWriteEnabled();
	m_dLengthS = dVal;
}
double TDbStruReinBar::GetLenO() const
{
	assertReadEnabled();
	return m_dLengthO;
}
void TDbStruReinBar::SetLenO(double dVal)
{
	assertWriteEnabled();
	m_dLengthO = dVal;
}
double TDbStruReinBar::GetLenB() const
{
	assertReadEnabled();
	return m_dLengthB;
}
void TDbStruReinBar::SetLenB(double dVal)
{
	assertWriteEnabled();
	m_dLengthB = dVal;
}
double TDbStruReinBar::GetDiaB() const
{
	assertReadEnabled();
	return m_dDiaB;
}
void TDbStruReinBar::SetDiaB(double dVal)
{
	assertWriteEnabled();
	m_dDiaB = dVal;
}

int TDbStruReinBar::GetFirstVersion()const
{
	return 10;
}
bool TDbStruReinBar::IsModelEntity() const
{
	return true;
}
AcDbCurve* TDbStruReinBar::GetBaseCurve()const
{
	assertReadEnabled();
	AcDbCurve* pCurve = m_polyOutline.AsAcDbCurve();

	return pCurve;
}

Acad::ErrorStatus TDbStruReinBar::SetBaseCurve(AcDbCurve*pCurve)
{
	assertWriteEnabled();

	AcDbCurve *pCurve1 = (AcDbCurve*)pCurve->clone();
	if (m_polyOutline.SetAcDbCurve(pCurve1))
	{
		delete pCurve1;
		return Acad::eOk;
	}
	else
	{
		delete pCurve1;
		return Acad::eNotImplementedYet;
	}
}


void InitDbStruReinBar(BOOL bInit)
{
	if (bInit)
	{
		TDbStruReinBar::rxInit();
		acrxBuildClassHierarchy();
		TDbStruReinBar::InitMatchProtocol(TRUE);
	}
	else
	{
		TDbStruReinBar::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbStruReinBar::desc());
	}
}
#endif