//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbStruFloorSlab类
// = Version	:   ver1.0
// = Author		:   ywb
// = CreateDate	:   2011-06-01
// = Description:   楼板类实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+

#include "StdAfx.h"
#ifdef TASD
#include "TBaseWallIntegrateTool.h"
#include "TDbStruFloorSlab.h" 
#include "TAsdKeyDefine.h"
#include "TDbStruSlabHole.h"
#include "TConfigInfo.h"

#define BOUNDARYSPACE 100					//固定边界两短线之间的长度
#define FIXBOUNDARYLEN 50					//固定边界时短线长度

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

const Adesk::UInt8 TDbStruFloorSlab::g_nVersion = 1;
int nInclineColor = 3;		// 斜板颜色

TDbStruFloorSlab::TDbStruFloorSlab()
{
	m_polyOutline.Reset();
	m_arAssocHoleIds.setLogicalLength(0);
	m_arAssocZIds.setPhysicalLength(0);
	m_arAssocWallIds.setLogicalLength(0);
	GetSpecialtyData()->Empty();
}

TDbStruFloorSlab::~TDbStruFloorSlab()
{
	m_polyOutline.Reset();
	m_arAssocHoleIds.setLogicalLength(0);
	m_arAssocZIds.setPhysicalLength(0);
	m_arAssocWallIds.setLogicalLength(0);
	GetSpecialtyData()->Empty();
}

Acad::ErrorStatus TDbStruFloorSlab::dwgInFields( AcDbDwgFiler* pFiler )
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbStruEntityBase::dwgInFields(pFiler);
	if (es != Acad::eOk)
		return es;
	
	// 版本号
	Adesk::UInt8  nVer = 1;
	pFiler->readItem(&nVer);
	if (nVer > g_nVersion)
		return Acad::eMakeMeProxy;
	
	// 轮廓线
	Adesk::UInt8 nCount = 0;
	pFiler->readItem(&nCount);
	AcGePoint3dArray arPt(nCount, nCount);
	AcArray<double> arBulge(nCount, nCount);
	Adesk::Int8 i = 0;
	AcGePoint3d pt;
	for (i = 0; i < nCount; ++i)
	{
		// 点
		pt = AcGePoint3d::kOrigin;
		pFiler->readPoint3d(&pt);
		arPt.append(pt);
	}
	double dBulge(0);
	for (i = 0; i < nCount; ++i)
	{
		// 凸度
		pFiler->readDouble(&dBulge);
		arBulge.append(dBulge);
	}
	
	m_polyOutline.Reset();
	for (i = 0; i < nCount; ++i)
		m_polyOutline.AppendNode(arPt.at(i), arBulge.at(i));
	m_polyOutline.SetClosed();
	
	// 关联对象数组
	nCount = 0;
	// xy平面关联对象ID数组
	pFiler->readItem(&nCount);
	AcDbSoftPointerId id = AcDbSoftPointerId::kNull;
	m_arAssocHoleIds.setLogicalLength(0);
	for(i = 0; i < nCount; i++)
	{
		pFiler->readItem(&id);
		m_arAssocHoleIds.append(id);
	}
	// z平面关联对象ID数组
	nCount = 0;
	pFiler->readItem(&nCount);
	m_arAssocZIds.setLogicalLength(0);
	for(i = 0; i < nCount; i++)
	{
		pFiler->readItem(&id);
		m_arAssocZIds.append(id);
	}

	// 关联墙
	nCount = 0;
	pFiler->readItem(&nCount);
	m_arAssocWallIds.setLogicalLength(0);
	for (i = 0; i < nCount; i++)
	{
		pFiler->readItem(&id);
		m_arAssocWallIds.append(id);
	}

	pFiler->readItem(&m_idLayerLoad);
	pFiler->readItem(&m_idLayerLoadL);
	pFiler->readItem(&m_idLayerLoadC);
	pFiler->readItem(&m_idTextStyle);
	pFiler->readItem(&m_idTextStyleRB);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStruFloorSlab::dwgOutFields( AcDbDwgFiler* pFiler ) const
{
	assertReadEnabled();
	
	Acad::ErrorStatus es = TDbStruEntityBase::dwgOutFields(pFiler);
	if (es != Acad::eOk)
		return es;
	
	pFiler->writeItem(g_nVersion);
	
	Adesk::UInt8 nCount = m_polyOutline.Length();
	pFiler->writeItem(nCount);
	Adesk::UInt8 i = 0;
	for (i = 0; i < nCount; ++i)
		pFiler->writePoint3d(m_polyOutline.GetPointListAt(i));
	for (i = 0; i < nCount; ++i)
		pFiler->writeDouble(m_polyOutline.GetBulge(i));
	
	nCount = (Adesk::UInt8)m_arAssocHoleIds.length();
	pFiler->writeItem(nCount);
	for(i = 0; i < nCount; i++)
	{
		pFiler->writeItem(AcDbSoftPointerId(m_arAssocHoleIds.at(i)));
	}
	
	nCount = (Adesk::UInt8)m_arAssocZIds.length();
	pFiler->writeItem(nCount);
	for (i = 0; i < nCount; i++)
	{
		pFiler->writeItem(AcDbSoftPointerId(m_arAssocZIds.at(i)));
	}

	nCount = (Adesk::UInt8)m_arAssocWallIds.length();
	pFiler->writeItem(nCount);
	for (i = 0; i < nCount; i++)
	{
		pFiler->writeItem(AcDbSoftPointerId(m_arAssocWallIds.at(i)));
	}

	pFiler->writeItem(m_idLayerLoad);
	pFiler->writeItem(m_idLayerLoadL);
	pFiler->writeItem(m_idLayerLoadC);
	pFiler->writeItem(m_idTextStyle);
	pFiler->writeItem(m_idTextStyleRB);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStruFloorSlab::dxfInFields( AcDbDxfFiler* pFiler )
{
	assertWriteEnabled();
	
	Acad::ErrorStatus es = TDbStruEntityBase::dxfInFields(pFiler);
	if (es != Acad::eOk)
		return es;
	if (!pFiler->atSubclassData(_T("TDbStruFloorSlab")))
		return Acad::eBadDxfSequence;
	
	try
	{
		// Object Version
		struct resbuf rb;
		pFiler->readItem(&rb);
		if (rb.restype != AcDb::kDxfInt8) 
			throw AcDb::kDxfInt8;
		
		Adesk::Int16 version = rb.resval.rint;
		if (version > g_nVersion)
			return Acad::eMakeMeProxy;
	}
	catch (AcDb::DxfCode code)
	{
		pFiler->pushBackItem();
		pFiler->setError(Acad::eInvalidDxfCode, _T("\nError: expected group code %d"), code);
		return pFiler->filerStatus();
	}
	
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStruFloorSlab::dxfOutFields( AcDbDxfFiler* pFiler ) const
{
	assertReadEnabled();
	
	Acad::ErrorStatus es = TDbStruEntityBase::dxfOutFields(pFiler);
	if (es != Acad::eOk)
		return es;
	
	pFiler->writeItem(AcDb::kDxfSubclass, _T("TDbStruFloorSlab"));
	pFiler->writeItem(AcDb::kDxfInt8, g_nVersion);
	
	return pFiler->filerStatus();
}

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

Acad::ErrorStatus TDbStruFloorSlab::subTransformBy( const AcGeMatrix3d& xform )
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	es = TDbStruEntityBase::subTransformBy(xform);
	
	m_polyOutline.TransformBy(xform);

	AcGePoint3d ptPos = AcGePoint3d::kOrigin;
	if (GetAt(KEY_POS, ptPos))
	{
		ptPos.transformBy(xform);
		SetAt(KEY_POS, ptPos);
	}

	return es;
}

Acad::ErrorStatus TDbStruFloorSlab::subGetTransformedCopy( const AcGeMatrix3d& xform, AcDbEntity*& pEnt ) const
{
	assertReadEnabled();
	
	pEnt = new TDbStruFloorSlab;
	pEnt->copyFrom(this);
	pEnt->transformBy(xform);
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::copyFrom( const AcRxObject* pSrc )
{
	assertWriteEnabled();
	
	if (pSrc != NULL)
	{
		TDbStruEntityBase::copyFrom(pSrc);
		
		TDbStruFloorSlab* pStruSlab = TDbStruFloorSlab::cast(pSrc);
		if (pStruSlab != NULL)
		{
			//setDatabaseDefaults(pStruSlab->database());
			m_polyOutline.Reset();
			m_polyOutline = pStruSlab->GetOutlinePoly();
			GetSpecialtyData()->Empty();
			GetSpecialtyData()->CopyFrom(pStruSlab->GetSpecialtyData());
		}
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
	assertReadEnabled();
	
	// 型心
	AcGePoint3d ptPos = AcGePoint3d::kOrigin;
	if (GetAt(KEY_POS, ptPos))
		gripPoints.append(ptPos);

	int nSlabType = 0;
	GetAt(KEY_KIND, nSlabType);
	if (nSlabType == 1) // 悬挑板
	{
		// 加入顶点
		int nNum = m_polyOutline.Length();
		for (int i = 0; i < nNum; i++)
		{
			gripPoints.append(m_polyOutline[i]);
		}

		// 边中点
		nNum = m_polyOutline.TotalSegments();
		TGGeCurveSegment seg;
		for (i = 0; i < nNum; i++)
		{
			m_polyOutline.Nth(i, seg);
			gripPoints.append(seg.MidPoint());
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::subGetStretchPoints( AcGePoint3dArray& stretchPoints ) const
{
	assertReadEnabled();
	
	AcDbIntArray osnapModes;
	AcDbIntArray geomIds;
	return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}

Acad::ErrorStatus TDbStruFloorSlab::subMoveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	if (indices.length() == 0 || offset.isZeroLength())
		return Acad::eOk;
	
	assertWriteEnabled();
	
	// 获得所有夹点
	AcGePoint3dArray arGrip;
	AcDbIntArray osnapModes;
	AcDbIntArray geomIds;
	subGetGripPoints(arGrip, osnapModes, geomIds);
	const int idx = indices.at(0);
	if (idx > arGrip.length())
		return Acad::eOk;
	
	// xoy平面
	AcGeVector3d vtOffset(offset);
	vtOffset.z = 0;
	
	if (idx == 0)
	{
		// 中心位置点
		AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
		mat.setToTranslation(vtOffset);
		
		TDbStruEntityBase::subTransformBy(mat);
		m_polyOutline.TransformBy(mat);
		
		AcGePoint3d ptPos = AcGePoint3d::kOrigin;
		if (GetAt(KEY_POS, ptPos))
		{
			ptPos.transformBy(mat);
			SetAt(KEY_POS, ptPos);
		}
	}
	else
	{
		int nSlabType = 0;
		GetAt(KEY_KIND, nSlabType);
		if (nSlabType == 1) // 悬挑板
		{
			int nNum = m_polyOutline.Length();
			if (idx >= 1 && idx <= nNum) // 顶点
			{
				m_polyOutline[idx-1]->TransformBy(vtOffset);
			}
			else // 某边中心点
			{
				int nSegIndex = idx - nNum - 1;
				if (nSegIndex < 0 || nSegIndex >= m_polyOutline.TotalSegments())
				{
					return Acad::eOk;
				}

				TGGeCurveSegment seg;
				m_polyOutline.Nth(nSegIndex, seg);
				int nLineType = seg.GetCurveType();
				if ( nLineType == CURVE_LINE)
				{
					// 获取当前边后边的索引
					int nNextIndex = 0;
					if (nSegIndex == nNum - 1)
					{
						nNextIndex = 0;
					}
					else
					{
						nNextIndex = nSegIndex + 1;
					}
					m_polyOutline[nSegIndex]->TransformBy(vtOffset);
					m_polyOutline[nNextIndex]->TransformBy(vtOffset);
    			}
				else if (nLineType == CURVE_ARC)
				{
					TADSGePoint3d ptMid = seg.MidPoint();   
					ptMid += vtOffset;    
					TADSGePoint3d ptS = *m_polyOutline[nSegIndex];
					TADSGePoint3d ptE;
					if (nSegIndex == nNum - 1)
					{
						ptE = *m_polyOutline[0];
					}
					else 
					{
						ptE = *m_polyOutline[nSegIndex + 1];
					}
					TGGeArc arc(ptS, ptMid, ptE);
  					double dbulge = arc.Bulge();
					TADSGePoint3d ptS1;
					arc.GetStartPoint(ptS1);
					if (ptS1.Distance(ptS) > _DIST_SNAP)
					{
						dbulge = -dbulge;
					}
					*m_polyOutline.m_ardbulges[nSegIndex] = dbulge; 
				 }     
			}   

			AcGePoint3d ptPos;
			GetAt(KEY_POS, ptPos);
			TADSGePoint3d ptLow, ptUp;
			m_polyOutline.GetExtend(ptLow, ptUp);
			TADSGePoint3d ptMid;
			Midpoint(ptLow, ptUp, ptMid);
			ptPos.x = ptMid.x;
			ptPos.y = ptMid.y;
			SetAt(KEY_POS, ptPos);
		}
    }
	
	return Acad::eOk;
}

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

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

Acad::ErrorStatus TDbStruFloorSlab::subWblockClone( AcRxObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbStruEntityBase::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
	if (es != Acad::eOk)
		return es;

	TDbStruFloorSlab *pSlab = TDbStruFloorSlab::cast(pClonedObject);
	if (pSlab != NULL)
	{
		pSlab->m_polyOutline = m_polyOutline;
		pSlab->GetSpecialtyData()->Empty();
		*pSlab->GetSpecialtyData() = *GetSpecialtyDataReadOnly();
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::subDeepClone( AcDbObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
	Acad::ErrorStatus es = TDbStruEntityBase::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
	if (es != Acad::eOk)
		return es;
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::GetGripText( int i, CString &cs ) const
{
	assertReadEnabled();
	
	int iCtrl = GetCtrlToggle();
	int iShape(-1);
	GetAt(KEY_SSHAPE, iShape);
	
	if (i == 0)
	{
		cs = _T("移动");
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::ExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();

	if(m_polyOutline.Length() < 2)
	{
		return Acad::eOk;
	}

	// modify by wjx on 120105 设置斜板颜色
	int nColor = dc.GetColor();
	if(IsInclinedSlab())
	{
		dc.SetColor(nInclineColor);
	}

	TGGePoly2D plTop(m_polyOutline);
	plTop.SetElevation(GetTopElev());
	if (plTop.HasArcSegment())
	{
		TGGePoly2D poly;
		plTop.Disperse(poly);
		plTop = poly;
	}

	double dArea = plTop.PathArea();
	if (dArea <= _DIST_SNAP)
	{
		plTop.Reverse();
	}

	if(g_bDetailMode)
	{
		const AcGePoint3d pt0 = *plTop[0];
		const AcGePoint3d pt1 = *plTop[1];
		const AcGePoint3d pt2 = *plTop[2];
		AcGeVector3d vt1 = pt0 - pt1;
		AcGeVector3d vt2 = pt2 - pt1;
		vt1 = vt2.crossProduct(vt1);
		vt1.normalize();	// 朝下

		double dHigh(0);
		GetAt(KEY_THICK, dHigh);
		vt1 *= dHigh;
		// 侧面
		AcGePoint3dArray ptArr;
		for(int i = 0; i < plTop.Length(); i++)
		{
			AcGePoint3d pt = *plTop[i];
			ptArr.append(pt);
			ptArr.append(pt + vt1);
		}
		AcGePoint3d pt = *plTop[0];
		ptArr.append(pt);
		ptArr.append(pt + vt1);
		dc.DrawMesh(plTop.Length() + 1, 2, ptArr.asArrayPtr());

		// 顶面
		TDPtrList<TGGePoly2D> lstHole;
		TDbStruSlabHole *pHole = NULL;
		for (int i = 0; i < m_arAssocHoleIds.length(); i++)
		{
			acdbOpenObject(pHole, m_arAssocHoleIds[i], AcDb::kForRead);
			if (pHole != NULL)
			{
				TGGePoly2D poly2d;
				pHole->GetOutline(poly2d);
				pHole->Close();
				TGGePoly2D *pPolyIn=new TGGePoly2D(poly2d);
				lstHole.Append(pPolyIn);
			}
		}
		dc.DrawShell(plTop, lstHole);

		// 底面
		AcGeMatrix3d mat;
		mat.setTranslation(vt1);
		plTop.TransformBy(mat);
		lstHole.Reset();
		pHole = NULL;
		for (i = 0; i < m_arAssocHoleIds.length(); i++)
		{
			acdbOpenObject(pHole, m_arAssocHoleIds[i], AcDb::kForRead);
			if (pHole != NULL)
			{
				TGGePoly2D poly2d;
				pHole->GetOutline(poly2d);
				pHole->Close();
				poly2d.TransformBy(mat);
				TGGePoly2D *pPolyIn=new TGGePoly2D(poly2d);
				lstHole.Append(pPolyIn);
			}
		}
		dc.DrawShell(plTop, lstHole);
	}
	else
	{
		dc << plTop;
	}

	// modify by xlc on 120112荷载显示控制
	if((DocGetSlabShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == SURFACELOAD)
	{	
		DrawSlabLoad(dc, 1);
	}

	dc.SetColor(nColor);

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::ExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();
	int nSlabType = 0;
	GetAt(KEY_KIND, nSlabType);

	// modify by wjx on 120105 设置斜板颜色
	int nColor = dc.GetColor();
	if(IsInclinedSlab())
	{
		dc.SetColor(nInclineColor);
	}

	if (nSlabType == 0) // 普通板
	{
		TGGePoly2D poly(m_polyOutline);
		poly.SetElevation(0.0); // 二维时z值置为0

		AcDbObjectId idMe = objectId();
		BOOL bHighlight = !idMe;
		int nHLight = 0;
		GetAt(KEY_HLGHT, nHLight);
		if (nHLight == 1 || g_nLoadDrawMode == SURFACELOAD || g_nDrawModeSlab == 1)
		{
			bHighlight = TRUE;
		}
		
		if(bHighlight)
		{
			dc << poly;
		}

		//显示构件编号
		//if(DocGetSlabShowCL())
		{
			DrawClab(dc);
		}

		//显示板厚尺寸
		if(DocGetSlabShowBH())
		{
			DrawBH(dc);		
		}
	} 
	else // 悬挑板
	{
		ExplodeOrDraw2d2(dc);
	}

	// modify by xlc on 120112荷载显示控制
	if((DocGetSlabShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == SURFACELOAD)
	{
		DrawSlabLoad(dc, 0);
	}

	if (g_nDrawModeSlabBorder)			//绘制边界属性
	{
		DrawBorder(dc);
	}

	dc.SetColor( nColor);

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::ExplodeOrDraw2d2( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();
	int nNum = m_polyOutline.TotalSegments();
	TGGeVisibilityPoly2D poly;
	TGGeCurveSegment seg;
	AcDb::Visibility visible;
	for (int i = 0; i < nNum; i++)
	{
		if (IsVisibleAt(i)) // 可见
		{
			m_polyOutline.Nth(i, seg);
			GetPoly(poly, seg);
			poly.SetElevation(0.0);
			for(int j = 0; j < poly.TotalSegments(); j++)
			{
				poly.Nth(j, seg, &visible);
				if (visible == AcDb::kVisible)
				{
					dc << seg;
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::GetExtents2d( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	assertReadEnabled();
	m_polyOutline.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruFloorSlab::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	assertReadEnabled();
	
	GetExtents2d(ptLow, ptUp);

	AcGePoint3d ptPos;
	GetAt(KEY_POS, ptPos);

	double dUpHigh(0);
	GetAt(KEY_UPHIGH, dUpHigh);
	ptUp.z = ptPos.z + dUpHigh;

	double dThick(0);
	GetAt(KEY_THICK, dThick);
	ptLow.z = ptUp.z - dThick;
	
	return Acad::eOk;
}

bool TDbStruFloorSlab::UnifyElevation( double dElevation )
{
	SetTopElev(dElevation);	
	return true;
}

void TDbStruFloorSlab::GetTips(TDPtrList<TObjInfoUnit>& lstInfo) const
{
	assertReadEnabled();
	double dHeight(0);
	GetAt(KEY_THICK, dHeight);
	
	lstInfo.Append(new TObjInfoUnit(_T("板厚"), Dist2Str(dHeight)));
}

const TCHAR * TDbStruFloorSlab::GetDefaultLayer() const
{
	int nSlabType = 0;
	GetAt(KEY_KIND, nSlabType);
	if (nSlabType == 1)		// 悬挑板
	{
		return LAY_S_CSLA;
	}
	return LAY_S_SLAB_PLAN_LINE;
}

BOOL TDbStruFloorSlab::IsValid() const
{
	assertReadEnabled();
	
	double dHigh(0);
	GetAt(KEY_THICK, dHigh);
	if (dHigh <= _DIST_SNAP)
		return FALSE;
	
	if (m_polyOutline.IsClosed() != 1)
		return FALSE;
	
	if (m_polyOutline.IsSelfIntersect())
		return FALSE;
	
	if (m_polyOutline.Area() <= _DIST_SNAP)
		return FALSE;
	
	return TRUE;
}

void TDbStruFloorSlab::CopyPropertiesFrom( AcDbEntity *pSrcEntity, unsigned gMatchFlag )
{
	assertWriteEnabled();
	
	TDbStruEntityBase::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbStruFloorSlab* pSlab = TDbStruFloorSlab::cast(pSrcEntity);
	if (pSlab != NULL)
	{
		AcGePoint3d ptPos;
		GetAt(KEY_POS, ptPos);
		double dThickness(0);
		GetAt(KEY_THICK, dThickness);
		GetSpecialtyData()->Empty();
		GetSpecialtyData()->CopyFrom(pSlab->GetSpecialtyData());
		SetAt(KEY_POS, ptPos);
		SetAt(KEY_THICK, dThickness);

		if(database() == NULL ||
			pSrcEntity->database() == NULL ||
			database() == pSrcEntity->database())
		{
			m_idLayerLoad = pSlab->m_idLayerLoad;
			m_idLayerLoadL = pSlab->m_idLayerLoadL;
			m_idLayerLoadC = pSlab->m_idLayerLoadC;
			m_idTextStyle = pSlab->m_idTextStyle;
			m_idTextStyleRB = pSlab->m_idTextStyleRB;
		}
	}
}

bool TDbStruFloorSlab::GetStandardFaceBody( AcDbVoidPtrArray& arFacePtrs ) const
{
	return false;
}

bool TDbStruFloorSlab::GetSafeProtectedSpace( AcDbVoidPtrArray& arFacePtrs ) const
{
	return false;
}

bool TDbStruFloorSlab::GetSection( const AcDbFace &face, 
								  const AcGeVector3d& vtPlaneSecDir, 
								  std::vector<TObjSectionRecord> &sectionRecords, 
								  AcDbVoidPtrArray& arFillPtrs ) const
{
	return false;
}

CString TDbStruFloorSlab::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_STRU_FLOORSLAB"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("楼板"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));		
	}

	CString strText;
	POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
		strText.Format(_T("%ld"), objectId());
		xmlTree.SetItemText(posItem1, strText);
	}

	POSITION posItem = NULL;
	POSITION posItem2 = xmlTree.Insert(_T("Position"),posRoot, posItem1);
	{ 
		xmlTree.SetAttribute(posItem2, _T("name"), _T("位置点"));
		AcGePoint3d ptPos;
		GetAt(KEY_POS, ptPos);
		TADSGePoint3d ptTransformBy = ptPos;
		ptTransformBy.TransformBy(mat);
		strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
		xmlTree.SetItemText(posItem, strText);
	}

	POSITION posItem3 = xmlTree.Insert(_T("UpHeight"), posRoot, posItem2);
	{
		double dHeight=0;
		GetAt(KEY_UPHIGH, dHeight);
		xmlTree.SetAttribute(posItem3, _T("name"), _T("抬板高度"));
		xmlTree.SetAttribute(posItem3, _T("comment"), _T("楼板抬升高度"));
		strText.Format(_T("%f"), dHeight);
		xmlTree.SetItemText(posItem, strText);
	}

	POSITION posItem5 = xmlTree.Insert(_T("Thick"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem5, _T("name"), _T("楼板厚度"));
		xmlTree.SetAttribute(posItem, _T("comment"), _T("楼板厚度"));
		double dHeight=0;
		GetAt(KEY_THICK, dHeight);
		strText.Format(_T("%f"), dHeight);
		xmlTree.SetItemText(posItem, strText);
	}

	POSITION posItem6 = xmlTree.Insert(_T("Link_Hole"),posRoot, posItem5);
	{ 
		xmlTree.SetAttribute(posItem3, _T("name"), _T("板洞"));

		for (int i = 0; i < m_arAssocHoleIds.length(); i++)
		{
			posItem = xmlTree.Insert(_T("Link_ID"), posItem3, posItem);
			xmlTree.SetAttribute(posItem, _T("name"), _T("洞口句柄"));
			strText.Format(_T("%ld"), m_arAssocHoleIds[i]);
			xmlTree.SetItemText(posItem, strText);
		}
	}

	CString strBase = TEntityBase::GetXml(mat);
	CString strXml = xmlTree.GetXml();
	int nIndex = strXml.Find(_T("<Object_ID"));
	strXml.Insert(nIndex, strBase);

	return strXml;
}

void TDbStruFloorSlab::PostAssocMsg( TAssocMsg assocMsg ) const
{

}

void TDbStruFloorSlab::ReceiveAssocMsg( TAssocMsg assocMsg )
{
	assertWriteEnabled();
#ifdef TESTCASE	
	AcDbObjectIdArray arId;
	arId.append(assocMsg.GetAssocId());
	MakeAssocRelation(arId);
	return;
#endif

}

void TDbStruFloorSlab::MakeAssocRelation( AcDbObjectIdArray& ids )
{
	assertWriteEnabled();
#ifdef TESTCASE
	m_arAssocHoleIds.append(ids);
	return;
#endif

	if (ids.length() < 1)
	{
		return;
	}

	TPickEntSet ss(SS_FREE);
	ads_name eName;
	for (int i = 0; i < ids.length(); i++)
	{
		if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
		{
			ss += ids[i];
		}
	}

	TGGePoly2D poly;						//楼板面
	GetOutline(poly);
	poly.SetElevation(0);

	double dGap(0);
	TEntitySet ent;
	AcDbObjectId idObj;
	for (long j = 0; j < ss.Length(); j++)
	{
		ent = ss[j];
		if (ent.Is(_T("ATS_STRUBEAM")))		//梁
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbBaseWall, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;			//梁,墙平面线
			pEnt->GetPoly2D(polyDest);
			polyDest.SetElevation(0);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
			if(bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();	

			if (!m_arAssocWallIds.contains(idObj)) 
			{
				m_arAssocWallIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_WALL")))		//墙
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;			//梁,墙平面线
			pEnt->GetOutlinePoly1(0, polyDest);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
			if(bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();	

			if (!m_arAssocWallIds.contains(idObj)) 
			{
				m_arAssocWallIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_STRUSLABHOLE")))//板洞
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruSlabHole, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;			//板洞平面线
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
			if(bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();	

			if (!m_arAssocHoleIds.contains(idObj)) 
			{
				m_arAssocHoleIds.append(idObj);
			}
		}
	}
}

// 不验证关系，直接建立关联关系
void TDbStruFloorSlab::MakeAssocRelationDirect(const AcDbObjectId& idObj)
{
	assertWriteEnabled();
	TPickEntSet ss(SS_FREE);
	ss += idObj;

	TEntitySet ent;
	for (long i = 0; i < ss.Length(); i++)
	{
		ent = ss[i];
		if (ent.Is(_T("ATS_STRUBEAM"))
			||ent.Is(_T("ATS_WALL"))) // 梁,墙
		{
			if (!m_arAssocWallIds.contains(idObj)) 
			{
				m_arAssocWallIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_STRUSLABHOLE"))) // 墙洞
		{
			if (!m_arAssocHoleIds.contains(idObj))
			{
				m_arAssocHoleIds.append(idObj);
			}
		}
	}
}

void TDbStruFloorSlab::RemoveAssocRelation( AcDbObjectId& id )
{
	assertWriteEnabled();
	m_arAssocHoleIds.remove(id);
	m_arAssocWallIds.remove(id);
	m_arAssocZIds.remove(id);
}

void TDbStruFloorSlab::GetAssocRelation( int nType, AcDbObjectIdArray& ar ) const
{
	assertReadEnabled();
	ar.setLogicalLength(0);
	
	switch (nType)
	{
	case ASSOC_HOLE:
		ar.append(m_arAssocHoleIds);
		break;
	case ASSOC_Z:
		ar.append(m_arAssocZIds);
		break;
	case ASSOC_XY:
		ar.append(m_arAssocWallIds);
		break;
	case ASSOC_ALL:
		ar.append(m_arAssocHoleIds);
		ar.append(m_arAssocWallIds);
		ar.append(m_arAssocZIds);
		break;
	default:
		break;
	}
}

void TDbStruFloorSlab::GetOutline( TGGePoly2D &poly ) const
{
	assertReadEnabled();
	poly = m_polyOutline;
}

const TGGePoly2D& TDbStruFloorSlab::GetOutlinePoly() const
{
	assertReadEnabled();
	return (TGGePoly2D&)m_polyOutline;
}

void TDbStruFloorSlab::SetOutlinePoly( const TGGePoly2D &poly )
{
	assertWriteEnabled();
	m_polyOutline = poly;
	m_polyOutline.SetFlag(1);	//需要外轮廓线闭合
	if (m_polyOutline.PathArea() > 0) // 顺时针
	{
		m_polyOutline.Reverse(); 
	}
}

double TDbStruFloorSlab::GetTopElev() const
{
	assertReadEnabled();
	AcGePoint3d ptPos = AcGePoint3d::kOrigin;
	GetAt(KEY_POS, ptPos);
	double dUpHigh = 0.0; // 抬板高度
	GetAt(KEY_UPHIGH, dUpHigh);
	return ptPos.z + dUpHigh;
}

void TDbStruFloorSlab::SetTopElev( double dElev )
{
	assertWriteEnabled();	
	AcGePoint3d ptPos = AcGePoint3d::kOrigin;
	GetAt(KEY_POS, ptPos);
	ptPos.z = dElev;
	SetAt(KEY_POS, ptPos);
}

bool TDbStruFloorSlab::IsVisibleAt( int idx ) const
{
	assertReadEnabled();
	ASSERT(idx < m_polyOutline.TotalSegments());
	int nEdge = 0;
	GetAt(KEY_RAILEDGE, nEdge);
	int nTestBit = 0x01;
	nTestBit <<= idx;
	bool bVal = (nEdge&nTestBit) > 0;
	return ((nEdge&nTestBit) > 0);
}

void TDbStruFloorSlab::SetVisibleAt( int idx, bool bHasRail )
{
	assertWriteEnabled();
	ASSERT(idx < m_polyOutline.TotalSegments());
	int nEdge = 0;
	GetAt(KEY_RAILEDGE, nEdge);
	int nTestBit = 0x01;
	nTestBit <<= idx;
	if(bHasRail)
	{
		nEdge |= nTestBit;
	}
	else
	{
		nEdge &= ~nTestBit;
	}
	SetAt(KEY_RAILEDGE, nEdge);
}

void TDbStruFloorSlab::GetPoly( TGGeVisibilityPoly2D &poly, TGGeCurveSegment &seg ) const
{
	seg.SetElevation(0.0);
	TGGePoly2D polyTemp;
	seg.AsPoly2D(polyTemp);
	AcDbCurve *pCurve = polyTemp.AsAcDbCurve();
	if (pCurve == NULL)
	{
		return;
	}

	TADSGePoint3d ptS = seg.StartPoint(), ptE = seg.EndPoint();
	poly.Reset();
	poly.SetAcDbCurve(pCurve);
	TDbWall *pWall = NULL;
	TGGePoly2D poly1;
	AcDbCurve *pTemp = NULL;
	AcGePoint3dArray arPt;
	for (int i = 0; i < m_arAssocWallIds.length(); i++)
	{
		acdbOpenObject(pWall, m_arAssocWallIds[i], AcDb::kForRead);
		if (pWall != NULL)
		{
			pWall->GetOutlinePoly(0,poly1);
			pWall->close();
			
			poly1.SetElevation(0.0);
			pTemp = poly1.AsAcDbCurve();
			if (pTemp != NULL)
			{
				arPt.setLogicalLength(0);
				pTemp->intersectWith(pCurve, AcDb::kOnBothOperands, arPt);
				delete pTemp;
				pTemp = NULL;

				if (arPt.length() == 2)
				{
					poly.InsertNodeAt(arPt[0], arPt[1], AcDb::kInvisible); // 设置为不可见
				}
				else if (arPt.length() == 1)
				{
					int nRet = ptS & poly1;
					if (nRet == PR_EDGE || nRet == PR_INSIDE)
					{
						poly.InsertNodeAt(arPt[0], ptS, AcDb::kInvisible);
					}

					nRet = ptE & poly1;
					if (nRet == PR_EDGE || nRet == PR_INSIDE)
					{
						poly.InsertNodeAt(arPt[0], ptE, AcDb::kInvisible);
					}
				}
			}
		}
	}

	delete pCurve;
}

void TDbStruFloorSlab::AddAssocWallId( const AcDbObjectId &idWall )
{
	m_arAssocWallIds.append(idWall);
}

void TDbStruFloorSlab::RemoveAssocWall()
{
	m_arAssocWallIds.setLogicalLength(0);
}


// 显示板厚
void TDbStruFloorSlab::DrawBH(TGGiExplodeDrawBase &dc) const
{
	assertReadEnabled();
	TDbText text;

	// 得到文字样式
	AcDbObjectId idFloorBHStyl = DocGetSlabBHStyle();
	if(idFloorBHStyl.isNull())
	{
		idFloorBHStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idFloorBHStyl);			// 设置文字样式

	text.SetHeight(DocGetSlabBHHigh());		// 设置楼板尺寸文字高度			

	int nColor = IsInclinedSlab()? nInclineColor: DocGetSlabBHColor();
	text.setColorIndex(nColor);// 设置尺寸文字颜色

	text.SetAlignment(XExplodeDraw::kCenter);// 设置文字的对齐方式

	CString strText;
	if(1 == DocGetSlabShowBH())				// 显示板的标高和板厚
	{
		double dTHick, dEle;
		GetAt(KEY_THICK, dTHick);			// 得到板厚
		CString strThick = Dist2Str(dTHick);
		strText = strThick;

		GetAt(KEY_UPHIGH, dEle);			// 得到楼板的标高
		if(fabs(dEle) > _DIST_SNAP)			// 如果楼板的标高不为0则显示
		{
			CString strEle = Dist2Str(dEle);
			strText += _T("/");
			strText += strEle;
		}
	}
	else if(2 == DocGetSlabShowBH())		// 荷载和荷载编号
	{

	}
	text.SetText(strText);					// 设置文字内容

	AcGePoint3d ptInsert;
	GetAt(KEY_POS, ptInsert);				 // 得到楼板的插入位置
	ptInsert.z = 0;
	ptInsert.y -= DocGetSlabBHHigh()*GetPScale();// 将文字显示的位置设置在楼板形心的下部
	text.SetLocation(ptInsert);				// 设置文字的插入位置

	text.ExplodeOrDraw2d(dc);
}

// 显示板的构件编号
void TDbStruFloorSlab::DrawClab(TGGiExplodeDrawBase &dc) const
{
	assertReadEnabled();
	TDbText text;

	// 得到文字样式ID
	AcDbObjectId idFloorCLStyl = DocGetSlabCLStyle();
	if(idFloorCLStyl.isNull())
	{
		idFloorCLStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idFloorCLStyl);			// 设置文字样式

	text.SetHeight(DocGetSlabCLHigh());		// 设置文字高度			

	int nColor = IsInclinedSlab()? nInclineColor: DocGetSlabBHColor();
	text.setColorIndex(nColor);// 设置文字颜色

	text.SetAlignment(XExplodeDraw::kCenter);// 设置文字对齐方式

	CString strText;
	GetAt(KEY_CLAB, strText);
	text.SetText(strText);					// 得到楼板的构建编号

	AcGePoint3d ptInsert;
	GetAt(KEY_POS, ptInsert);				// 得到楼板的插入位置
	ptInsert.z = 0;
	text.SetLocation(ptInsert);				// 设置文字的插入位置

	text.setLayer(DocGetSlabCLLayer());		// 设置文字图层

	text.ExplodeOrDraw2d(dc);				// 画文字对象
}

// add by wjx on 111226
// 绘制楼面荷载信息
void TDbStruFloorSlab::DrawSlabLoad(TGGiExplodeDrawBase &dc, int n2dOr3dFlag)const
{
	//if(NULL == g_pStruSubProject)
	//{
	//	return;
	//}

	//add by xlc on 120112荷载显示控制
	BOOL bShowGraphic = false;		//显示图形
	BOOL bShowLive = false;			//显示活荷
	BOOL bShowUnLive = false;		//显示恒荷

	if(g_nLoadDrawMode == BYOBJLOAD)
	{
		bShowGraphic = true;
		bShowLive = bShowUnLive = DocGetShowLoadPara();
	}
	else
	{
		bShowGraphic = GetViewStyle(BYGRAPHIC);
		bShowLive = GetViewStyle(BYVARYING);
		bShowUnLive = GetViewStyle(BYUNVARYING);
	}

	//都不显示时直接返回
	if (!(bShowGraphic||bShowLive||bShowUnLive))
	{
		return;
	}
	
	// modify by wjx on 120130 修改荷载的读取方式
	std::vector<TStruLoad> vecLoad;
	GetLoadsArray(vecLoad);
	int nSize = vecLoad.size();
	if(nSize < 1)
	{
		return;
	}

	TStruLoad loadData;
	//int nColor = dc.GetColor();
	TPushProperty vProp(this, dc);
	if (m_idLayerLoad.isValid())
	{
		dc.SetLayer(m_idLayerLoad);
	}

	for(int i = 0; i < nSize; i++)
	{
		loadData = vecLoad[i];

		if (bShowGraphic)
		{
			DrawSlabLoad2dOr3d(dc, loadData, n2dOr3dFlag);
		}

		if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
			||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
			)
		{
			DrawSlabLoadText2dOr3d(dc, loadData, n2dOr3dFlag);
		}
	}
	//dc.SetColor(nColor);

// 	AcDbHandle hBeam;
// 	getAcDbHandle(hBeam);
// 	int nHandle = hBeam.low();
// 
// 	// 在自然层中找到该句柄对应的荷载信息
// 	int nSize = g_pStruSubProject->m_vecFloorData.size();// 自然层数
// 	int nLoadSize = 0;						// 自然层中荷载数量
// 	TStruEntLoads entLoad;
// 	bool bFind = false;						// 是否找到荷载信息
// 	for(int i = 0; i < nSize; i++)
// 	{
// 		nLoadSize = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads.size();
// 		for (int j = 0; j < nLoadSize; j++)
// 		{
// 			entLoad = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j];
// 
// 			if (entLoad.GetEntHandle().low() == nHandle)
// 			{
// 				bFind = true;
// 				int nColor = dc.GetColor();
// 				// 得到荷载数据
// 				int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
// 				TStruLoad loadData;
// 				for(int k = 0; k < nLoadInfoCount; k++)
// 				{
// 					loadData = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads[k];
// 					
// 					if (bShowGraphic)
// 					{
// 						DrawSlabLoad2dOr3d(dc, loadData, n2dOr3dFlag);
// 					}
// 
// 					if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
// 						||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
// 						)
// 					{
// 						DrawSlabLoadText2dOr3d(dc, loadData, n2dOr3dFlag);
// 					}
// 				}
// 				dc.SetColor(nColor);
// 				break;
// 			}
// 		}
// 
// 		if(bFind)
// 		{
// 			break;
// 		}
// 	}
}

// add by wjx on 111226
// 绘制荷载
void TDbStruFloorSlab::DrawSlabLoad2dOr3d(TGGiExplodeDrawBase &dc, TStruLoad loadData, int n2dOr3dFlag) const
{
	//if(!GetViewStyle(BYGRAPHIC))
	//{
	//	return;
	//}

	//dc.SetColor(7);
	TGGePoly2D poly = GetOutlinePoly();

	TGGeCurveSegment segOne, segSec, segTemp;

	XPoint pt[4], ptTemp;

	// 得得到各方向的线
	int nType = loadData.GetLoadType();
	if(nType == 1 || nType == 2)
	{
		pt[0] = poly.GetPointListAt(0)->AsAcGePoint3d();
		pt[1] = poly.GetPointListAt(1)->AsAcGePoint3d();
		pt[2] = poly.GetPointListAt(2)->AsAcGePoint3d();
		pt[3] = poly.GetPointListAt(3)->AsAcGePoint3d();
		double dMin, dMax;
		// 得到左侧的两个点和右侧的两个点
		bool blSwitch = false;
		for(int i = 0; i < 3; i++)
		{
			for(int j = 0; j < 3-i; j++)
			{
				dMin = pt[j].x;
				dMax = pt[j+1].x;

				if(dMin - dMax > _DIST_SNAP)
				{
					ptTemp = pt[j];
					pt[j] = pt[j+1];
					pt[j+1] = ptTemp;

					blSwitch = true;
				}
				else if(fabs(dMin - dMax) <= _DIST_SNAP)
				{
					dMin = pt[j].y;
					dMax = pt[j+1].y;
					if(dMin - dMax > _DIST_SNAP)
					{
						ptTemp = pt[j];
						pt[j] = pt[j+1];
						pt[j+1] = ptTemp;

						blSwitch = true;
					}
				}
			}

			if(!blSwitch)
			{
				break;
			}
		}
		
		segOne = TGGeCurveSegment(pt[0], (nType == 1)? pt[1]: pt[2], 0);
		segSec = TGGeCurveSegment((nType == 1)?pt[2]: pt[1],  pt[3], 0);

		segTemp = TGGeCurveSegment(pt[0], segOne.MidPoint(), 0);
		ptTemp = segTemp.MidPoint();

		segSec.ProjectToMe(ptTemp, ptTemp);
		segTemp = TGGeCurveSegment(segTemp.MidPoint(), ptTemp, 0);
 		if(n2dOr3dFlag == 0)
 		{
 			segTemp.SetElevation(0.0);
 		}
		dc.DrawCurve(segTemp);
		
		segSec.ProjectToMe(segOne.MidPoint(), ptTemp);
		segTemp = TGGeCurveSegment(segOne.MidPoint(), ptTemp, 0);
		if(n2dOr3dFlag == 0)
		{
			segTemp.SetElevation(0.0);
		}
		if(nType == 1)
		{
			dc.DrawCurve(segTemp);
		}

		segTemp = TGGeCurveSegment((nType == 1)? pt[1]: pt[2], segOne.MidPoint(), 0);
		ptTemp = segTemp.MidPoint();
		segSec.ProjectToMe(ptTemp, ptTemp);
		segTemp = TGGeCurveSegment(segTemp.MidPoint(), ptTemp, 0);
		if(n2dOr3dFlag == 0)
		{
			segTemp.SetElevation(0.0);
		}
		dc.DrawCurve(segTemp);
	}
	else if(nType == 3)
	{
		poly.Nth(0, segOne);
		poly.Nth(1, segSec);

		TGGeCurveSegment segLeft, segRight;
		TADSGePointDir2d ptL, ptR;
		if(segOne.GetLength() - segSec.GetLength() < g_distZero)
		{
			poly.Nth(2, segSec);
		}
		else
		{
			poly.Nth(3, segOne);
		}

		if(n2dOr3dFlag == 0)
		{
 			segOne.SetElevation(0.0);
 			segSec.SetElevation(0.0);	
		}

		segTemp = TGGeCurveSegment(segOne.MidPoint(), segSec.MidPoint(), 0);
		pt[0] = segOne.StartPoint();
		pt[1] = segOne.EndPoint();

		double dDis = segOne.GetLength()/2;
		segTemp.Polar(dDis, ptL);
		
		segOne = TGGeCurveSegment(pt[0], ptL, 0);
		if(n2dOr3dFlag == 0)
		{
			segOne.SetElevation(0.0);
		}
		dc.DrawCurve(segOne);

		segOne = TGGeCurveSegment(pt[1], ptL, 0);
		dc.DrawCurve(segOne);

		pt[0] = segSec.GetStartPoint();
		pt[1] = segSec.GetEndPoint();

		dDis = segTemp.GetLength() - segSec.GetLength()/2;
		segTemp.Polar(dDis, ptR);
	
		segOne = TGGeCurveSegment(pt[0], ptR, 0);
		if(n2dOr3dFlag == 0)
		{
			segOne.SetElevation(0.0);
		}
		dc.DrawCurve(segOne);

		segOne = TGGeCurveSegment(pt[1], ptR, 0);
		if(n2dOr3dFlag == 0)
		{
			segOne.SetElevation(0.0);
		}
		dc.DrawCurve(segOne);

		segOne = TGGeCurveSegment(ptL, ptR, 0);
		if(n2dOr3dFlag == 0)
		{
			segOne.SetElevation(0.0);
		}
		dc.DrawCurve(segOne);

	}
	else if(nType == 4)
	{
		if(n2dOr3dFlag == 0)
		{
	 		poly.SetElevation(0.0);
		}
		TGGePoly2D polyOffset;
		if (poly.Offset(-200.0, polyOffset) == RTNORM)
		{
			dc.DrawXPoly(polyOffset);
		}
	}
}

// add by wjx on 111227
// 绘制荷载的文字信息
void TDbStruFloorSlab::DrawSlabLoadText2dOr3d(TGGiExplodeDrawBase &dc, TStruLoad loadData,
											  int n2dOr3dFlag) const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	//if(!GetViewStyle(nKind))
	//{
	//	return;
	//}

	TGGePoly2D poly = GetOutlinePoly();
	XPoint pt[4], ptTemp;

	pt[0] = poly.GetPointListAt(0)->AsAcGePoint3d();
	pt[1] = poly.GetPointListAt(1)->AsAcGePoint3d();
	pt[2] = poly.GetPointListAt(2)->AsAcGePoint3d();
	pt[3] = poly.GetPointListAt(3)->AsAcGePoint3d();
	// 得到左侧的两个点和右侧的两个点
	bool blSwitch = false;
	for(int i = 0; i < 3; i++)
	{
		for(int j = 0; j < 3-i; j++)
		{
			if(pt[j].x > pt[j+1].x)
			{
				ptTemp = pt[j];
				pt[j] = pt[j+1];
				pt[j+1] = ptTemp;

				blSwitch = true;
			}
		}

		if(!blSwitch)
		{
			break;
		}
	}

	TGGeCurveSegment segLeft = TGGeCurveSegment(pt[0], pt[1], 0);
	TGGeCurveSegment segRight = TGGeCurveSegment(pt[2], pt[3], 0);

	XPoint ptMidL = segLeft.MidPoint();
	XPoint ptMidR = segRight.MidPoint();

	double dAngle = ads_angle(ptMidL, ptMidR);
	
	while(dAngle<0)
	{
		dAngle += PI;
	}

	while (dAngle > PI/2)
	{
		dAngle -= PI/2;
	}

	// 设置文字
	AcDbText text;
	text.setHeight(DocGetLoadTextHeight());// 设置文字高度	

	AcGePoint3d ptInsert;
	GetAt(KEY_POS, ptInsert);				// 得到楼板的插入位置

	CString strNo, strLoadText;
	GetAt(KEY_CLAB, strNo);

	text.setTextString(strNo);

	// modify by wjx on 120326
// 	strLoadText.Format(_T("%.1f"), loadData.GetValue());
	strLoadText = TrimDoubleZero(loadData.GetValue());

	XPoint ptText;
	ads_matrix matMove, matRot;

	if(n2dOr3dFlag == 0)
	{
		double dDis = fabs(pt[0].y-pt[1].y)/4.0;

		XPoint(ptInsert).GetMoveMatrix(XPoint(ptInsert.x, ptInsert.y+dDis, ptInsert.z), matMove);
		XPoint(ptInsert).GetRotationMatrix(dAngle, matRot);
		ptText = XPoint(ptInsert);
		ptText.TransformBy(matRot);
		ptText.TransformBy(matMove);

		text.setPosition(XPoint(ptText.x, ptText.y, 0));
		text.setColorIndex(1);
		dc.DrawEntity(text);
		//text.setColorIndex(256);
		
		text.setTextString(strLoadText);
		
		TPushProperty vProp(this, dc);
		
		if(nKind == TStruLoad::LK_UNVARYING)
		{
			text.setPosition(XPoint(ptInsert.x, ptInsert.y, 0));
			//text.setColorIndex(7);
			if (m_idLayerLoadC.isValid())
			{
				dc.SetLayer(m_idLayerLoadC);
				text.setLayer(m_idLayerLoadC);				
			}
		}
		else
		{
			XPoint(ptInsert).GetMoveMatrix(XPoint(ptInsert.x, ptInsert.y-dDis, ptInsert.z), matMove);
			ptText = XPoint(ptInsert);
			ptText.TransformBy(matRot);
			ptText.TransformBy(matMove);

			text.setPosition(XPoint(ptText.x, ptText.y, 0));
			//text.setColorIndex(2);
			if (m_idLayerLoadL.isValid())
			{
				dc.SetLayer(m_idLayerLoadL);
				text.setLayer(m_idLayerLoadL);
			}
		}
		dc.DrawEntity(text);
	}
	else
	{
		// 设置文字法向
		if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
		{
			AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();

			AcGePoint3d ptCamera, ptTarget;
			vp.getCameraTarget(ptTarget);
			vp.getCameraLocation(ptCamera);

			AcGeVector3d vtViewDrt = ptCamera-ptTarget;
			AcGeVector3d vtViewDir1= vp.viewDir();

			AcGeVector3d vtCamera;
			vp.getCameraUpVector(vtCamera);

			vtViewDrt.normalize();

			text.setNormal(vtViewDrt);
		}

		text.setPosition(XPoint(ptInsert.x, ptInsert.y, ptInsert.z+2*DocGetLoadTextHeight()));
		text.setColorIndex(1);
		dc.DrawEntity(text);

		text.setColorIndex(256);
		text.setTextString(strLoadText);
		TPushProperty vProp(this, dc);
		if(nKind == TStruLoad::LK_UNVARYING)
		{
			text.setPosition(XPoint(ptInsert.x, ptInsert.y, ptInsert.z+DocGetLoadTextHeight()));
			//text.setColorIndex(7);
			if (m_idLayerLoadC.isValid())
			{
				dc.SetLayer(m_idLayerLoadC);
				text.setLayer(m_idLayerLoadC);
			}
		}
		else
		{
			text.setPosition(ptInsert);
			//text.setColorIndex(2);
			if (m_idLayerLoadL.isValid())
			{
				dc.SetLayer(m_idLayerLoadL);
				text.setLayer(m_idLayerLoadL);
			}
		}
		dc.DrawEntity(text);
	}
}

// add by wjx 0n 120105 
// 判断是否为斜板
// return: TRUE:是斜板 FALSE:不是斜板
BOOL TDbStruFloorSlab::IsInclinedSlab()const
{
	TGGePoly2D poly;
	poly = GetOutlinePoly();

	XPoint ptVertex;
	int iPointNum = poly.Length();						  // 得到poly的顶点个数
	if(iPointNum > 0)
	{
		ptVertex = poly.GetPointListAt(0)->AsAcGePoint3d();
		double dZ = ptVertex.z;											  // z坐标
		for (int i = 1; i < iPointNum; i++)
		{
			ptVertex = poly.GetPointListAt(i)->AsAcGePoint3d();// 得到poly的第i个顶点
			
			// 通过z坐标判断是否是斜板
			if(fabs(dZ - ptVertex.z) > _DIST_SNAP)
			{
				return TRUE;
			}
		}
	}

	return FALSE;
}

void TDbStruFloorSlab::DrawBorder(TGGiExplodeDrawBase &dc)const
{
	TGGeCurveSegment seg, segLeft, segRight;
	TGGePoly2D poly;
	GetOutline(poly);

	int nBoundType = 0;		//保存边界条件类型
	Adesk::Int16 nOldColorIndex = dc.GetColor();

	double dOffsetDis = 0.0;	//偏移距离
	int nSegNum = poly.TotalSegments();
	int nSide = 0;
	for (int i = 0; i < nSegNum; i++)
	{
		poly.Nth(i, seg);

		if (!GetBound(i, nBoundType))//取得边界类型和边界
		{
			continue;
		}
		
		if (i == 0)
		{
			poly.Nth(nSegNum - 1, segLeft);
			poly.Nth(i + 1, segRight);
		}
		else if (i == nSegNum - 1)
		{
			poly.Nth(i-1, segLeft);
			poly.Nth(0, segRight);
		}
		else
		{
			poly.Nth(i - 1, segLeft);
			poly.Nth(i + 1, segRight);
		}

		GetBoundSegment(seg, segLeft, segRight ,nSide);

		TADSGePoint3d ptStart = seg.StartPoint();
		TADSGePointDir2d ptDirS, ptDirE;
		TADSGePoint3d ptS,ptE;

		int nNum = 0;
		double dLenth = 0.0;
		double dSpaceLen = 0.0;
		double dSegLenth = seg.GetLength();
		double dBulge = seg.GetBulge();

		switch(nBoundType)				//边界类型
		{
		case FIXBOUNDARY:				//固定边界
			dc.SetColor(1);
			dc.DrawXCurve(seg, 0);

			nNum = dSegLenth / BOUNDARYSPACE;

			//绘制短线
			for (int n = 0; n < nNum - 1; n++)
			{
				dLenth = (n + 1) * dSegLenth / nNum;
				seg.Polar(dLenth, ptDirS);
				ptS = ptDirS.AsAcGePoint3d();
				if (fabs(seg.GetBulge()) < _angSnap)
				{
					ads_polar(ptS, seg.Direction(ptS) + PI/2 , FIXBOUNDARYLEN, ptE);
				}
				else
				{
					ads_polar(ptS, nSide==OFFSET_LEFT ? seg.Direction(ptS) + PI/2 : seg.Direction(ptS) - PI/2 , FIXBOUNDARYLEN, ptE);
				}
				TGGeCurveSegment segTemp(ptS, ptE, 0.0);
				dc.DrawXCurve(segTemp, 0);
			}
			break;
		case SIMBOUNDARY:				//简支边界
			dc.SetColor(5);
			dc.DrawXCurve(seg, 0);
			break;
		case FREEBOUNDARY:				//自由边界
			dc.SetColor(5);
			dSpaceLen = 2 * BOUNDARYSPACE;//自由边界时短线和短线之间间距的长度

			nNum = dSegLenth / dSpaceLen;
			if (nNum%2 == 0)			  //为了保证将边界线偶数等分
			{
				nNum = nNum + 1;
			}

			dSpaceLen = dSegLenth / nNum;

			//以一定距离绘制边界线
			for (int j = 0; j < nNum; j = j + 2)
			{
				dLenth = j * dSpaceLen;
				seg.Polar(dLenth, ptDirS);
				ptS = ptDirS.AsAcGePoint3d();
				seg.Polar(dLenth + dSpaceLen, ptDirE);
				ptE = ptDirE.AsAcGePoint3d();

				dBulge = dBulge / nNum;

				TGGeCurveSegment segment(ptS, ptE, dBulge);
				dc.DrawXCurve(segment, 0);				
			}
			break;
		default:
			dc.SetColor(0);
			dc.DrawXCurve(seg,0);
			break;
		}	
	}
	dc.SetColor(nOldColorIndex);
}
void TDbStruFloorSlab::GetBoundSegment(TGGeCurveSegment &cvSeg, TGGeCurveSegment cvLeftSeg, TGGeCurveSegment cvRightSeg, int &nSide) const
{
	AcDbObjectIdArray idArray;
	GetAssocRelation(ASSOC_ALL, idArray);

	TGGePoly2D poly;
	GetOutline(poly);				//楼板poly
	TGGeCurveSegment cvBase;		//求的所求线段左右两边直线
	bool bLeft = false, bRight = false, bBase = false;	//保存是否是所得的三根线
	TADSGePoint3d ptLeftMid = cvLeftSeg.MidPoint(), ptRightMid = cvRightSeg.MidPoint(), ptSegMid = cvSeg.MidPoint();
	double dWidth = 0;

	TGGeCurveSegment segTemp = cvSeg;
	TADSGePoint3d ptTemp;
	for (int i = 0; i < idArray.length(); i++)
	{
		OPENOBJ_BEGIN(idArray[i], AcDb::kForRead, TDbBaseWall, pWall);
		if (pWall == NULL)
		{
			continue;
		}

		cvBase = pWall->GetLongBaseLine();
		pWall->GetTotalWidth(dWidth);
		dWidth = dWidth / 2;

		double dDist = cvBase.GetDist2Me(ptSegMid);
		if (fabs(cvBase.GetDist2Me(ptSegMid)) < _DIST_SNAP 
			&& fabs(cvBase.MidPoint().Distance2d(ptSegMid)) < _DIST_SNAP)//将选择的楼板的边偏移到梁，或者墙边线上
		{
			nSide = GetOffsetSegment(cvSeg, poly, dWidth);
			segTemp = cvSeg;
			bBase = true;
		}
		else if (fabs(cvBase.GetDist2Me(ptLeftMid)) < _DIST_SNAP		//将与cvSeg相邻的边进行偏移
			&& fabs(cvBase.MidPoint().Distance2d(ptLeftMid)) < _DIST_SNAP)
		{
			GetOffsetSegment(cvLeftSeg, poly, dWidth);
			bLeft = true;
		}
		else if (fabs(cvBase.GetDist2Me(ptRightMid)) < _DIST_SNAP		//将与cvSeg相邻的另外一条边进行偏移
			&& fabs(cvBase.MidPoint().Distance2d(ptRightMid)) < _DIST_SNAP)
		{
			GetOffsetSegment(cvRightSeg, poly, dWidth);
			bRight = true;
		}

		if (bLeft && bRight && bBase)
		{
			break;
		}
		OPENOBJ_END();
	}

	TADSGePoint3d pt1, pt2;
	int nInterNum = cvSeg.Intersection(cvLeftSeg, pt1, pt2);

	if (nInterNum > 0)		//如果有交点
	{
		if(nInterNum == 2)	//如果有两个交点，需要求出两个交点中哪一个是需要使用的点
		{
			TADSGePoint3d ptS = cvLeftSeg.StartPoint(), ptE = cvLeftSeg.EndPoint();
			double dDist1 = ptS.Distance2d(pt1);

			//求出两个交点与cvleftseg的两个端点的距离最近
			//说明这个交点是需要使用的交点
			if (ptE.Distance2d(pt1) < dDist1)
			{
				dDist1 = ptE.Distance2d(pt1);
			}

			double dDist2 = ptS.Distance2d(pt2);
			if (ptE.Distance2d(pt2) < dDist2)
			{
				dDist2 = ptE.Distance2d(pt2);
			}

			if (dDist1 > dDist2)
			{
				pt1 = pt2;
			}
		}

		if (cvSeg.StartPoint().Distance2d(pt1) < cvSeg.EndPoint().Distance(pt1))
		{
			cvSeg.SetStartPoint(pt1);
		}
		else
		{
			cvSeg.SetEndPoint(pt1);
		}
	}

	nInterNum = cvSeg.Intersection(cvRightSeg, pt1, pt2);
	if (nInterNum > 0)		//cvseg与cvRightSeg有交点
	{
		if (nInterNum == 2)	//如果有两个交点，需要判断哪个交点是需要使用的交点
		{
			TADSGePoint3d ptS = cvRightSeg.StartPoint(), ptE = cvRightSeg.EndPoint();
			double dDist1 = ptS.Distance2d(pt1);

			if (ptE.Distance2d(pt1) < dDist1)	//求ptE,ptS两点中离pt1最近的点
			{
				dDist1 = ptE.Distance2d(pt1);
			}

			double dDist2 = ptS.Distance2d(pt2);
			if (ptE.Distance2d(pt2) < dDist2)
			{
				dDist2 = ptE.Distance2d(pt2);
			}

			if (dDist1 > dDist2)
			{
				pt1 = pt2;
			}
		}

		if (cvSeg.StartPoint().Distance2d(pt1) < cvSeg.EndPoint().Distance(pt1))
		{
			cvSeg.SetStartPoint(pt1);
		}
		else
		{
			cvSeg.SetEndPoint(pt1);
		}
	}

	//如果要是弧线边，需要处理bulge值
	if (fabs(cvSeg.GetBulge()) > _angSnap)	
	{
		//求出cvseg的长度，根据长度换算出cvseg的bulge值
		double dDistance = segTemp.GetLength() - segTemp.PathDistance(cvSeg.EndPoint(), 0) - segTemp.PathDistance(cvSeg.StartPoint());
		cvSeg.SetBulge(segTemp.GetBulge() * dDistance / segTemp.GetLength());
	}

}

//add by lgy 20120706	该函数功能是对cvSeg进行偏移dOffsetDis,偏移后保证其仍在poly中
int TDbStruFloorSlab::GetOffsetSegment(TGGeCurveSegment &cvSeg, TGGePoly2D poly, double dOffsetDis) const
{
	TGGeCurveSegment segTemp = cvSeg;
	TADSGePoint3d ptTemp;

	segTemp = segTemp.Offset(OFFSET_LEFT, dOffsetDis, LS_INFINITE);
	ptTemp = segTemp.MidPoint();
	int nSide = OFFSET_LEFT;
	if ((ptTemp&poly) != PR_OUTSIDE)
	{
		cvSeg = segTemp;
	}
	else
	{
		cvSeg = cvSeg.Offset(OFFSET_RIGHT, dOffsetDis, LS_INFINITE);
		nSide = OFFSET_RIGHT;
	}

	return nSide;
}

//add by xlc on 120118
//设置荷载数组
bool TDbStruFloorSlab::SetLoadsArray(const std::vector<TStruLoad>& vectLoads)
{
	assertWriteEnabled();
	ClearLoadsArray();
	return SetAt(KEY_SLAB, vectLoads);
}
//获得荷载数组
bool TDbStruFloorSlab::GetLoadsArray(std::vector<TStruLoad>& vectLoads)const
{
	assertReadEnabled();
	return GetAt(KEY_SLAB, vectLoads);
}
//清除荷载数组
void TDbStruFloorSlab::ClearLoadsArray()
{
	assertWriteEnabled();
	RemoveLoadsKey(KEY_SLAB);
}

//add by xlc on 130621
//设置边界属性数组
bool TDbStruFloorSlab::SetBoundArray(const std::vector<int>& vectBound)
{
	assertWriteEnabled();
	ClearBoundArray();
	
	int nLength = vectBound.size();
	SetAt(KEY_BOUND, nLength);

	CString sSubKey;
	for (int i = 0;i < nLength; i++)
	{
		sSubKey.Format(_T("%s%d"), KEY_BOUND, i);
		SetAt(sSubKey, vectBound[i]);		
	}

	return true;

}
bool TDbStruFloorSlab::GetBoundArray(std::vector<int>& vectBound)const
{
	assertReadEnabled();

	vectBound.clear();
	int nLength = 0;
	GetAt(KEY_BOUND, nLength);

	CString sSubKey;
	double dVal = 0;
	int nVal = 0;

	int i = 0;
	for(; i < nLength; i++)
	{
		sSubKey.Format(_T("%s%d"), KEY_BOUND, i);
		if (GetAt(sSubKey, nVal))
		{
			vectBound.push_back(nVal);
		}
	}

	return (vectBound.size() > 0);
}
void TDbStruFloorSlab::ClearBoundArray()
{
	assertWriteEnabled();

	int nLength = 0;
	GetAt(KEY_BOUND, nLength);
	GetSpecialtyData()->RemoveAt(KEY_BOUND);

	CString sSubKey;
	for (int i = 0;i < nLength; i++)
	{
		sSubKey.Format(_T("%s%d"),KEY_BOUND, i);
		GetSpecialtyData()->RemoveAt(sSubKey);
	}
}

void TDbStruFloorSlab::SetBound(int nIndex, int nVal)
{
	assertWriteEnabled();

	int nLength = 0;
	GetAt(KEY_BOUND, nLength);
	if (nIndex < nLength)
	{
		CString sSubKey;
		sSubKey.Format(_T("%s%d"), KEY_BOUND, nIndex);
		SetAt(sSubKey, nVal);	
	}
}
bool TDbStruFloorSlab::GetBound(int nIndex, int& nVal)const
{
	assertReadEnabled();

	nVal = FIXBOUNDARY;
	int nLength = 0;
	GetAt(KEY_BOUND, nLength);
	if (nIndex < nLength)
	{
		CString sSubKey;
		sSubKey.Format(_T("%s%d"), KEY_BOUND, nIndex);
		return GetAt(sSubKey, nVal);	
	}
	return false;
}
//荷载
AcDbObjectId TDbStruFloorSlab::GetLayerLoad() const
{
	return m_idLayerLoad;
}
void TDbStruFloorSlab::SetLayerLoad(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoad = idLayer;
}

//活荷值
AcDbObjectId TDbStruFloorSlab::GetLayerLoadL() const
{
	return m_idLayerLoadL;
}
void TDbStruFloorSlab::SetLayerLoadL(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadL = idLayer;
}

//恒荷值
AcDbObjectId TDbStruFloorSlab::GetLayerLoadC() const
{
	return m_idLayerLoadC;
}
void TDbStruFloorSlab::SetLayerLoadC(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadC = idLayer;
}

//文字样式
AcDbObjectId TDbStruFloorSlab::GetTextStyle() const
{
	return m_idTextStyle;
}
void TDbStruFloorSlab::SetTextStyle(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyle = idLayer;
}

//文字样式
AcDbObjectId TDbStruFloorSlab::GetTextStyleRB() const
{
	return m_idTextStyleRB;
}
void TDbStruFloorSlab::SetTextStyleRB(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyleRB = idLayer;
}

int TDbStruFloorSlab::GetFirstVersion()const
{
	return 10;
}
bool TDbStruFloorSlab::IsModelEntity() const
{
	return true;
}


void InitStruFloorSlab(bool bTrue)
{
	if (bTrue)
	{
		TDbStruFloorSlab::rxInit();
		acrxBuildClassHierarchy();
		TDbStruFloorSlab::InitMatchProtocol(TRUE);
	} 
	else
	{
		TDbStruFloorSlab::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbStruFloorSlab::desc());
	}
}
#endif