#include "stdafx.h"
#include "AecOutDrawingJig.h"
#include "KTTempTol.h"
#include "aecdbObjXDataMap.h"
#include "KTCADUtilityEx.h"
#include "EarThwormDef.h"

extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb,bool bClose);

static void FreeBuffer(int n,const AcDbVoidPtrArray& arEntPtrs)
{
	AcDbEntity* pEnt = NULL;
	for (int i = n;i < arEntPtrs.length();i++)
	{
		pEnt = (AcDbEntity*)arEntPtrs.at(i);
		DELETE_PTR(pEnt);
	}
}

AecDrawingFrmsEntity::AecDrawingFrmsEntity()
{}

AecDrawingFrmsEntity::~AecDrawingFrmsEntity()
{}

void AecDrawingFrmsEntity::AppendDrawFrame(AcGePoint3d* pptGe,int nCount)
{
	if (nCount == 5 && pptGe != NULL)
	{
		DrawFrame frm;
		memcpy(frm.ptGe,pptGe,nCount * sizeof(AcGePoint3d));
		frm.ptPick.set(0,0,0);
		m_arDrawFrames.append(frm);
	}
}

int AecDrawingFrmsEntity::GetDrawFrames(AcArray<DrawFrame>& arDrawFrames)
{
	arDrawFrames.append(m_arDrawFrames);
	return arDrawFrames.length();
}

void AecDrawingFrmsEntity::SetDrawingEnts(const AcDbVoidPtrArray& arEntPtrs)
{
	m_arEntPtrs.append(arEntPtrs);
}

#if ARX < 18
Adesk::Boolean AecDrawingFrmsEntity::worldDraw (AcGiWorldDraw *mode)
{
	return worldDraw2d(mode);
}
#else
Adesk::Boolean AecDrawingFrmsEntity::subWorldDraw (AcGiWorldDraw *mode)
{
	return worldDraw2d(mode);
}
#endif

Adesk::Boolean AecDrawingFrmsEntity::worldDraw2d(AcGiWorldDraw *mode)
{
	int nBk = mode->subEntityTraits().color();
	mode->subEntityTraits().setColor(1);
	for (int i = 0;i < m_arDrawFrames.length();i++)
	{
		mode->geometry().polyline(5,m_arDrawFrames.at(i).ptGe);
	}

	mode->subEntityTraits().setColor(nBk);
	
	AcGiDrawable* pAble = NULL;
	AcDbEntity* pEnt = NULL;
	for (int k = 0;k < m_arEntPtrs.length();k++)
	{
		pEnt = (AcDbEntity*)m_arEntPtrs.at(k);

		pAble = pEnt->drawable();
		if (pAble != NULL)
			mode->geometry().draw(pAble);
	}
	return Adesk::kTrue;
}

AecOutDrawingJig::AecOutDrawingJig(void)
{
	m_pDrawingFrms = new AecDrawingFrmsEntity;
	m_bIsShowEntPtrs = false;
	m_bExtValid = false;
	m_bHasRoadLine = true;
	m_ptGe.set(0,0,0);
}

AecOutDrawingJig::~AecOutDrawingJig(void)
{
	DELETE_PTR(m_pDrawingFrms);

	CUIntArray* pGroups = NULL;
	for (int i = 0;i < m_arIndexsGrpPtrs.GetSize();i++)
	{
		pGroups = (CUIntArray*)m_arIndexsGrpPtrs.GetAt(i);
		DELETE_PTR(pGroups);
	}
	m_arIndexsGrpPtrs.RemoveAll();
}

void AecOutDrawingJig::SetDrawingEnts(const AcDbVoidPtrArray& arEntPtrs,const AcGeVector3d& vtDir,bool bIsShowEntPtrs,bool bLastIsRoadLine)
{
	m_arEntPtrs.append(arEntPtrs);
	m_vtDir = vtDir;
	m_vtDir.normalize();
	m_bIsShowEntPtrs = bIsShowEntPtrs;

	if (bIsShowEntPtrs)
	{
		m_pDrawingFrms->SetDrawingEnts(arEntPtrs);
	}
	m_bHasRoadLine = bLastIsRoadLine;
}

void AecOutDrawingJig::SetDrawingExt(const AcDbExtents& extUCS,const AcGeVector3d& vtDir,bool bIsShowEntPtrs)
{
	m_vtDir = vtDir;
	m_vtDir.normalize();
	m_bIsShowEntPtrs = bIsShowEntPtrs;

	m_bExtValid = true;
	m_extAll = extUCS;
}

void AecOutDrawingJig::SetDrawingFrme(AcDbObjectId idRec,double dScale)
{ 
	m_idRec = idRec;
	m_dScale = dScale;
}

extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
bool GetInsideDrawSize(AcDbObjectId idRec,AcGePoint2d& ptSize)
{
	AcDbBlockReference ref;
	ref.setBlockTableRecord(idRec);
	ref.setScaleFactors(AcGeScale3d(1,1,1));

	AcDbExtents ext1;
	ref.getGeomExtents(ext1);

	AcDbVoidPtrArray arEntPtrs;
	ref.explode(arEntPtrs);

	AcGePoint3d ptCen = MidPoint(ext1.minPoint(),ext1.maxPoint());
	ptCen.z = 0.0;
		
	AcDbXline xLn1,xLn2;
	xLn1.setBasePoint(ptCen);
	xLn1.setUnitDir(AcGeVector3d::kXAxis);

	xLn2.setBasePoint(ptCen);
	xLn2.setUnitDir(AcGeVector3d::kYAxis);

	AcGePoint3d pt;
	AcGePoint3dArray arPts1,arPts2;
	AcDbEntity* pEnt = NULL;

	double dX1 = 99999.0,dX2 = 99999.0;
	double dY1 = 99999.0,dY2 = 99999.0;

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

		arPts1.removeAll();
		pEnt->intersectWith(&xLn1,AcDb::kOnBothOperands,arPts1);

		for (int j = 0;j < arPts1.length();j++)
		{
			pt = arPts1.at(j);
			if (pt.x - ptCen.x > 1.e-10)
			{
				dX2 = __min(dX2,pt.x - ptCen.x);//取最小
			}
			else
			{
				dX1 = __min(dX1,ptCen.x - pt.x);//取最小
			}
		}

		arPts2.removeAll();
		pEnt->intersectWith(&xLn2,AcDb::kOnBothOperands,arPts2);

		for (int j = 0;j < arPts2.length();j++)
		{
			pt = arPts2.at(j);
			if (pt.y - ptCen.y > 1.e-10)
			{
				dY2 = __min(dY2,pt.y - ptCen.y);//取最小
			}
			else
			{
				dY1 = __min(dY1,ptCen.y - pt.y);//取最小
			}
		}
		DELETE_PTR(pEnt);
	}

	//排序,取得距离 ptCen 最近的点
	if (dX1 < 9999.0 && dX2 < 9999.0 && dY1 < 9999.0 && dY2 < 9999.0)
	{
		ptSize.set( dX1 + dX2 ,dY1 + dY2);
		return true;
	}
	return false;
}

bool GetInsideDrawSize(AcDbObjectId idRec,AcGePoint2d& ptSize,AcGePoint3d& ptLB)
{
	AcDbBlockReference ref;
	ref.setBlockTableRecord(idRec);
	ref.setScaleFactors(AcGeScale3d(1,1,1));

	AcDbExtents ext1;
	ref.getGeomExtents(ext1);

	AcDbVoidPtrArray arEntPtrs;
	ref.explode(arEntPtrs);

	AcGePoint3d ptCen = MidPoint(ext1.minPoint(),ext1.maxPoint());
	ptCen.z = 0.0;

	AcDbXline xLn1,xLn2;
	xLn1.setBasePoint(ptCen);
	xLn1.setUnitDir(AcGeVector3d::kXAxis);

	xLn2.setBasePoint(ptCen);
	xLn2.setUnitDir(AcGeVector3d::kYAxis);

	AcGePoint3d pt;
	AcGePoint3dArray arPts1,arPts2;
	AcDbEntity* pEnt = NULL;

	double dX1 = 99999.0,dX2 = 99999.0;
	double dY1 = 99999.0,dY2 = 99999.0;
	ptLB.set(-dX1,-dY1,0.0);

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

		arPts1.removeAll();
		pEnt->intersectWith(&xLn1,AcDb::kOnBothOperands,arPts1);

		for (int j = 0;j < arPts1.length();j++)
		{
			pt = arPts1.at(j);
			if (pt.x - ptCen.x > 1.e-10)
			{
				dX2 = __min(dX2,pt.x - ptCen.x);//取最小
			}
			else
			{
				dX1 = __min(dX1,ptCen.x - pt.x);//取最小
			}
		}

		arPts2.removeAll();
		pEnt->intersectWith(&xLn2,AcDb::kOnBothOperands,arPts2);

		for (int j = 0;j < arPts2.length();j++)
		{
			pt = arPts2.at(j);
			if (pt.y - ptCen.y > 1.e-10)
			{
				dY2 = __min(dY2,pt.y - ptCen.y);//取最小
			}
			else
			{
				dY1 = __min(dY1,ptCen.y - pt.y);//取最小
			}
		}
		DELETE_PTR(pEnt);
	}

	//排序,取得距离 ptCen 最近的点
	if (dX1 < 9999.0 && dX2 < 9999.0 && dY1 < 9999.0 && dY2 < 9999.0)
	{
		ptSize.set( dX1 + dX2 ,dY1 + dY2);
		ptLB.set(ptCen.x - dX1,ptCen.y - dY1,0.0);
		return true;
	}
	return false;
}

bool PickBoundary(const AcDbVoidPtrArray& arEntPtrs,const AcGePoint3d& ptHit,AcGePoint2d& ptSize,AcGePoint3d& ptLB)
{
	AcDbXline xLn1,xLn2;
	xLn1.setBasePoint(ptHit);
	xLn1.setUnitDir(AcGeVector3d::kXAxis);

	xLn2.setBasePoint(ptHit);
	xLn2.setUnitDir(AcGeVector3d::kYAxis);

	AcGePoint3d pt;
	AcGePoint3dArray arPts1,arPts2;
	AcDbEntity* pEnt = NULL;

	double dX1 = 99999.0,dX2 = 99999.0;
	double dY1 = 99999.0,dY2 = 99999.0;
	ptLB.set(-dX1,-dY1,0.0);

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

		arPts1.removeAll();
		pEnt->intersectWith(&xLn1,AcDb::kOnBothOperands,arPts1);

		for (int j = 0;j < arPts1.length();j++)
		{
			pt = arPts1.at(j);
			if (pt.x - ptHit.x > 1.e-10)
			{
				dX2 = __min(dX2,pt.x - ptHit.x);//取最小
			}
			else
			{
				dX1 = __min(dX1,ptHit.x - pt.x);//取最小
			}
		}

		arPts2.removeAll();
		pEnt->intersectWith(&xLn2,AcDb::kOnBothOperands,arPts2);

		for (int j = 0;j < arPts2.length();j++)
		{
			pt = arPts2.at(j);
			if (pt.y - ptHit.y > 1.e-10)
			{
				dY2 = __min(dY2,pt.y - ptHit.y);//取最小
			}
			else
			{
				dY1 = __min(dY1,ptHit.y - pt.y);//取最小
			}
		}
		DELETE_PTR(pEnt);
	}

	//排序,取得距离 ptCen 最近的点
	if (dX1 < 9999.0 && dX2 < 9999.0 && dY1 < 9999.0 && dY2 < 9999.0)
	{
		ptSize.set( dX1 + dX2 ,dY1 + dY2);
		ptLB.set(ptHit.x - dX1,ptHit.y - dY1,0.0);
		return true;
	}
	return false;
}

bool GetInsideDrawSize(AcDbBlockReference& ref,AcGePoint2d& ptSize,AcGePoint3d& ptLB)
{
	AcDbExtents ext1;
	ref.getGeomExtents(ext1);

	AcDbVoidPtrArray arEntPtrs;
	ref.explode(arEntPtrs);

	AcGePoint3d ptCen = MidPoint(ext1.minPoint(),ext1.maxPoint());
	ptCen.z = 0.0;

	return PickBoundary(arEntPtrs,ptCen,ptSize,ptLB);
}

bool PolylineIntersectWithLine(AcDbEntity* pEnt,AcDbLine* pLine,AcGePoint3dArray& arPts)
{
	AcGePoint3dArray arPts2;
	AcDbPolyline* pPl = AcDbPolyline::cast(pEnt);
	if (pPl != NULL)
	{
		AcDbVoidPtrArray arCurPtrs;
		pPl->explode(arCurPtrs);

		AcDbEntity* pEnt2 = NULL;
		for (int i = 0;i < arCurPtrs.length();i++)
		{
			pEnt2 = (AcDbEntity*)arCurPtrs.at(i);
			pEnt2->intersectWith(pLine,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts2);
			DELETE_PTR(pEnt2);
		}

		AcGePoint3d ptOn;
		for (int i = 0;i < arPts2.length();i++)
		{
			ptOn = arPts2.at(i);
			pPl->getClosestPointTo(arPts2.at(i),ptOn);

			arPts.append(ptOn);
		}
	}

	AcDbLine* pLn = AcDbLine::cast(pEnt);
	if (pLn != NULL)
	{
		pLn->intersectWith(pLine,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts2);
		AcGePoint3d ptOn;
		for (int i = 0;i < arPts2.length();i++)
		{
			ptOn = arPts2.at(i);
			pLn->getClosestPointTo(arPts2.at(i),ptOn);

			arPts.append(ptOn);
		}
	}
	return arPts.length() > 0 ? true : false;
}

bool IsExtInFrame(AcDbExtents& ext,DrawFrame& frm)
{
	//判断范围有交集
	AcDbLine ln(ext.minPoint(),ext.maxPoint());

	AcGePoint3dArray arPts;
	for (int i = 0;i < 4;i++)
	{
		AcDbLine ln2(frm.ptGe[i],frm.ptGe[i+1]);

		ln.intersectWith(&ln2,AcDb::kOnBothOperands,arPts);

		if (arPts.length() > 0)
		{
			return true;
		}
	}
	return false;
}

void AecOutDrawingJig::AddElevationPoint(AecDbObjXDataMap* pxData,AcDbCurve* pCurve,const AcGePoint3dArray& arPts,CMapWordToPtr& mapPos2PtPtr)
{
	if (pxData == NULL)
		return;

	//排序，保留最左边UCS X 最小的标高点对象 3个,每个位置一个0,1,2 //路，顶，底

	AecDbObjXDataMap xData;
	int nPos = 0;
	double dStaEl = 0.0,dElOnPt = 0.0;
	pxData->GetAt(_T("StaEl"),dStaEl);//起点标高
	pxData->GetAt(_T("ElPos"),nPos);//起点标高

	//开头
	AcGePoint3d ptSta,ptGe1,ptGe2;
	pCurve->getStartPoint(ptSta);
	ads_point pt0;
	acdbWcs2Ucs(asDblArray(ptSta),pt0,false);

	AcGePoint3dArray arPts2;
	if (arPts.isEmpty())
		arPts2.append(ptSta);

	if (!arPts.isEmpty())
		arPts2.append(arPts);

	AcDbPoint* pPt = NULL;
	BOOL bSuccess = FALSE;
	ads_point ptucs,pt2;
	for(int i = 0;i <  arPts2.length();i++)
	{
		ptGe1 = arPts2.at(i);

		acdbWcs2Ucs(asDblArray(ptGe1),ptucs,false);
		dElOnPt = (ptucs[Y] - pt0[Y] ) + dStaEl;//UCS下 Y之差+起点标高

		if (mapPos2PtPtr.Lookup(nPos,(void*&)pPt))
		{
			ptGe2 = pPt->position();
			acdbWcs2Ucs(asDblArray(ptGe2),pt2,false);

			if (pt2[X] - ptucs[X] < 1.e-3)//ptucs 大 
			{
				//忽略
			}
			else //ptucs x 小 (左 ), 用ptucs
			{
				AecDbObjXDataMap xData2;
				xData2.Read(pPt,_T("StaEl"));

				//使用当前点
				xData2.SetAt(_T("StaEl"),dElOnPt);
				pPt->setPosition(ptGe1);//
				xData2.Write(pPt,_T("StaEl"));
			}
		}
		else //没有,添加
		{
			pPt = new AcDbPoint;
			pPt->setPosition(arPts2.at(i));
			pPt->setNormal(AcGeVector3d::kZAxis);
			xData.SetAt(_T("StaEl"),dElOnPt);
			xData.SetAt(_T("ElPos"),nPos);
			bSuccess = xData.Write(pPt,_T("StaEl"));

			mapPos2PtPtr.SetAt(nPos,pPt);//位置-Pt
		}
	}
}

void AecOutDrawingJig::SplitEntitiesOnDrawframe()
{
	KTTempTol tol(1.e-2);

	float* pvertx = NULL;
	float* pverty = NULL;

	pvertx = new float[5];
	pverty = new float[5];

	Acad::ErrorStatus es = Acad::eOk;
	AcArray<int> arIdxGrouped;
	AcGePoint3d ptSta;
	AcGeVector3d vtLB2Cen;

	//分割图形实体
	AcDbEntity* pEnt = NULL;
	AcDbCurve* pCurve = NULL;
	for (int k = 0;k < m_pDrawingFrms->m_arDrawFrames.length();k++)
	{
		DrawFrame& frm = m_pDrawingFrms->m_arDrawFrames.at(k);

		for (int n = 0;n < 5;n++)
		{
			pvertx[n] = (float)frm.ptGe[n].x;
			pverty[n] = (float)frm.ptGe[n].y;
		}

		vtLB2Cen = MidPoint(frm.ptGe[2],frm.ptGe[1]) - MidPoint(frm.ptGe[0],frm.ptGe[3]);
		vtLB2Cen.normalize();

		AcDbLine ln[4];
		for (int n = 0;n < 4;n++)
		{
			ln[n].setStartPoint(frm.ptGe[n]);
			ln[n].setEndPoint(frm.ptGe[n+1]);
			ln[n].setNormal(AcGeVector3d::kZAxis);

			//测试
			//AcDbLine* pLine = (AcDbLine*)ln[n].clone();
			//pLine->setColorIndex(1);
			//AddToModelSpace(pLine,NULL,true);
		}

		//分割实体
		AcDbVoidPtrArray arOtherPtrs;
		CMapWordToPtr mapPos2PtPtr;

		for (int i = 0;i < m_arEntPtrs.length();i++)
		{
			pEnt = (AcDbEntity*)m_arEntPtrs.at(i);
			pCurve = AcDbCurve::cast(pEnt);

			if (pCurve != NULL)
			{
				for (int m = 0;m < 4;m++)
				{
					AcDbPolyline* pPl = AcDbPolyline::cast(pCurve);
					if (pPl != NULL)
					{
						pPl->setElevation(0.0);
						pPl->setNormal(AcGeVector3d::kZAxis);
					}

					AcGePoint3dArray arPts;//1个点
					//if (Acad::eOk == ( es = ln[m].intersectWith(pEnt,AcDb::kOnBothOperands,AcGePlane::kXYPlane,arPts) ) )
					if ( PolylineIntersectWithLine(pEnt,&ln[m],arPts) )
					{
						AcDbVoidPtrArray arCurPtrs;
						pCurve->getSplitCurves(arPts,arCurPtrs);

						if (arCurPtrs.length() > 0)
						{
							//复制写扩展数据了
							AecDbObjXDataMap xDataT;
							AcDbCurve* pCurveGet = NULL;
							if ( xDataT.Read(pCurve,_T("StaEl")) )//起点标高
							{
								pCurve->getStartPoint(ptSta);
								ads_point pt0;
								acdbWcs2Ucs(asDblArray(ptSta),pt0,false);

								double dStaEl = 0.0,dElOnPt = 0.0;
								xDataT.GetAt(_T("StaEl"),dStaEl);//起点标高

								double dW = 0.0;
								AcDbPolyline* pPlCurve = AcDbPolyline::cast(pCurve);

								ads_point ptucs;
								for (int nn = 0;nn < arCurPtrs.length();nn++)
								{
									pCurveGet = (AcDbCurve*)arCurPtrs.at(nn);
									pCurveGet->getStartPoint(ptSta);

									AcDbLine* pLn = AcDbLine::cast(pCurveGet);
									if (pLn != NULL)
									{
										AcGePoint3d ptLn[2];
										ptLn[0] = pLn->startPoint();
										ptLn[1] = pLn->endPoint();

										AcDbPolyline* pPlGet = new AcDbPolyline;
										if (pPlGet != NULL && pPlCurve != NULL)
										{
											pPlCurve->getConstantWidth(dW);
											pPlGet->setConstantWidth(dW);

											pPlGet->addVertexAt(0,ptLn[0].convert2d(AcGePlane::kXYPlane));
											pPlGet->addVertexAt(1,ptLn[1].convert2d(AcGePlane::kXYPlane));

											DELETE_PTR(pCurveGet);
											pCurveGet = pPlGet;
											arCurPtrs.setAt(nn,pCurveGet);
										}
									}

									if ( pCurveGet->isClosed() )
									{
										int mmm = 0;
									}

									acdbWcs2Ucs(asDblArray(ptSta),ptucs,false);
									dElOnPt = (ptucs[Y] - pt0[Y] ) + dStaEl;//UCS下 Y之差+起点标高

									AecDbObjXDataMap xData2;
									xData2.Read(pCurve,_T("StaEl"));
									xData2.SetAt(_T("StaEl"),dElOnPt);
									xData2.Write(pCurveGet,_T("StaEl"));
								}
							}

							pCurveGet = (AcDbCurve*)arCurPtrs.first();
							m_arEntPtrs.setAt(i,pCurveGet);
							arCurPtrs.removeFirst();

							if (arCurPtrs.length() > 0)
							{
								//如果含有道路中心线,说明是纵断出图
								if (m_bHasRoadLine)
								{
									AecDbObjXDataMap xData;
									if ( xData.Read(pCurve,_T("StaEl")) )//起点标高
									{
										AddElevationPoint(&xData,pCurve,arPts,mapPos2PtPtr);
									}
								}
								arOtherPtrs.append(arCurPtrs);
							}
							DELETE_PTR(pEnt);//原删除
						}
						else
						{
							acutPrintf(_T("\ngetSplitCurves error!"));
						}
						break;
					}
					else //不相交
					{
						//如果含有道路中心线,说明是纵断出图
						if (m_bHasRoadLine)
						{
							AecDbObjXDataMap xData;
							if ( xData.Read(pCurve,_T("StaEl")) )//起点标高
							{
								pCurve->getStartPoint(ptSta);
								ptSta += vtLB2Cen * 0.5;//前进一点

								//不相交,且开始端点在图框内
								if (KTCADUtilityEx::IsPointInPoly(5,pvertx,pverty,(float)ptSta.x,(float)ptSta.y) > 0)
								{
									AddElevationPoint(&xData,pCurve,arPts,mapPos2PtPtr);
								}
							}
						}
					}
				}
			}
		}

		WORD nPos = -1;
		AcDbPoint* pPtr = NULL;
		for (POSITION ps = mapPos2PtPtr.GetStartPosition();ps != NULL;)
		{
			mapPos2PtPtr.GetNextAssoc(ps,nPos,(void*&)pPtr);
			if(pPtr != NULL) arOtherPtrs.append(pPtr);
		}

		if (arOtherPtrs.length() > 0)
		{
			m_arEntPtrs.append(arOtherPtrs);
		}

		//按图框分组
		CUIntArray* pGroups = new CUIntArray;
		AcGePoint3d ptCen,ptTemp;
		for (int i = 0;i < m_arEntPtrs.length();i++)
		{
			pEnt = (AcDbEntity*)m_arEntPtrs.at(i);
			
			AcDbExtents ext;
			pEnt->getGeomExtents(ext);

			ptCen = MidPoint(ext.minPoint(),ext.maxPoint());
			ptCen += vtLB2Cen * 0.5;//前进一点

			if (KTCADUtilityEx::IsPointInPoly(5,pvertx,pverty,(float)ptCen.x,(float)ptCen.y) > 0)
			{
				if (arIdxGrouped.find(i) == -1)
				{
					pGroups->Add(i);
					arIdxGrouped.append(i);
				}
			}

			//测试
			//AcDbEntity* pClone = (AcDbEntity*)pEnt->clone();
			//pClone->setColorIndex(3);
			//AddToModelSpace(pClone,NULL,true);
		}

		if (pGroups->GetSize() > 0)
		{
			m_arIndexsGrpPtrs.Add(pGroups);
		}
		else
		{
			DELETE_PTR(pGroups);
		}
	}
}

BOOL AecOutDrawingJig::GetDrawingEnts(AcDbVoidPtrArray& arEntPtrs,CPtrArray& arIndexGrpPtrs)
{
	if (!m_arEntPtrs.isEmpty())
		arEntPtrs.append(m_arEntPtrs);

	if (!m_arIndexsGrpPtrs.IsEmpty())
		arIndexGrpPtrs.Append(m_arIndexsGrpPtrs);

	return arIndexGrpPtrs.GetSize() > 0 ? TRUE : FALSE;
}

BOOL AecOutDrawingJig::GetFrmeAtGroups( AcArray<DrawFrame>& arFrames)
{
	if (m_pDrawingFrms != NULL)
	{
		m_pDrawingFrms->GetDrawFrames(arFrames);
	}
	return arFrames.length() > 0 ? TRUE : FALSE;
}

void AecOutDrawingJig::GetEntsUCSExt(AcDbExtents& extAll)
{
	ads_point pt;
	AcGePoint3d ptGe;

	AcDbEntity* pEnt = NULL;
	if (m_bHasRoadLine)
	{
		pEnt = (AcDbEntity*)m_arEntPtrs.last();
		
		AcDbLine* pLn = AcDbLine::cast(pEnt);
		if (pLn != NULL)
		{
			ptGe = pLn->startPoint();
			acdbWcs2Ucs(asDblArray(ptGe),pt,false);
			extAll.addPoint(asPnt3d(pt));

			ptGe = pLn->endPoint();
			acdbWcs2Ucs(asDblArray(ptGe),pt,false);
			extAll.addPoint(asPnt3d(pt));
		}
		if (pEnt != NULL)
			DELETE_PTR(pEnt);

		m_arEntPtrs.removeLast();
		return;
	}

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

		AcDbLine* pLn = AcDbLine::cast(pEnt);
		if (pLn != NULL)
		{
			ptGe = pLn->startPoint();
			acdbWcs2Ucs(asDblArray(ptGe),pt,false);
			extAll.addPoint(asPnt3d(pt));

			ptGe = pLn->endPoint();
			acdbWcs2Ucs(asDblArray(ptGe),pt,false);
			extAll.addPoint(asPnt3d(pt));
		}

		AcDbPolyline* pPl = AcDbPolyline::cast(pEnt);
		if (pPl != NULL)
		{
			for (int j = 0;j < pPl->numVerts();j++)
			{
				pPl->getPointAt(j,ptGe);

				acdbWcs2Ucs(asDblArray(ptGe),pt,false);
				extAll.addPoint(asPnt3d(pt));
			}
		}
	}
}

BOOL AecOutDrawingJig::DoIt(bool bDrag)
{
	AcDbExtents extAll1,extEnt;
	AcDbExtents ext,extAll;

	if (!m_bExtValid)//非总图出图
	{
		GetEntsUCSExt(extAll);
	}
	else
	{
		//总图出图，外部传入 ext m_vtDir
		extAll = m_extAll;
	}

	//分割为多个框,也可由外面传入图幅尺寸
	//如果获取内框线范围???,+字求交法
	AcGePoint2d ptSize;
	if ( !GetInsideDrawSize(m_idRec,ptSize) )
	{
		acutPrintf(_T("\n计算图幅绘图尺寸出错!请检查图框正确!"));
		return FALSE;
	}
	
	//通过UCS EXT 计算
	double dXE = extAll.maxPoint().x - extAll.minPoint().x;
	int nCount = (int)( dXE / ( ptSize.x * m_dScale) + 1.0);//总共这么多图框
	if (nCount == 0) nCount = 1; //图框比例太大

	//涉及到用户坐标系
	AcGePoint3d ptGe[5],ptGeFr,ptGeTo;

	AcGePoint3d ptGeFr1 = extAll.minPoint();
	AcGePoint3d ptGeTo1 = extAll.maxPoint();

	AcGeVector3d vtDirY = m_vtDir;
	if (m_bExtValid)
	{
		AcGePoint3d ptGeTo11 = ptGeTo1;
		ptGeTo11.x = __min(ptGeFr1.x,ptGeTo1.x);
		AcGePoint3d ptGeFrY = MidPoint(ptGeFr1,ptGeTo11);
		acdbUcs2Wcs(asDblArray(ptGeFrY),asDblArray(ptGeFr),false);

		vtDirY = m_vtDir;
		vtDirY.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
		vtDirY.normalize();

		ptGeFr -= ptSize.y  * m_dScale * 0.5 * vtDirY;
	}
	else
	{
		ptGeFr = ptGeFr1;
		ptGeTo = ptGeTo1;

		ptGeTo.x = __min(ptGeFr.x,ptGeTo.x);
		ptGeFr = MidPoint(ptGeFr,ptGeTo);

		//UCS 纵断等
		vtDirY = AcGeVector3d::kYAxis;
		m_vtDir = AcGeVector3d::kXAxis;

		//图框内上下居中显示. WriteToDwgFile函数又做了居中调整
		//故此处修改 0.5 系数 显示和出图效果不一致,出图始终居中!!!
		ptGeFr -= ptSize.y  * m_dScale * 0.5 * vtDirY;
	}

	AcDbLine lnLeft,lnRight;
	for (int i = 0;i < nCount;i++)
	{
		ptGe[0] = ptGeFr;
		ptGe[1] = ptGe[0] + m_vtDir * ptSize.x  * m_dScale;
		ptGe[2] = ptGe[1] + vtDirY * ptSize.y  * m_dScale;
		ptGe[3] = ptGe[0] + vtDirY * ptSize.y  * m_dScale;
		ptGe[4] = ptGe[0];

		if (i == 0)
		{
			lnLeft.setStartPoint(ptGe[0]);
			lnLeft.setEndPoint(ptGe[3]);
		}

		if (i == nCount - 1)
		{
			lnRight.setStartPoint(ptGe[1]);
			lnRight.setEndPoint(ptGe[2]);
		}

		//纵断出图在 UCS 下, 需要转成wcs
		if (!m_bExtValid)
		{
			ads_point pt;
			for (int j = 0;j < 5;j++)
			{
				acdbUcs2Wcs(asDblArray(ptGe[j]),pt,false);
				ptGe[j] = asPnt3d(pt);
			}
		}

		m_pDrawingFrms->AppendDrawFrame(ptGe,5);
		ptGeFr += m_vtDir * ptSize.x  * m_dScale;
	}

	AcEdJig::DragStatus eStat = AcEdJig::kNormal;
	setDispPrompt(_T("\n请按任意键出图或拾取点出图:"));

	if (bDrag)
		eStat = drag();

	if (eStat == AcEdJig::kNormal ||
		eStat == AcEdJig::kNull)
	{
		SplitEntitiesOnDrawframe();
		return TRUE;
	}
	return FALSE;
}

AcEdJig::DragStatus AecOutDrawingJig::sampler()
{
	setUserInputControls( ( UserInputControls)
		( AcEdJig::kAccept3dCoordinates |
		AcEdJig::kNullResponseAccepted ) );

	AcEdJig::DragStatus eStat;
	if (m_bIsShowEntPtrs)
	{
		//double dDist = 0.0;
		//eStat = acquireDist(dDist);

		AcGePoint3d ptGe;
		eStat = acquirePoint(ptGe);

		if (eStat == AcEdJig::kNormal)
		{
			if ( ptGe.isEqualTo(m_ptGe))
			{
				//鼠标原地不动
				return AcEdJig::kNoChange;
			}
			m_ptGe = ptGe;
		}
	}
	else
	{
		AcGePoint3d ptGe;
		eStat = acquirePoint(ptGe);

		if (eStat == AcEdJig::kNormal)
		{
			if ( ptGe.isEqualTo(m_ptGe))
			{
				//鼠标原地不动
				return AcEdJig::kNoChange;
			}
			m_ptGe = ptGe;
		}
	}
	return eStat;
}

AcDbEntity* AecOutDrawingJig::entity() const
{
	return m_pDrawingFrms;
}

Adesk::Boolean AecOutDrawingJig::update()
{
	return Adesk::kTrue;
}