#include "stdafx.h"
#include "basefunc.h"
#include "distdrag.h"
#include "tkcsdlg.h"
#include "DockPane.h"
#include "BlockDrag.h"

extern CTkcsDlg *g_TkcsDlg;
extern CString g_sLayerName;
CDockPane *g_pDockPane = NULL;

namespace BaseFuncs
{
	void CAD_GetVarInt(CString sMode, int &nRet)
	{
		resbuf *pRb = acutBuildList(RTSHORT, 23, 0);
		acedGetVar(sMode, pRb);
		if (pRb==NULL)
		{
			acutRelRb(pRb);
			return;
		}
		nRet = pRb->resval.rint;
		acutRelRb(pRb);
	}

	void CAD_SetvarInt(CString sMode, int nRet)
	{
		resbuf *pNewRb = acutBuildList(RTSHORT, nRet, 0);
		acedSetVar(sMode, pNewRb);
		acutRelRb(pNewRb);
	}

	BOOL DeleteEnt(AcDbObjectId EntId)
	{
		AcDbEntity *pEnt = NULL;
		if (acdbOpenObject(pEnt, EntId, AcDb::kForWrite)==Acad::eOk)
		{
			Acad::ErrorStatus es = pEnt->erase();
			pEnt->close();
			pEnt = NULL;
			return TRUE;
		}
		return FALSE;
	}

	BOOL ClearAcadCmdLine()
	{
		HWND hAcadDocWnd = adsw_acadDocWnd();
		if (hAcadDocWnd == NULL)
			return false;

		::SendMessage(hAcadDocWnd, WM_CHAR, VK_ESCAPE, 0);
		::SendMessage(hAcadDocWnd, WM_CHAR, VK_ESCAPE, 0);

		acedPostCommandPrompt();
		return true;
	}

	BOOL AddEntToDb(AcDbEntity *pEnt, AcDbObjectId &EntId, AcDbObjectId OwerId)
	{
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		//	AcDbBlockTable *pBlockTable=NULL;
		AcDbBlockTableRecord *pBlockTableRecord = NULL;
		//	pDb->getSymbolTable(pBlockTable,AcDb::kForRead);
		if (OwerId==NULL)
			OwerId = pDb->currentSpaceId();
		if (acdbOpenObject(pBlockTableRecord, OwerId, AcDb::kForWrite)!=Acad::eOk)
		{
			return FALSE;
		}
		Acad::ErrorStatus es = pBlockTableRecord->appendAcDbEntity(EntId, pEnt);
		pBlockTableRecord->close();
		pEnt->close();
		return TRUE;
	}

	void CAD_SendStringToExecute(CString szCommand, bool bAutoReturn /*=TRUE*/)
	{
		if (acedGetAcadDwgView()!=NULL)
			acedGetAcadDwgView()->SetFocus();
		AcApDocument *pDoc = acDocManager->curDocument();
		//取消当前命令
		HWND hdoc = acedGetAcadTextCmdLine()->m_hWnd;
		szCommand.TrimRight();
		szCommand += _T("\n");
		acDocManager->sendStringToExecute(pDoc, szCommand);
		return;
		if (bAutoReturn)
		{
			::SendMessage(hdoc, WM_CHAR, VK_RETURN, 0);
		}
	}

	void dist_ent_highlight(AcDbObjectId EntId)
	{
		AcDbEntity *pEnt = NULL;
		if (acdbOpenObject(pEnt, EntId, AcDb::kForRead)==Acad::eOk)
		{
			pEnt->highlight();
			pEnt->close();
			pEnt = NULL;
		}
	}

	void dist_ent_highlight(AcDbObjectIdArray EntIds)
	{
		for (int nLen = 0; nLen<EntIds.logicalLength(); nLen++)
			dist_ent_highlight(EntIds[nLen]);
	}

	void dist_ent_unhighlight(AcDbObjectId EntId)
	{
		AcDbEntity *pEnt = NULL;
		if (acdbOpenObject(pEnt, EntId, AcDb::kForRead)==Acad::eOk)
		{
			pEnt->unhighlight();
			pEnt->close();
			pEnt = NULL;
		}
	}

	void dist_ent_unhighlight(AcDbObjectIdArray EntIds)
	{
		for (int nLen = 0; nLen<EntIds.logicalLength(); nLen++)
			dist_ent_unhighlight(EntIds[nLen]);
	}

	void JxString(CString str, CString strFg, CStringArray &strArr)
	{


		CString strZj;
		CString strFind = str;
		str.TrimLeft();
		str.TrimRight();
		if (str==_T(""))
			return;
		int nIndex = strFind.Find(strFg, 0);
		while (nIndex>=0)
		{
			int nLength = strFind.GetLength();
			strZj = strFind.Left(nIndex);
			strFind = strFind.Right(nLength-nIndex-strFg.GetLength());
			strFind.TrimLeft();
			strFind.TrimRight();
			nIndex = strFind.Find(strFg, 0);
			strZj.TrimLeft();
			strZj.TrimRight();
			strArr.Add(strZj);
		}
		strFind.TrimLeft();
		strFind.TrimRight();
		strArr.Add(strFind);
	}

	BOOL FindStringInArr(CStringArray &strArr, CString str, int &nIndex)
	{
		nIndex = -1;
		for (int nLen = 0; nLen<strArr.GetSize(); nLen++)
		{
			if (str==strArr.GetAt(nLen))
			{
				nIndex = nLen;
				return TRUE;
			}
		}
		return FALSE;
	}

	void GetSubDir(CString sDirPath, CStringArray &sSubPathArr)
	{
		CFileFind find;
		BOOL bFind = FALSE;
		CString strPathFiles;
		strPathFiles = sDirPath;
		if (strPathFiles.Right(1) != _T("\\"))
			strPathFiles += "\\";
		strPathFiles += _T("*.*");

		bFind = find.FindFile(strPathFiles);
		while (bFind)
		{
			bFind = find.FindNextFile();

			if (find.IsDirectory()&&!find.IsDots())
			{
				CString sFileName = find.GetFileName();
				sSubPathArr.Add(sFileName);
			}
		}
	}

	void GetFileNameByDir(CString sDirPath, CString sExt, CStringArray &sFileNameArray)
	{
		sExt.MakeLower();
		CFileFind find;
		BOOL bFind = FALSE;
		CString strPathFiles;
		strPathFiles = sDirPath;
		if (strPathFiles.Right(1) != _T("\\"))
			strPathFiles += _T("\\");
		strPathFiles += _T("*.*");

		bFind = find.FindFile(strPathFiles);
		while (bFind)
		{
			bFind = find.FindNextFile();

			CString sFileName = find.GetFileName();
			CString sExtUp = sExt;
			CString sExtLow = sExt;
			sExtUp.MakeUpper();
			sExtLow.MakeLower();
			if (sFileName.Find(sExtUp, 0)>=0||sFileName.Find(sExtLow, 0)>=0)
			{
				sFileName.TrimRight(sExtUp);
				sFileName.TrimRight(sExtLow);
				sFileNameArray.Add(sFileName);
			}
		}
	}

	void DrawD(AcDbObjectId &PlineId, BOOL bAutoClose)
	{
		AsdkCadPolylineJig *pJig = new AsdkCadPolylineJig();
		pJig->doIt();
		PlineId = pJig->m_objId;
		delete pJig;
		if (bAutoClose)
		{
			AcDbPolyline *pLine = NULL;
			if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
			{
				if (pLine->numVerts()<3)
				{
					pLine->erase();
					PlineId = NULL;
				}
				else
					pLine->setClosed(Adesk::kTrue);
				pLine->close();
				pLine = NULL;
			}
		}
		return;

		int nIndex = 0;
		AcGePoint3d ptEnd;
		AcGePoint3d ptStart;
		double dOldAnlge = 0;
		AcDbPolyline *pLine = NULL;

		if (acedGetPoint(NULL, _T("\n指定起点"), asDblArray(ptStart))!=RTNORM)
			return;
		acdbUcs2Wcs(asDblArray(ptStart), asDblArray(ptStart), FALSE);
		pLine = new AcDbPolyline();
		ptEnd = ptStart;

		TCHAR kw[10];
		//获得当前线宽;
		double dWidth = 0.0;
		pLine->addVertexAt(nIndex++, AcGePoint2d(ptStart.x, ptStart.y), 0);
		AddEntToDb(pLine, PlineId);
		acutPrintf(_T("\n当前线宽(0.0)"));
		CString sPromt;
		AcGePoint3d pt1;
		AcGePoint3d pt2;
		AcGeVector3d vt;
		double dDist = 0;
		double dWidth1 = 0;
		double dWidth2 = 0;
		AcGePoint3d ptNext;
		AcGePoint3d ptLast;
		double dBulge;
		int nOldMode = 0;  //老的正交模式
		int nORTHOode = 0;
		CAD_GetVarInt(_T("ORTHOMODE"), nOldMode);
		CAD_GetVarReal(_T("SNAPANG"), dOldAnlge);
		double dSnapAnlge = 0;
		while (1)
		{
			if (nIndex<3)
			{
				acedInitGet(0, _T("A H L O U W"));
				sPromt = _T("\n指定下一个点或 [圆弧(A)/半宽(H)/长度(L)/正交(O)/放弃(U)/宽度(W)]:");
			}
			else
			{
				acedInitGet(0, _T("A C H L O U W"));
				sPromt = _T("\n指定下一个点或 [圆弧(A)/半宽(H)/长度(L)/正交(O)/放弃(U)/闭合(C)/宽度(W)]:");
			}
			acdbWcs2Ucs(asDblArray(ptStart), asDblArray(ptStart), FALSE);
			switch (acedGetPoint(asDblArray(ptStart), sPromt, asDblArray(ptEnd)))
			{
			case RTCAN:
				DeleteEnt(PlineId);
				PlineId = NULL;
				return;
			case RTNORM:
				acdbUcs2Wcs(asDblArray(ptEnd), asDblArray(ptEnd), FALSE);
				//	pLine->addVertexAt(nIndex++,AcGePoint2d(ptEnd.x,ptEnd.y));
				if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
				{
					pLine->addVertexAt(nIndex++, AcGePoint2d(ptEnd.x, ptEnd.y));
					pLine->setWidthsAt(nIndex-1, dWidth, dWidth);
					pLine->close();
					pLine = NULL;
				}
				ptStart = ptEnd;
				break;
			case RTKWORD:
				acedGetInput(kw);
				switch (kw[0])
				{
				case 'A':  //圆狐  
					if (acedGetPoint(asDblArray(ptStart), _T("\n指定圆弧第一点"), asDblArray(ptNext))!=RTNORM)
						continue;

					if (acedGetPoint(asDblArray(ptNext), _T("\n指定圆弧第二点"), asDblArray(ptLast))!=RTNORM)
						continue;
					acdbUcs2Wcs(asDblArray(ptStart), asDblArray(ptStart), FALSE);
					acdbUcs2Wcs(asDblArray(ptNext), asDblArray(ptNext), FALSE);
					acdbUcs2Wcs(asDblArray(ptLast), asDblArray(ptLast), FALSE);
					GetBulge(ptStart, ptNext, ptLast, dBulge);
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						pLine->setBulgeAt(nIndex-1, dBulge);
						pLine->addVertexAt(nIndex++, AcGePoint2d(ptLast.x, ptLast.y));
						pLine->close();
						pLine = NULL;
					}
					ptStart = ptLast;
					break;
				case 'L':
					if (acedGetDist(asDblArray(ptStart), _T("\n指定直线的长度:"), &dDist)!=RTNORM)
						continue;
					if (nIndex<2)
						continue;
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						pLine->getPointAt(nIndex-1, pt2);
						pLine->getPointAt(nIndex-2, pt1);
						ptStart = pt2+(pt2-pt1).normal()*dDist;
						pLine->setPointAt(nIndex-1, AcGePoint2d(ptStart.x, ptStart.y));
						pLine->close();
						pLine = NULL;
					}
					break;
				case 'U':  //回退
					if (nIndex<2)
						continue;
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						pLine->removeVertexAt(nIndex-1);
						nIndex--;
						pLine->getPointAt(nIndex-1, ptStart);
						pLine->close();
						pLine = NULL;
					}
					CAD_GetVarInt(_T("ORTHOMODE"), nORTHOode);
					if (nORTHOode==0) //关闭状态
					{
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
					}
					else
					{
						if (GetPlAngle(PlineId, dSnapAnlge))
						{
							CAD_SetvarReal(_T("SNAPANG"), dSnapAnlge);
						}
					}
					break;
				case 'W'://宽度
					dWidth1 = dWidth2 = dWidth;
					sPromt.Format(_T("\n指定起点线宽(%0.2f):"), dWidth1);
					if (acedGetDist(asDblArray(ptStart), sPromt, &dWidth1)==RTCAN)
					{
						if (bAutoClose)
							ClosePline(PlineId);
						CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
						return;
					}
					sPromt.Format(_T("\n指定终点线宽(%0.2f):"), dWidth2);
					if (acedGetDist(asDblArray(ptStart), sPromt, &dWidth2)==RTCAN)
					{
						if (bAutoClose)
							ClosePline(PlineId);
						CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
						return;
					}
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						dWidth = dWidth2;
						pLine->setWidthsAt(nIndex-1, dWidth1, dWidth2);
						pLine->close();
						pLine = NULL;
					}
					break;
				case 'H'://半宽
					dWidth1 = dWidth2 = dWidth/2;
					sPromt.Format(_T("\n指定起点半宽(%0.2f):"), dWidth1);
					if (acedGetDist(asDblArray(ptStart), sPromt, &dWidth1)==RTCAN)
					{
						if (bAutoClose)
							ClosePline(PlineId);
						CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
						return;
					}
					sPromt.Format(_T("\n指定终点半宽(%0.2f):"), dWidth2);
					if (acedGetDist(asDblArray(ptStart), sPromt, &dWidth2)==RTCAN)
					{
						if (bAutoClose)
							ClosePline(PlineId);
						CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
						return;
					}
					dWidth1 *= 2;
					dWidth2 *= 2;
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						dWidth = dWidth2;
						pLine->setWidthsAt(nIndex-1, dWidth1, dWidth2);
						pLine->close();
						pLine = NULL;
					}
					break;

				case 'C':  //闭合
					if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)==Acad::eOk)
					{
						pLine->setClosed(TRUE);
						pLine->close();
						pLine = NULL;
					}
					CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
					CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
					return;
				case 'O':  //正交
					CAD_GetVarInt(_T("ORTHOMODE"), nORTHOode);
					if (nORTHOode==1) //关闭状态
					{
						CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
					}
					else
					{
						if (GetPlAngle(PlineId, dSnapAnlge))
						{
							CAD_SetvarReal(_T("SNAPANG"), dSnapAnlge);
						}
					}
					CAD_SetvarInt(_T("ORTHOMODE"), (nORTHOode+1)%2);

					continue;
				default:
					break;
				}
				break;

			default:
				if (bAutoClose)
				{
					if (nIndex>2)
						ClosePline(PlineId);
				}
				CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
				CAD_SetvarInt(_T("ORTHOMODE"), nORTHOode);
				if (nIndex<2)
				{
					DeleteEnt(PlineId);
					PlineId = NULL;
					return;
				}
				return;

			}

		}
		CAD_SetvarReal(_T("SNAPANG"), dOldAnlge);
		CAD_SetvarInt(_T("ORTHOMODE"), nOldMode);
	}

	void GetBulge(AcGePoint3d pt1, AcGePoint3d pt2, AcGePoint3d pt3, double &dBulge)
	{
		AcGePoint3d ptCenter;
		AcGePoint3d ptJd;
		AcGePoint3d ptCenter1 = pt1+(pt2-pt1)/2;
		AcGePoint3d ptCenter2 = pt2+(pt3-pt2)/2;
		AcGeVector3d vt1 = pt2-pt1;
		AcGeVector3d vt2 = pt3-pt2;
		vt1 = vt1.normal();
		vt2 = vt2.normal();
		vt1 = vt1.rotateBy(PI/2, AcGeVector3d(0, 0, 1));
		vt2 = vt2.rotateBy(PI/2, AcGeVector3d(0, 0, 1));

		AcGePoint3d ptTo1 = ptCenter1+vt1*20;
		AcGePoint3d ptTo2 = ptCenter2+vt2*20;
		AcDbObjectId LineId;

		int nFx;

		AcDbPolyline *pLine = new AcDbPolyline;
		pLine->addVertexAt(0, AcGePoint2d(pt1.x, pt1.y));
		pLine->addVertexAt(1, AcGePoint2d(pt2.x, pt2.y));
		pLine->addVertexAt(2, AcGePoint2d(pt3.x, pt3.y));
		pLine->setClosed(Adesk::kTrue);
		AddEntToDb(pLine, LineId);
		//判断是顺时针还是你时针小于0是顺 大于0是你
		polyWindingNumber(LineId, nFx);
		DeleteEnt(LineId);

		acdbInters(asDblArray(ptCenter1), asDblArray(ptTo1), asDblArray(ptCenter2), asDblArray(ptTo2), 0, asDblArray(ptCenter));

		//开始求bugle
		vt1 = pt1-ptCenter;
		vt2 = pt3-ptCenter;
		double dAngle;
		if (nFx<0)
			dAngle = vt1.angleTo(vt2, -AcGeVector3d::kZAxis);
		else
			dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
		dBulge = fabs(tan(dAngle/4));
		if (nFx<0)
			dBulge = -dBulge;
	}

	void CAD_GetVarReal(CString sMode, double &dReal)
	{
		resbuf *pRb = acutBuildList(RTREAL, 23.0, 0);
		acedGetVar(sMode, pRb);
		if (pRb==NULL)
		{
			acutRelRb(pRb);
			return;
		}
		dReal = pRb->resval.rint;
		acutRelRb(pRb);
	}

	void CAD_SetvarReal(CString sMode, double dReal)
	{
		resbuf *pNewRb = acutBuildList(RTREAL, dReal, 0);
		acedSetVar(sMode, pNewRb);
		acutRelRb(pNewRb);
	}

	BOOL GetPlAngle(AcDbObjectId PlId, double &dAngle)
	{
		AcDbPolyline *pLine = NULL;
		int nNumVert = 0;
		AcGePoint2d ptStart;
		AcGePoint2d ptEnd;
		AcGeVector2d vt;
		if (acdbOpenObject(pLine, PlId, AcDb::kForRead)!=Acad::eOk)
			return FALSE;
		nNumVert = pLine->numVerts();
		if (nNumVert<2)
		{
			pLine->close();
			pLine = NULL;
			return FALSE;
		}
		pLine->getPointAt(nNumVert-2, ptStart);
		pLine->getPointAt(nNumVert-1, ptEnd);
		pLine->close();
		pLine = NULL;
		vt = ptEnd-ptStart;
		dAngle = vt.angle();
		return TRUE;
	}

	void ClosePline(AcDbObjectId PlineId)
	{
		AcDbPolyline *pLine = NULL;
		if (acdbOpenObject(pLine, PlineId, AcDb::kForWrite)!=Acad::eOk)
			return;
		int nVerts = pLine->numVerts();
		if (nVerts<3)
		{
			pLine->close();
			pLine = NULL;
			return;
		}
		pLine->setClosed(Adesk::kTrue);
		pLine->close();
		pLine = NULL;
	}

	Adesk::Boolean polyWindingNumber(AcDbObjectId polyId, int &winding)
	{
		//	if (!pPoly->isClosed())
		//	{
		//		return Adesk::kFalse;
		//	}
		AcDbPolyline *pPoly = NULL;
		if (acdbOpenObject(pPoly, polyId, AcDb::kForRead)!=Acad::eOk)
			return Adesk::kFalse;
		BOOL bRet = polyWindingNumber(pPoly, winding);
		pPoly->close();
		pPoly = NULL;
		return bRet;

	}

	Adesk::Boolean polyWindingNumber(AcDbPolyline *&pPoly, int &winding)
	{
		double turn = 0;
		int nSegs = pPoly->numVerts();
		AcGeVector3dArray startTans(nSegs);
		AcGeVector3dArray endTans(nSegs);
		double TWOPI = 6.28318530718;
		double PIBYTWO = 1.570796326795;
		int i = 0;
		for (i = 0; i < nSegs; i++)
		{
			if (pPoly->segType(i) == AcDbPolyline::kArc)
			{
				AcGeCircArc2d arc;
				pPoly->getArcSegAt(i, arc);
				AcGeVector2d startTan;
				AcGeVector2d endTan;
				AcGeVector2dArray startDerivs;
				arc.evalPoint(arc.startAng(), 1, startDerivs);
				startTan = startDerivs[0];
				AcGeVector2dArray endDerivs;
				arc.evalPoint(arc.endAng(), 1, endDerivs);
				endTan = endDerivs[0];
				startTans.append(AcGeVector3d(startTan.x, startTan.y, 0.0));
				endTans.append(AcGeVector3d(endTan.x, endTan.y, 0.0));
				double ang = arc.endAng() - arc.startAng();
				turn += arc.isClockWise() ? -ang : ang;
			}
			else if (pPoly->segType(i) == AcDbPolyline::kLine)
			{
				AcGeLineSeg2d line;
				pPoly->getLineSegAt(i, line);
				AcGeVector2d tan2d = line.endPoint() -line.startPoint();
				AcGeVector3d tan = AcGeVector3d(tan2d.x, tan2d.y, 0.0);
				startTans.append(tan);
				endTans.append(tan);
			}
		}
		nSegs = startTans.length();
		for (i = 0; i < nSegs; i++)
		{
			double angle = endTans[i].angleTo(startTans[(i + 1) % nSegs]);
			AcGeVector3d norm = endTans[i].crossProduct(startTans[(i + 1) % nSegs]);
			angle = norm.z > 0 ? angle : -angle;
			turn += angle;
		}
		turn = turn / TWOPI;
		double lower = floor(turn);
		double tol = 1e-6;
		if ((turn - lower) < tol)
			winding = (int)lower;
		else if (((lower + 1) - turn) < tol)
			winding = (int)(lower + 1);
		else
			return Adesk::kFalse;
		return Adesk::kTrue;
	}

	void SSToIds(ads_name ssName, AcDbObjectIdArray &EnIds)
	{
		AcDbObjectId EntId;
		ads_name EntName;
		Adesk::Int32 nLength = 0;
		acedSSLength(ssName, &nLength);
		for (int nLen = 0; nLen<nLength; nLen++)
		{
			acedSSName(ssName, nLen, EntName);
			acdbGetObjectId(EntId, EntName);
			EnIds.append(EntId);
		}
	}

	BOOL FindStringInArr(const CStringArray &strArr, CString str, int &nIndex)
	{
		nIndex = -1;
		for (int nLen = 0; nLen<strArr.GetSize(); nLen++)
		{
			if (str==strArr.GetAt(nLen))
			{
				nIndex = nLen;
				return TRUE;
			}
		}
		return FALSE;
	}

	void dist_blkrcd_getbyRef(AcDbObjectIdArray BlfIds, AcDbObjectIdArray &RcdIds, CStringArray &strArr)
	{
		for (int nLen = 0; nLen<BlfIds.logicalLength(); nLen++)
		{
			AcDbObjectId RcdId;
			AcDbBlockReference *pBlf = NULL;
			if (acdbOpenObject(pBlf, BlfIds[nLen], AcDb::kForRead)!=Acad::eOk)
				continue;
			RcdId = pBlf->blockTableRecord();
			pBlf->close();
			pBlf = NULL;
			int nFind = -1;
			if (!RcdIds.find(RcdId, nFind))
			{
				RcdIds.append(RcdId);
				TCHAR *name;
				AcDbBlockTableRecord *pRcd = NULL;
				acdbOpenObject(pRcd, RcdId, AcDb::kForRead);
				pRcd->getName(name);
				pRcd->close();
				pRcd = NULL;
				strArr.Add(name);
				free(name);
			}
		}
	}

	BOOL dist_dwg_ReadDiction(CString &sXDList, CString sDicName, CString sRecName)
	{
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		AcDbDictionary *pNameObj = NULL;
		AcDbDictionary *pDict = NULL;
		pDb->getNamedObjectsDictionary(pNameObj, AcDb::kForRead);
		if (pNameObj->getAt(sDicName, (AcDbObject *&)pDict, AcDb::kForRead) != Acad::eOk)
		{
			pNameObj->close();
			return FALSE;
		}
		pNameObj->close();
		pNameObj = NULL;
		AcDbXrecord *pXrec = NULL;
		struct resbuf *pHead = NULL;
		if (pDict->getAt(sRecName, (AcDbObject *&)pXrec, AcDb::kForRead) != Acad::eOk)
		{
			pDict->close();
			pDict = NULL;
			return FALSE;
		}
		pDict->close();
		pDict = NULL;

		pXrec->rbChain(&pHead);
		struct resbuf *pRb = pHead;
		if (pRb->restype==AcDb::kDxfXdReal)
			sXDList.Format(_T("%0.1f"), pRb->resval.rreal);
		else if (pRb->restype==AcDb::kDxfText)
			sXDList = pRb->resval.rstring;
		else if (pRb->restype==AcDb::kDxfXdInteger16)
			sXDList.Format(pRb->resval.rint);
		pXrec->close();
		pXrec = NULL;
		acutRelRb(pHead);
		pHead = NULL;
		return TRUE;
	}

	BOOL dist_dwg_WriteDiction(CString sXDList, CString sDicName, CString sRecName)
	{
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		AcDbDictionary *pNameObj = NULL;
		AcDbDictionary *pDict = NULL;
		pDb->getNamedObjectsDictionary(pNameObj, AcDb::kForWrite);
		if (pNameObj->getAt(sDicName, (AcDbObject *&)pDict, AcDb::kForWrite) != Acad::eOk)
		{
			pDict = new AcDbDictionary;
			AcDbObjectId DictId;
			if (pNameObj->setAt(sDicName, pDict, DictId)!=Acad::eOk)
			{
				pNameObj->close();
				pNameObj = NULL;
				delete pDict;
				return FALSE;
			}
		}
		pNameObj->close();
		pNameObj = NULL;

		AcDbXrecord *pXrec = NULL;
		struct resbuf *pHead = NULL;
		if (pDict->getAt(sRecName, (AcDbObject *&)pXrec, AcDb::kForWrite) != Acad::eOk)
		{
			pXrec = new AcDbXrecord;
			AcDbObjectId xrecObjId;
			if (pDict->setAt(sRecName, pXrec, xrecObjId)!=Acad::eOk)
			{
				pDict->close();
				pDict = NULL;
				delete pXrec;
				return FALSE;
			}
			pHead = acutBuildList(AcDb::kDxfText, sXDList, 0);
		}
		else
		{
			pXrec->rbChain(&pHead);
			struct resbuf *pRb = pHead;
			pRb->resval.rstring = _tcsdup(sXDList);
		}
		pDict->close();
		pDict = NULL;
		pXrec->setFromRbChain(*pHead);
		acutRelRb(pHead);
		pXrec->close();
		pXrec = NULL;
		return TRUE;
	}

	BOOL GetColorIndex(CString sColor, unsigned long &nColor)
	{
		if (sColor==_T("红色"))
			nColor = 1;
		else if (sColor==_T("黄色"))
			nColor = 2;
		else if (sColor==_T("绿色"))
			nColor = 3;
		else if (sColor==_T("青色"))
			nColor = 4;
		else if (sColor==_T("蓝色"))
			nColor = 5;
		else if (sColor==_T("紫色"))
			nColor = 6;
		else if (sColor==_T("白色"))
			nColor = 7;
		else
			return FALSE;
		return TRUE;
	}

	void GetSoftPath(CString &sSoftPath)
	{
		sSoftPath = FilePath::GetRootDir() + _T("\\");
	}

	// 得到软件的安装路径
	void GetPathName(CString &sSoftPath)
	{
		sSoftPath = FilePath::GetRootDir() + _T("\\");
	}

	void dist_blkrcd_insert(AcDbDatabase *pDb, AcDbObjectIdArray BlcokIds, AcDbDatabase *pOrgDb)
	{
		CString sCommand;
		AcDbObjectId RcdId;

		if (pOrgDb==NULL)
			pOrgDb = acdbHostApplicationServices()->workingDatabase();

		acedSetStatusBarProgressMeter(_T("..处理中"), 0, BlcokIds.logicalLength());
		for (int nLen = 0; nLen<BlcokIds.logicalLength(); nLen++)
		{
			acedSetStatusBarProgressMeterPos(nLen);
			CString strName;
			AcDbBlockTableRecord *pRcd = NULL;
			TCHAR *name;
			AcDbBlockTableRecord::PreviewIcon  previewIcon;
			if (acdbOpenObject(pRcd, BlcokIds[nLen], AcDb::kForRead)!=Acad::eOk)
				continue;
			BOOL bHasPreviewIcon = pRcd->hasPreviewIcon();
			pRcd->getPreviewIcon(previewIcon);
			pRcd->getName(name);
			BOOL bIsdepend = pRcd->isDependent();
			pRcd->close();
			strName = _tcsdup(name);
			free(name);
			//acutPrintf("\nblockname=%s",strName);
			AcDbObjectIdArray objIds;
			AcDbDatabase *pInsertDb = new AcDbDatabase;
			if (pOrgDb->wblock(pInsertDb, BlcokIds[nLen])==Acad::eOk)
			{
				//	dist_db_delNoUseBlk(pInsertDb);
				Acad::ErrorStatus es;
				es = pDb->insert(RcdId, strName, pInsertDb);
				AcDbBlockTableRecord *pRcd = NULL;
				if (acdbOpenObject(pRcd, RcdId, AcDb::kForWrite)==Acad::eOk)
				{
					if (bHasPreviewIcon)
						pRcd->setPreviewIcon(previewIcon);
					pRcd->close();
					pRcd = NULL;
				}
			}

			delete pInsertDb;
		}
		acedRestoreStatusBar();

	}
	void dist_blkrcd_insert(CString strFilePath, AcDbObjectIdArray BlcokIds, AcDbDatabase *pOrgDb)
	{
		acDocManager->lockDocument(curDoc());
		AcDbDatabase *pDb = new AcDbDatabase(Adesk::kFalse);
#if ARX < 19
		Acad::ErrorStatus es = pDb->readDwgFile(strFilePath, SH_DENYNO);
#else
		Acad::ErrorStatus es = pDb->readDwgFile(strFilePath, AcDbDatabase::kForReadAndAllShare);
#endif
		if (es!=Acad::eOk)
		{
			acDocManager->unlockDocument(curDoc());
			return;
		}
		acDocManager->unlockDocument(curDoc());
		dist_blkrcd_insert(pDb, BlcokIds, pOrgDb);
		
		AcDb::AcDbDwgVersion dwgVer = pDb->originalFileVersion();
		es = pDb->saveAs(strFilePath, false, dwgVer);
		delete pDb;
		if (es != Acad::eOk)
		{
			acutPrintf(_T("\n保存失败。"));
			return;
		}
	}

	void dist_ent_getminmaxpt(AcDbObjectIdArray GroupIds, AcGePoint3d &ptMin, AcGePoint3d &ptMax)
	{
		for (int nLen = 0; nLen<GroupIds.logicalLength(); nLen++)
		{
			AcGePoint3d pt1;
			AcGePoint3d pt2;
			GetEntExt(GroupIds[nLen], pt2, pt1);
			if (nLen==0)
			{
				ptMin = pt1;
				ptMax = pt2;
			}
			else
			{
				if (pt1.x<ptMin.x)
					ptMin.x = pt1.x;
				if (pt1.y<ptMin.y)
					ptMin.y = pt1.y;
				if (pt2.x>ptMax.x)
					ptMax.x = pt2.x;
				if (pt2.y>ptMax.y)
					ptMax.y = pt2.y;
			}
		}
	}

	BOOL GetEntExt(AcDbEntity *pEnt, AcGePoint3d &ptMax, AcGePoint3d &ptMin)
	{
		AcDbExtents ex;
		AcGePoint3d ptOrg;
		AcDbExtents extLast;
		pEnt->getGeomExtents(ex);
		ptMax = ex.maxPoint();
		ptMin = ex.minPoint();
		return TRUE;
	}

	BOOL GetEntExt(AcDbObjectId EntId, AcGePoint3d &ptMax, AcGePoint3d &ptMin)
	{
		AcDbEntity *pEnt = NULL;
		if (acdbOpenObject(pEnt, EntId, AcDb::kForRead)!=Acad::eOk)
			return FALSE;
		BOOL bRet = GetEntExt(pEnt, ptMax, ptMin);
		pEnt->close();
		pEnt = NULL;
		return bRet;
	}

	//将选择集转成实体
	void dist_ss_ToIds(ads_name ssName, AcDbObjectIdArray &EnIds)
	{
		AcDbObjectId EntId;
		ads_name EntName;
		Adesk::Int32 nLength = 0;
		acedSSLength(ssName, &nLength);
		for (int nLen = 0; nLen<nLength; nLen++)
		{
			acedSSName(ssName, nLen, EntName);
			acdbGetObjectId(EntId, EntName);
			EnIds.append(EntId);
		}
	}

	HBITMAP BaseFuncs::BitmapFromDib(HANDLE hdib, HPALETTE hpal)
	{
		LPBITMAPINFOHEADER  lpbi;
		HPALETTE            hpalT;
		HDC                 hdc;
		HBITMAP             hbm;

		if (!hdib)
			return NULL;

		lpbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);

		if (!lpbi)
			return NULL;

		hdc = GetDC(NULL);

		if (hpal)
		{
			hpalT = SelectPalette(hdc, hpal, FALSE);
			RealizePalette(hdc);     // GDI Bug...????
		}

		hbm = CreateDIBitmap(hdc,
			(LPBITMAPINFOHEADER)lpbi,
			(LONG)CBM_INIT,
			(LPSTR)lpbi + lpbi->biSize + PaletteSize(lpbi),
			(LPBITMAPINFO)lpbi,
			DIB_RGB_COLORS);

		if (hpal)
			SelectPalette(hdc, hpalT, FALSE);

		ReleaseDC(NULL, hdc);
		GlobalUnlock(hdib);
		return hbm;
	}

	HANDLE readDibFromMemory(LPVOID pDibSrc)
	{
		LPBITMAPINFOHEADER pbmih = (LPBITMAPINFOHEADER)pDibSrc;

		DWORD totalSize = pbmih->biSize
			+ pbmih->biSizeImage
			+ (DWORD)PaletteSize(pbmih);

		HANDLE hdib = GlobalAlloc(GHND, totalSize);
		LPVOID pDibDst = GlobalLock(hdib);

		CopyMemory(pDibDst, pDibSrc, totalSize);

		GlobalUnlock(hdib);
		return hdib;
	}

	WORD PaletteSize(VOID FAR *pv)
	{
		LPBITMAPINFOHEADER lpbi;
		WORD               NumColors;

		lpbi = (LPBITMAPINFOHEADER)pv;
		NumColors = DibNumColors(lpbi);

		return (WORD)(NumColors * sizeof(RGBQUAD));
	}

	WORD DibNumColors(VOID FAR *pv)
	{
		INT                 bits;
		LPBITMAPINFOHEADER  lpbi;

		lpbi = ((LPBITMAPINFOHEADER)pv);

		if (lpbi->biClrUsed != 0)
			return (WORD)lpbi->biClrUsed;
		bits = lpbi->biBitCount;

		switch (bits) {
		case 1:
			return 2;
		case 4:
			return 16;
		case 8:
			return 256;
		default:
			/* A 24 bitcount DIB has no color table */
			return 0;
		}
	}

	void makeHatch3(CString sHatchName, AcDbObjectIdArray ExtIds, AcDbObjectIdArray DftIds, int nColor, double dAngle, double dScale)
	{
		AcDbHatch *pHatch = new AcDbHatch();
		AcGeVector3d normal(0.0, 0.0, 1.0);
		pHatch->setNormal(normal);
		pHatch->setElevation(0.0);
		Acad::ErrorStatus es1 = pHatch->setPattern(AcDbHatch::kPreDefined, sHatchName);
		pHatch->setAssociative(Adesk::kTrue);
		pHatch->setColorIndex(nColor);
		pHatch->setPatternAngle(dAngle);
		pHatch->setPatternScale(dScale);
		AcDbObjectId  hatchId;
		AcDbObjectIdArray dbObjIds;
		pHatch->appendLoop(AcDbHatch::kExternal, ExtIds);
		pHatch->appendLoop(AcDbHatch::kDefault, DftIds);

		pHatch->evaluateHatch();
		pHatch->getAssocObjIds(dbObjIds);
		AddEntToDb(pHatch, hatchId);

		AcDbEntity *pEnt;
		int numObjs = dbObjIds.length();
		Acad::ErrorStatus es;
		for (int i = 0; i < numObjs; i++) {
			es = acdbOpenAcDbEntity(pEnt, dbObjIds[i], AcDb::kForWrite);
			if (es == Acad::eOk) {
				pEnt->addPersistentReactor(hatchId);
				pEnt->close();
			}
		}

	}

	BOOL GetAttdefByBlockIdNew(AcDbObjectId BlockId, CStringArray &strTags, CStringArray &strPromts, CStringArray &strContents)
	{
		// 如果我们在这里结束程序,我们将看到当前图形中source.dwg已经被作为图块插入.但是图块中没有source.dwg所定义的Attibute. 因此我们还要做工作.后面的事情就简单了. 	
		//	acDocManagerPtr()->lockDocument(curDoc());

		AcDbBlockTableRecord *pBlockDef;
		if (acdbOpenObject(pBlockDef, BlockId, AcDb::kForRead)!=Acad::eOk)
			return FALSE;

		AcDbBlockTableRecordIterator *pIterator;
		pBlockDef->newIterator(pIterator);
		AcGePoint3d basePoint;
		AcDbEntity *pEnt;
		AcDbAttributeDefinition *pAttdef;
		for (pIterator->start(); !pIterator->done();
			pIterator->step())//将source.dwg中所有的Attibute进行遍历 
		{
			pIterator->getEntity(pEnt, AcDb::kForRead);
			pAttdef = AcDbAttributeDefinition::cast(pEnt);
			if (pAttdef != NULL && !pAttdef->isConstant())
			{
				strTags.Add(pAttdef->tag());
				strPromts.Add(pAttdef->prompt());
				strContents.Add(pAttdef->textString());
			}
			pEnt->close(); // use pEnt... pAttdef might be NULL 
		}
		pBlockDef->close();
		delete pIterator;
		if (strTags.GetSize()>0)
			return TRUE;
		else
			return FALSE;
	}

	BOOL  GetBlockCommand(CString sDwgPath, CString sBlockName, CString &sCommand)
	{
		return FALSE;
		sCommand = "";
		CString sDwgName = _T("命令名");
		AcDbDictionary *pNameObj, *pDict;
		acDocManagerPtr()->lockDocument(curDoc());
		AcDbDatabase *pDb = new AcDbDatabase(Adesk::kFalse);
		pDb->readDwgFile(sDwgPath);
		if (pDb->getNamedObjectsDictionary(pNameObj, AcDb::kForWrite)!=Acad::eOk)
		{
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
		if (pNameObj->getAt(sDwgName, (AcDbObject *&)pDict, AcDb::kForRead)!=Acad::eOk)
		{
			pNameObj->close();
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
		pNameObj->close();
		AcDbXrecord *pXrec;
		if (pDict->getAt(sBlockName, (AcDbObject *&)pXrec, AcDb::kForRead)!=Acad::eOk)
		{
			pDict->close();
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
		pDict->close();
		struct resbuf *pRbList;
		pXrec->rbChain(&pRbList);
		pXrec->close();
		sCommand = pRbList->resval.rstring;
		//	acutRelRb(pRbList);
		acDocManagerPtr()->unlockDocument(curDoc());
		delete pDb;
		sCommand.TrimLeft();
		sCommand.TrimRight();
		if (sCommand==_T(""))
			return FALSE;
		return TRUE;
	}

	BOOL GetColorIndex(CString sTextPath, CString sKey, int &nRcolor, int &nGcolor, int &nBcolor)
	{
		int nIndex = 0;
		CString sContent;
		CFile file;
		if (!file.Open(sTextPath, CFile::modeRead))
			return FALSE;
		CArchive ar(&file, CArchive::load);
		while (ar.ReadString(sContent))
		{
			if (sContent.Find(sKey)>=0)
			{
				CString sG;
				CString sR;
				CString sB;
				sContent = sContent.Right(sContent.GetLength()-sKey.GetLength());
				sContent.TrimLeft();
				sContent.TrimRight();
				int nFind;
				nFind = sContent.Find(_T(','));
				sR = sContent.Left(nFind);
				sContent = sContent.Right(sContent.GetLength()-nFind-1);

				nFind = sContent.Find(_T(','));
				sG = sContent.Left(nFind);
				sContent = sContent.Right(sContent.GetLength()-nFind-1);

				sB = sContent;
				nRcolor = _ttoi(sR);
				nGcolor = _ttoi(sG);
				nBcolor = _ttoi(sB);
				return TRUE;

			}
		}
		return FALSE;
	}

	BOOL GetBlockId(CString sDwgFilePath, AcDbObjectId &BlockId)
	{
		acDocManagerPtr()->lockDocument(curDoc());
		CString sFileName;
		sFileName = sDwgFilePath.Right(sDwgFilePath.GetLength()-sDwgFilePath.ReverseFind('\\')-1);
		//	sFileName.TrimRight(".dwg");
		//	sFileName.TrimRight(".DWG");
		AcDbDatabase *pNewDb = new AcDbDatabase(Adesk::kFalse);
		pNewDb->readDwgFile(sDwgFilePath);
		AcDbBlockTable *pBlkTable = NULL;
		acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pBlkTable, AcDb::kForWrite);
		if (pBlkTable->has(sFileName))
		{
			pBlkTable->getAt(sFileName, BlockId);
			pBlkTable->close();
			acDocManagerPtr()->unlockDocument(curDoc());
			return TRUE;
		}
		pBlkTable->close();
		acdbHostApplicationServices()->workingDatabase()->insert(BlockId, sFileName, pNewDb);
		delete pNewDb;
		acDocManagerPtr()->unlockDocument(curDoc());
		return TRUE;
	}

	BOOL RenameBlock(AcDbDatabase *&pDb, CString sOldName, CString sNewName)
	{
		BOOL bRet = FALSE;
		acDocManagerPtr()->lockDocument(curDoc());
		AcDbObjectId RcdId;
		AcDbBlockTableRecord *pRcd = NULL;
		AcDbBlockTable *pBlkTable;
		pDb->getBlockTable(pBlkTable, AcDb::kForRead);
		if (pBlkTable->has(sNewName))
		{
			acutPrintf(_T("\n该块名已被使用"));
			pBlkTable->close();
			pBlkTable = NULL;
			acDocManagerPtr()->unlockDocument(curDoc());
			ClearAcadCmdLine();
			return FALSE;

		}
		if (pBlkTable->getAt(sOldName, pRcd, AcDb::kForWrite)==Acad::eOk)
		{
			pRcd->setName(sNewName);
			pRcd->close();
			pRcd = NULL;
			bRet = TRUE;
		}
		pBlkTable->close();
		pBlkTable = NULL;
		acDocManagerPtr()->unlockDocument(curDoc());
		return bRet;
	}

	BOOL RenameBlock(CString sDwgName, CString sOldName, CString sNewName)
	{
		BOOL bRet = FALSE;
		acDocManagerPtr()->lockDocument(curDoc());
		Acad::ErrorStatus es;
		AcDbDatabase *pDb = new AcDbDatabase(Adesk::kFalse);

#if ARX < 19
		es = pDb->readDwgFile(sDwgName, SH_DENYNO);
#else
		es = pDb->readDwgFile(sDwgName, AcDbDatabase::kForReadAndAllShare);
#endif

		AcDbObjectId RcdId;
		AcDbBlockTableRecord *pRcd = NULL;
		AcDbBlockTable *pBlkTable;
		if ((es = pDb->getBlockTable(pBlkTable, AcDb::kForRead))!=Acad::eOk)
		{
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
		if (pBlkTable->has(sNewName))
		{
			acutPrintf(_T("\n该块名已被使用"));
			pBlkTable->close();
			pBlkTable = NULL;
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;

		}


		pBlkTable->getAt(sOldName, RcdId);
		pBlkTable->close();
		pBlkTable = NULL;

		if (acdbOpenObject(pRcd, RcdId, AcDb::kForWrite)!=Acad::eOk)
		{
			delete pDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;

		}
		pRcd->setName(sNewName);
		pRcd->close();
		pRcd = NULL;
		acDocManagerPtr()->unlockDocument(curDoc());
		
		AcDb::AcDbDwgVersion dwgVer = pDb->originalFileVersion();
		pDb->saveAs(sDwgName, false, dwgVer);

		delete pDb;
		return TRUE;
	}

	void InsertBlockRef1(AcDbObjectId BlockId, AcDbObjectId &BlockRefId, AcGePoint3d ptInsert,
		AcGeScale3d scale, double dAngle, BOOL bCreate)
	{
		if (BlockId==NULL)
			return;
		if (bCreate==TRUE)
		{
			AcDbBlockReference *pBref = new AcDbBlockReference(ptInsert, BlockId);
			pBref->setScaleFactors(scale);
			pBref->setRotation(dAngle);

			AddEntToDb(pBref, BlockRefId, NULL);
		}

		CStringArray strTags;
		CStringArray strPromts;
		CStringArray strContents;
		CStringArray strContentsNew;
		CString sPrompt;
		//判断是不是属性块
		if (!GetAttdefByBlockIdNew(BlockId, strTags, strPromts, strContents))
			return;

		int nLength = (int)strTags.GetSize();
		int nLen = 0;
		for (nLen = 0; nLen<nLength; nLen++)
		{
			strContentsNew.Add(strContents[nLen]);
		}
		nLen = 0;
		AcDbObjectId newEntId;
		CString strTag;
		CString strPromt;
		AcDbBlockReference *pBlkRef = NULL;
		if (acdbOpenObject(pBlkRef, BlockRefId, AcDb::kForWrite)!=Acad::eOk)
			return;

		AcDbBlockTableRecord *pBlockDef;
		if (acdbOpenObject(pBlockDef, BlockId, AcDb::kForRead)!=Acad::eOk)
		{
			pBlkRef->close();
			pBlkRef = NULL;
			acutPrintf(_T("\n打开块表记录失败"));
			return;
		}
		AcDbBlockTableRecordIterator *pIterator;
		pBlockDef->newIterator(pIterator);
		AcGePoint3d basePoint;
		AcDbEntity *pEnt;
		AcDbAttributeDefinition *pAttdef;
		AcDbObjectIdArray attIds;
		for (pIterator->start(); !pIterator->done();
			pIterator->step())//将source.dwg中所有的Attibute进行遍历 
		{
			pIterator->getEntity(pEnt, AcDb::kForRead);
			pAttdef = AcDbAttributeDefinition::cast(pEnt);
			if (pAttdef != NULL && !pAttdef->isConstant()) {

				AcDbAttribute *pAtt = new AcDbAttribute();
				pAtt->setLayer(pAttdef->layer());
				pAtt->setColorIndex(pAttdef->colorIndex());
				pAtt->setColor(pAttdef->color());
				pAtt->setTextStyle(pAttdef->textStyle());
				pAtt->setPropertiesFrom(pAttdef);
				pAtt->setInvisible(pAttdef->isInvisible());
				basePoint = pAttdef->position();
				//   basePoint += pBlkRef->position().asVector(); 
				pAtt->setPosition(basePoint);
				pAtt->setHeight(pAttdef->height());
				//pAtt->setRotation(pAttdef->rotation()+dAngle);   
				pAtt->setTag(pAttdef->tag());
				pAtt->setFieldLength(pAttdef->fieldLength());
				pAtt->setTextString(strContentsNew[nLen++]);
				pAtt->setHorizontalMode(pAttdef->horizontalMode());
				pAtt->setVerticalMode(pAttdef->verticalMode());
				pAtt->setAlignmentPoint(pAttdef->alignmentPoint());
				AcDbObjectId attId;
				pAtt->setAttributeFromBlock(pBlkRef->blockTransform());
				//	ScaleEnt(ptInsert,pAtt,scale);
				//	RotateEnt1(ptInsert,pAtt,dAngle);
				pBlkRef->appendAttribute(attId, pAtt);
				pAtt->close();
				attIds.append(attId);
			}
			pEnt->close();
		}
		pBlockDef->close();
		pBlkRef->close();
		pBlkRef = NULL;
		delete pIterator;
	}

	void GetInIFolderAndIcon(CString sIniName, CStringArray &sFolderArr, CStringArray &sBigIconArr, CStringArray &sSmllIconArr)
	{
		CStringArray sIconArr;
		ACHAR  sIconName[256];
		ACHAR  sDwgName[256];
		CString sDefautStr;
		CString sAppName;
		int nIndex = sIniName.ReverseFind(_T('\\'));
		sAppName = sIniName.Right(sIniName.GetLength()-nIndex-1);
		GetPrivateProfileString(sAppName, _T("文件夹"), sDefautStr, sDwgName, 256, sIniName+_T(".ini"));
		JxString(sDwgName, sFolderArr);
		if (sFolderArr.GetSize()<1)
			return;
		GetPrivateProfileString(sAppName, _T("FOLDERICON"), sDefautStr, sIconName, 256, sIniName+_T(".ini"));
		JxString(sIconName, sIconArr);
		CString sBigIcon = sIconArr[0];
		CString sSmallIcon = sIconArr[1];
		for (int nLen = 0; nLen<sFolderArr.GetSize(); nLen++)
		{
			GetPrivateProfileString(sAppName, sFolderArr[nLen], sDefautStr, sIconName, 256, sIniName+_T(".ini"));
			CString sIcon = sIconName;
			sIcon.TrimLeft();
			sIcon.TrimRight();
			if (sIcon==_T(""))
			{
				sBigIconArr.Add(sBigIcon);
				sSmllIconArr.Add(sSmallIcon);
			}
			else
			{
				sIconArr.SetSize(0);
				JxString(sIconName, sIconArr);
				sBigIconArr.Add(sIconArr[0]);
				sSmllIconArr.Add(sIconArr[1]);
			}
		}

	}

	void JxString(CString str, CStringArray &strArr)
	{
		CString strZj;
		CString strFind = str;
		str.TrimLeft();
		str.TrimRight();
		if (str==_T(""))
			return;
		int nIndex = strFind.Find(_T(","), 0);
		while (nIndex>=0)
		{
			int nLength = strFind.GetLength();
			strZj = strFind.Left(nIndex);
			strFind = strFind.Right(nLength-nIndex-1);
			nIndex = strFind.Find(_T(","), 0);
			strArr.Add(strZj);
		}
		strArr.Add(strFind);
	}

	BOOL GetJd(AcGePoint3d pt1, AcGePoint3d pt2, AcGeVector3d vt, AcGePoint3d ptOut, AcGePoint3d &ptJd)
	{
		AcGePoint3dArray ptJds;
		AcDbLine *pLine = new AcDbLine(pt1, pt2);
		AcDbLine *pLine1 = new AcDbLine(ptOut, ptOut+vt);
		pLine->intersectWith(pLine1, AcDb::kExtendBoth, ptJds);
		delete pLine;
		if (ptJds.logicalLength()!=1)
			return FALSE;
		ptJd = ptJds[0];
		return TRUE;
	}

	void CAD_FlushAcadGraphicsQueue()
	{
		if (acdbHostApplicationServices()->workingDatabase() && actrTransactionManager)
		{
			actrTransactionManager->flushGraphics();
			acedUpdateDisplay();
		}
	}

	void MoveRecordToZ0(AcDbBlockTable* pBlockTable,CString& sBlockName)
	{
		//整体移动,最低为点0,0
		AcDbBlockTableRecord* pRec = NULL;
		if ( Acad::eOk == pBlockTable->getAt(sBlockName,pRec,AcDb::kForRead) )
		{
			AcDbBlockTableRecordIterator* pIt = NULL;
			pRec->newIterator(pIt);

			if (pIt != NULL)
			{
				AcGePoint3d ptMin;
				double dMinZ = 999999999.0;
				AcDbExtents extT;
				AcDbEntity* pEnt = NULL;
				for ( pIt->start();!pIt->done();pIt->step() )
				{
					if ( Acad::eOk == pIt->getEntity(pEnt,AcDb::kForRead) )
					{
						pEnt->getGeomExtents(extT);
						ptMin = extT.minPoint();

						if (dMinZ > ptMin.z)
						{
							dMinZ = ptMin.z;
						}
						pEnt->close();
					}
				}

				AcGeVector3d vtM(0,0,-dMinZ);
				AcGeMatrix3d xform;
				xform.setToTranslation(vtM);

				for ( pIt->start();!pIt->done();pIt->step() )
				{
					if ( Acad::eOk == pIt->getEntity(pEnt,AcDb::kForWrite) )
					{
						pEnt->transformBy(xform);
						pEnt->close();
					}
				}

				delete pIt;
			}
			pRec->close();
		}
	}

	BOOL InSertBlockFromDwgToCurDb(CString sDwgPath, CString sBlockName, AcDbObjectId &BlockId)
	{
		Acad::ErrorStatus es;
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		AcDbBlockTable *pBlockTable = NULL;
		if (pDb->getBlockTable(pBlockTable, AcDb::kForRead)!=Acad::eOk)
			return FALSE;
		if (pBlockTable->getAt(sBlockName, BlockId)==Acad::eOk)
		{
			//MoveRecordToZ0(pBlockTable,sBlockName);
			pBlockTable->close();
			pBlockTable = NULL;
			return FALSE;
		}
		pBlockTable->close();
		pBlockTable = NULL;
		acDocManagerPtr()->lockDocument(curDoc());
		AcDbDatabase *pNewDb = new AcDbDatabase(Adesk::kFalse);
		pNewDb->readDwgFile(sDwgPath);

		AcDbObjectId RcdId;
		if (pNewDb->getBlockTable(pBlockTable, AcDb::kForRead)!=Acad::eOk)
		{
			delete pNewDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
	#if ARX > 24
		if (pBlockTable->getAt(sBlockName, RcdId)!=Acad::eOk)
	#else
		if (pBlockTable->getAt(sBlockName, RcdId, AcDb::kForRead)!=Acad::eOk)
	#endif
		{
			pBlockTable->close();
			pBlockTable = NULL;
			delete pNewDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}

		MoveRecordToZ0(pBlockTable,sBlockName);
		pBlockTable->close();
		pBlockTable = NULL;

		AcDbDatabase *pInsertDb = new AcDbDatabase;
		if ((es = pNewDb->wblock(pInsertDb, RcdId))!=Acad::eOk)
		{
			delete pInsertDb;
			delete pNewDb;
			acDocManagerPtr()->unlockDocument(curDoc());
			return FALSE;
		}
		es = pDb->insert(BlockId, sBlockName, pInsertDb);
		delete pNewDb;
		delete pInsertDb;
		acDocManagerPtr()->unlockDocument(curDoc());
		return TRUE;
	}

	void DrawBlockFun()
	{
		g_BlockId = NULL;
		AcGeVector3d g_vt = AcGeVector3d(0, 0, 0);
		g_dAngle = 0.0;
		BOOL bGet = FALSE;
		TCHAR cValue[256];
		CString sDefautStr;
		CString strPathName;
		BaseFuncs::GetPathName(strPathName);
		strPathName += _T("\\tk\\Customer\\图库中心");
		CString strSubPath = g_strInsertDwgPath;

		CString subPath(strSubPath), pathName(strPathName);
		subPath.MakeUpper();
		pathName.MakeUpper();

		if (subPath.Find(pathName, 0)>=0)
			subPath = subPath.Right(subPath.GetLength()-pathName.GetLength());
		bGet = GetPrivateProfileString(subPath, g_strInsertBlockName, sDefautStr, cValue, 256, pathName+_T("\\dwglib.ini"));
		BaseFuncs::InSertBlockFromDwgToCurDb(g_strInsertDwgPath, g_strInsertBlockName, g_BlockId);
		if (g_BlockId==NULL)
			return;
		//	 AfxMessageBox("44");
		CAcModuleResourceOverride res;
		Showtkcsdlg(TRUE);
		g_TkcsDlg->m_strAngle = "0.0";
		g_TkcsDlg->m_strScaleX = "1.0";
		g_TkcsDlg->m_strScaleY = "1.0";
		g_TkcsDlg->m_strScaleZ = "1.0";

		CStringArray strArr;
		BaseFuncs::JxString(cValue, _T(","), strArr);
		BOOL bAutoScale = FALSE;
		BOOL bAutoExplode = FALSE;
		BOOL bMM = FALSE;
		if (strArr.GetSize()==3)
		{
			bMM = _ttoi(strArr[0]);
			bAutoScale = _ttoi(strArr[1]);
			bAutoExplode = _ttoi(strArr[2]);
		}

		if (!bMM) //图块的原始单位是米
		{
			if (BaseFuncs::IsMMUnitForDwg()) //毫米
			{
				g_TkcsDlg->m_strScaleX.Format(_T("%0.4f"), 1000.0);
				g_TkcsDlg->m_strScaleY.Format(_T("%0.4f"), 1000.0);
				g_TkcsDlg->m_strScaleZ.Format(_T("%0.4f"), 1000.0);
			}
		}
		else
		{
			if (!BaseFuncs::IsMMUnitForDwg())//米
			{
				g_TkcsDlg->m_strScaleX.Format(_T("%0.4f"), 0.001);
				g_TkcsDlg->m_strScaleY.Format(_T("%0.4f"), 0.001);
				g_TkcsDlg->m_strScaleZ.Format(_T("%0.4f"), 0.001);
			}
		}
		if (bAutoScale)
		{
			if (!BaseFuncs::IsMMUnitForDwg())//米
			{
				g_TkcsDlg->m_strScaleX.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleX));
				g_TkcsDlg->m_strScaleY.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleY));
				g_TkcsDlg->m_strScaleZ.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleZ));
			}
			else
			{
				g_TkcsDlg->m_strScaleX.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleX)/1000.0);
				g_TkcsDlg->m_strScaleY.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleY)/1000.0);
				g_TkcsDlg->m_strScaleZ.Format(_T("%0.4f"), _ttof(g_TkcsDlg->m_strScaleZ)/1000.0);
			}
		}



		g_TkcsDlg->m_strLengthX.Format(_T("%0.3f"), _ttof(g_TkcsDlg->m_strScaleX)*g_TkcsDlg->m_dUnitLengthX);
		g_TkcsDlg->m_strLengthY.Format(_T("%0.3f"), _ttof(g_TkcsDlg->m_strScaleY)*g_TkcsDlg->m_dUnitLengthY);
		g_TkcsDlg->m_strLengthZ.Format(_T("%0.3f"), _ttof(g_TkcsDlg->m_strScaleZ)*g_TkcsDlg->m_dUnitLengthZ);
		g_TkcsDlg->UpdateData(FALSE);

		//g_TkcsDlg->UpdateDataAll(); 
		CLayer layer(_T("图库中心"), g_sLayerName);
		while (1)
		{
			acedGetAcadDwgView()->SetFocus();
			BOOL bAppend = FALSE;
			AcEdBlockDrag *drag = new AcEdBlockDrag(g_BlockId, g_dBlockScale, g_dAngle, g_vt);
			drag->doIt();
			bAppend = drag->m_bAppend;
			g_dAngle = drag->m_dAngle;
			g_dBlockScale = drag->m_dScale;
			g_vt = drag->m_vt;
			AcDbObjectId objId = drag->m_objId;
			delete drag;
			drag = NULL;

			if (!bAppend)
				break;

			if (bAutoExplode)
			{
				AcDbVoidPtrArray voidPtrArr;
				AcDbEntity *pEnt = NULL;
				if (acdbOpenObject(pEnt, objId, AcDb::kForRead)==Acad::eOk)
				{
					pEnt->explode(voidPtrArr);
					pEnt->close();
					pEnt = NULL;
				}
				for (int nLen = 0; nLen<voidPtrArr.logicalLength(); nLen++)
				{
					AcDbObjectId objId;
					AddEntToDb((AcDbEntity *)voidPtrArr[nLen], objId);
				}
				DeleteEnt(objId);
			}
			CAD_FlushAcadGraphicsQueue();
			//	break; 
		}
		Showtkcsdlg(FALSE);
		acedGetAcadFrame()->ShowControlBar(g_pDockPane, TRUE, FALSE);
	}

	BOOL GetLayerParam(CString sAppName, CString sLayerName, LayerParam &pm)
	{
		CStringArray strArr;
		CString sDefautStr;
		TCHAR sLayerParam[256];
		CString sSoftPath;
		GetSoftPath(sSoftPath);
		GetPrivateProfileString(sAppName, sLayerName, sDefautStr, sLayerParam, 256, sSoftPath+_T("\\Sys\\LayerConfig.ini"));
		JxString(sLayerParam, strArr);
		if (strArr.GetSize()==8)
		{
			pm.sKey = sLayerName;
			pm.sLayerName = strArr[0];
			pm.nColorIndex = _ttoi(strArr[1]);
			pm.strColor = strArr[1];
			pm.dLineWidth = _ttof(strArr[2]);
			pm.sLineType = strArr[3];
			pm.bClose = _ttoi(strArr[4]);
			pm.bFreeze = _ttoi(strArr[5]);
			pm.bvpdflt = _ttoi(strArr[6]);
			pm.bLock = _ttoi(strArr[7]);

			return TRUE;
		}
		return FALSE;
	}

	void CreateLineType(CString sLineTypeName, AcDbObjectId &LineTypeId)
	{
		CString sSoftPath;
		GetSoftPath(sSoftPath);
		sSoftPath += _T("Sys\\Customer.lin");
		Acad::ErrorStatus es = acdbLoadLineTypeFile(sLineTypeName, sSoftPath, acdbHostApplicationServices()->workingDatabase());
		AcDbLinetypeTable *pLineTpTable;
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		pDb->getLinetypeTable(pLineTpTable, AcDb::kForWrite);
		pLineTpTable->getAt(sLineTypeName, LineTypeId);
		pLineTpTable->close();
	}

	void GetLineTypeId(CString sLineTypeName, AcDbObjectId &LineTypeId)
	{
		AcDbLinetypeTable *pLineTpTable;
		AcDbDatabase *pDb = acdbHostApplicationServices()->workingDatabase();
		pDb->getLinetypeTable(pLineTpTable, AcDb::kForRead);
		pLineTpTable->getAt(sLineTypeName, LineTypeId);
		pLineTpTable->close();
	}

	AcDbObjectId CreateLayer(CString sAppName, CString sLayerName)
	{
		AcDbObjectId LineTypeId;
		LayerParam pm;
		AcDbObjectId LayerId;
		AcDbLayerTable *pLayerTbl;
		acdbHostApplicationServices()->workingDatabase()
			->getSymbolTable(pLayerTbl, AcDb::kForWrite);

		if (GetLayerParam(sAppName, sLayerName, pm))
		{
			sLayerName = pm.sLayerName;
			if (!pLayerTbl->has(sLayerName))
			{
				AcDbLayerTableRecord *pLayerTblRcd = new AcDbLayerTableRecord;
				pLayerTblRcd->setName(sLayerName);
				pLayerTblRcd->setIsFrozen(pm.bFreeze ? true : false);
				pLayerTblRcd->setIsOff(pm.bClose ? true : false);
				pLayerTblRcd->setVPDFLT(pm.bvpdflt ? true : false);
				pLayerTblRcd->setIsLocked(pm.bLock ? true : false);
				GetLineTypeId(pm.sLineType, LineTypeId);
				if (LineTypeId==NULL)
					CreateLineType(pm.sLineType, LineTypeId);
				if (LineTypeId!=NULL)
					pLayerTblRcd->setLinetypeObjectId(LineTypeId);
				//	pLayerTblRcd->setLineWeight(pm.dLineWidth);
				//	pLayerTblRcd->setL
				AcCmColor color;
				color.setColorIndex(pm.nColorIndex);
				pLayerTblRcd->setColor(color);
				pLayerTbl->add(pLayerTblRcd);
				pLayerTblRcd->close();
			}
			//  pLayerTbl->close();
		}
		pLayerTbl->getAt(sLayerName, LayerId);
		pLayerTbl->close();
		return LayerId;
	}

	bool IsMMUnitForDwg()
	{
		struct resbuf rb;
		acedGetVar(_T("INSUNITS"), &rb);
		if (rb.resval.rint == AcDb::kUnitsMillimeters)
			return true;
		return false;
	}

	void OpenTkAndSelectByName(LPCTSTR pszFolder, LPCTSTR pszDwg)
	{
		// 首先打开库图
		if (g_pDockPane == NULL)
		{
			AfxSetResourceHandle(_hdllInstance);
			g_pDockPane = new CDockPane;
			g_pDockPane->Create(acedGetAcadFrame(), _T("图库中心"));
			AfxSetResourceHandle(acedGetAcadResourceInstance());
			g_pDockPane->EnableDocking(CBRS_ALIGN_ANY);

			g_pDockPane->m_DockDialog.m_pMyFrame->ShowExplainCtrl();
			g_pDockPane->RestoreControlBar();
		}
		else
		{
			acedGetAcadFrame()->ShowControlBar(g_pDockPane, TRUE, FALSE);
		}

		if (pszFolder && pszDwg)
		g_pDockPane->SetSltDwgFile(pszFolder, pszDwg);
	}
	void updateBlockIcon()
	{
		SHacedCommand(RTSTR, _T("blockIcon"), RTSTR, _T(""), 0);
	}
}

namespace BaseFuncs
{
	CLayer::CLayer(CString sAppName, CString sLyaerName, BOOL bRet)
	{
		m_bRet = bRet;
		m_OldId = acdbHostApplicationServices()->workingDatabase()->clayer();
		AcDbObjectId LayerId = CreateLayer(sAppName, sLyaerName);
		acdbHostApplicationServices()->workingDatabase()->setClayer(LayerId);
		AcDbLayerTableRecord *pRcd = NULL;
		if (acdbOpenObject(pRcd, LayerId, AcDb::kForWrite)==Acad::eOk)
		{
			pRcd->setIsOff(FALSE);
			pRcd->close();
			pRcd = NULL;
		}
	}
	CLayer::~CLayer()
	{
		if (m_bRet)
			acdbHostApplicationServices()->workingDatabase()->setClayer(m_OldId);
	}
}