//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   导出全局函数实现文件
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   全局函数的声明
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "acgs.h"
#include "XGlobalFunc.h"
#include "XAdvanceSampler.h"

#include "XScreenDc.h"
#include "XBlockTableRecPtr.h"
#include "XPushVar.h"
#include "XPushMemVar.h"
#include "XDbObject.h"
#include "XPathParser.h"
#include "XPushPrec.h"
#include "XDrawingLib.h"
#include "XAsdkCustomWorldDraw.h"

#include "XDbLayerTableRec.h"
#include "XHoleModel.h"
#include "AEntityBase.h"

#include "XAsdkShellData.h"
#include "XBlockTable.h"
#include "CTempTol.h"
#include "RegProperty.h"
#include "CImageDC.h"
#include "CImageDCEx.h"
#include "AString.h"
#include "UString.h"
#include "imgdef.h"
#include "imgent.h"
#include "direct.h"
#include "errno.h"
#include "dbregion.h"
#include "SymbolTable.h"
#include "dbltrans.h"
#include "lngtrans.h"
#include "dbhatch.h"
#include "StyleTable.h"
#include "DragPickEntSet.h"
#include "XWcsStream.h"
#include "XUcsStream.h"
#include "TextRange.h"
#include "XPushMMUnit.h"
#include "SqlQuiry.h"
#include "SafeResource.h"
#include "XConfigBase.h"
#include "io.h"
#include "afxdisp.h"
#include "XRectAngle.h"
#include "WValList.h"

//#include "dwgcplib.h"
#include "XBlockTableRecordZone.h"
#include "XPrivateGlobalFunc.h"
#include "comutil.h"

static const TCHAR *sMsgPrompt[] =
{
	/*MSG0*/ _T("\n目标位置:"),
	/*MSG1*/ _T("\n缩放比例<1.0>: "),
	/*MSG2*/ _T("\n输入无效!"),
	/*MSG3*/ _T("\n旋转角度<0.0>: "),
};

static int			KwIndex = NOP;              /* Index into kwtab */
static int			m_nPos = 0;
static int			g_nFlag = 0;
static int			g_nDragFlag = 0;			//默认为非移动

static XPoint		g_ptCursorWcs;				//热键发生时的光标位置

static ads_point	Base;                       /* Base point for xform */
static double		scr_h;                      /* current vport height */
static ads_matrix   CTM;						/* Current Transformation Matrix */

static TCHAR		g_szKeyTable[256] = _T("");
static TCHAR		m_szCommandStr[1024] = _T("");

static int CompareDouble(const double *p1, const double *p2)
{
    if(*p1>*p2)
        return 1;
    return -1;
}

//	根据绕X轴旋转的点初始化矩阵
//	参数： VSINX: 旋转角度的正弦值
//         VCOSX: 旋转角度的余弦值
static void rota_X_init(ads_matrix rota_X,double VSINX,double VCOSX)
{
	
	AT_InitIdenMat(rota_X);
	
	rota_X[1][1] = rota_X[2][2] = VCOSX;
	rota_X[2][1] = VSINX;
	rota_X[1][2] = 0.0 - VSINX;
}

//	根据绕Z轴旋转的点初始化矩阵
//	参数： VSINZ: 旋转角度的正弦值
//         VCOSZ: 旋转角度的余弦值
static void rota_Z_init(ads_matrix rota_Z,double VSINZ,double VCOSZ)
{
	AT_InitIdenMat(rota_Z);
	
	rota_Z[0][0] = rota_Z[1][1] = VCOSZ;
	rota_Z[1][0] = VSINZ;
	rota_Z[0][1] = 0.0 - VSINZ;
}

static double ads_fabsv(ads_point ap)
{
    return sqrt(ap[X] * ap[X] + ap[Y] * ap[Y] + ap[Z] * ap[Z]);
}

static void ads_subvec(ads_point ap, ads_point bp, ads_point dp)
{
    dp[X] = ap[X] - bp[X];
    dp[Y] = ap[Y] - bp[Y];
    dp[Z] = ap[Z] - bp[Z];
}

static double ads_dist(ads_point p1, ads_point p2)
{
    ads_point pd;
    ads_subvec(p1, p2, pd);
    return ads_fabsv(pd);
}

static void ads_mat_ident(ads_matrix matrix)
{
     memcpy(matrix, ads_identmat, sizeof(ads_matrix));
}

static void ads_mat_rot(double angle, int axis, ads_matrix m)
{
    int axp1, axp2;
	
    axp1 = (axis + 1) % 3;
    axp2 = (axis + 2) % 3;
    ads_mat_ident(m);
    m[axp1][axp1] = m[axp2][axp2] = cos(angle);
    m[axp1][axp2] = -(m[axp2][axp1] = sin(angle));
}

static void ads_mat_scale(double xscale, double yscale, double zscale, ads_matrix m)
{
    ads_mat_ident(m);
    m[X][X] = xscale;
    m[Y][Y] = yscale;
    m[Z][Z] = zscale;
}

static void ads_mat_x_vec(ads_matrix mat, ads_point pin, ads_point pout)
{
    int i;
    ads_point temp;
    for (i = X; i <= Z; i++)
	{
        temp[i] = mat[i][X] * pin[X] + mat[i][Y] * pin[Y] +	mat[i][Z] * pin[Z];
	}
    memcpy(pout, temp, sizeof(ads_point));
}

static int IsDigit(const char *str)
{
	int len = strlen(str);
	for(int i = 0; i < len; i++) 
	{
		if(!isdigit(str[i]))
		{
			return 0;
		}
	}
	return 1;
}

static int AT_mod_arcp(ads_name ent_arc, int code, ads_point pt)
{
	struct resbuf *ebuf, *rb;
	ads_point cenpt;
	
	ebuf = ads_entget(ent_arc);
	rb = AT_get_resbuf(ebuf, 10);
	Cpoint(cenpt, rb->resval.rpoint);
	rb = AT_get_resbuf(ebuf, code);
	rb->resval.rreal = ads_angle(cenpt, pt);
	ads_entmod(ebuf);
	ads_relrb(ebuf);
	
	return 1;
}

static int init_cir(ads_name all_set)
{
	Entity cir1, cir2;
	double ang1, ang2, rad1, rad2;
	ads_point cen1, cen2;
	long i,j;
	long len;
	
	PickSet ssAll = all_set, cir_set(SS_FREE|SS_CREATE), del_set(SS_FREE|SS_CREATE);
	len = ssAll.Length();
	for (i = 0; i<len; i++) 
	{
		Entity ent = ssAll[i];
		if (ent.Is(_T("CIRCLE"))) 
		{
			cir_set += ent;
		}
	}
	
	len = cir_set.Length();
	for (i = 0; i < len; i++) 
	{
		ads_ssname(cir_set,i,cir1);
		Entity cir1 = cir_set[i];
		if (cir1.In(&del_set))  
		{
			continue;
		}
		
		AT_get_cirarcp(cir1, cen1, &rad1, &ang1, &ang2);
		if (rad1<_DIST_SNAP) 
		{ // zero radius
			del_set += cir1;
			ads_ssadd(cir1, del_set, del_set);
			continue;
		}
		
		for (j = 0; j < len; j++) 
		{
			Entity cir2 = cir_set[j];
			if (cir1 == cir2 || cir2.In(&del_set))
			{
				continue;
			}

			
			AT_get_cirarcp(cir2, cen2, &rad2, &ang1, &ang2);
			if ( ads_distance(cen1,cen2) <= _DIST_SNAP && fabs(rad1 - rad2) < _DIST_SNAP)
			{
				del_set += cir2;
			}
		}
	}
	ssAll -= del_set;
	del_set.Erase();
	return RTNORM;
}

static int init_arc(ads_name all_set)
{
	
	Entity arc1, arc2;
	double s_ang1, s_ang2, e_ang1, e_ang2, rad1, rad2;
	ads_point cen1, cen2;
	long i,j;
	long len;
	ads_point a2_pt1, a2_pt2, a1_pt1, a1_pt2;
		
	PickSet ssAll = all_set, arc_set(SS_FREE|SS_CREATE), del_set(SS_FREE|SS_CREATE);
	len = ssAll.Length();
	for (i = 0; i<len; i++) 
	{
		Entity ent = ssAll[i];
		if (ent.Is(_T("ARC")))
		{
			arc_set += ent;
		}
	}
	
	len = arc_set.Length();
	for (i = 0; i<len; i++) 
	{
		arc1 = arc_set[i];
		if (arc1.In(&del_set))
		{
			continue;
		}
		
		AT_get_cirarcp(arc1, cen1, &rad1, &s_ang1, &e_ang1);
		if (rad1 < _DIST_SNAP && fabs(sin(s_ang1 - e_ang1)) < 0.01) 
		{ // zero radius or zero length
			del_set += arc1;
			continue;
		}
		
		ads_polar(cen1, s_ang1, rad1, a1_pt1);
		ads_polar(cen1, e_ang1, rad1, a1_pt2);
		
		for (j = 0; j < len; j++) 
		{
			arc2 = arc_set[j];
			if (arc1 == arc2) 
			{
				continue;
			}

			if (arc2.In(&del_set)) 
			{
				continue;
			}
			
			AT_get_cirarcp(arc2, cen2, &rad2, &s_ang2, &e_ang2);
			if ( ads_distance(cen1,cen2) <= _DIST_SNAP && fabs(rad1-rad2) < _DIST_SNAP) 
			{
				ads_polar(cen1, s_ang2, rad1, a2_pt1);
				ads_polar(cen1, e_ang2, rad1, a2_pt2);
				
				if (AT_in_arc(a2_pt1, cen1, rad1, s_ang1, e_ang1))
				{  /* start point on within arc1*/
					ads_ssadd(arc2,del_set,del_set);
					if (!AT_in_arc(a2_pt2,cen1,rad1,s_ang1,e_ang1))
					{  /*endpoint on extension arc1 */
						AT_mod_arcp(arc1, 51, a2_pt2);
					}
					// else end point also on within arc1, only del arc2 is enough
				}
				
				else if (AT_in_arc(a2_pt2,cen1,rad1,s_ang1,e_ang1))
				{//endpoint on within arc1
					ads_ssadd(arc2,del_set,del_set);
					if (!AT_in_arc(a2_pt1,cen1,rad1,s_ang1,e_ang1)) 
					{// start point on extension arc1
						AT_mod_arcp(arc1, 50, a2_pt1);
					}
					// else start point also on within arc1, only del arc2 is enough
				}
				
				else if (AT_in_arc(a1_pt1,cen2,rad2,s_ang2,e_ang2) &&   // whole arc1
					AT_in_arc(a1_pt2,cen2,rad2,s_ang2,e_ang2) )  
				{ // is within arc2
					ads_ssadd(arc2, del_set, del_set);         // then change arc1 to
					AT_mod_arcp(arc1, 50, a2_pt1);               // arc2, and del arc2
					AT_mod_arcp(arc1, 51, a2_pt2);
				}
			}
		} 
	} 
	
	
	ssAll -= del_set;
	del_set.Erase();
	return RTNORM;
}

static void acadrgb(int hsv, struct r_g_b *rgp)
{
    static double brightfac[5] = { 1.0, 0.65, 0.5, 0.3, 0.15 };	/* Brightness levels */
	static double halfsat = .5;									/* Halfway saturation */
    int ih, vs;
    double h, s, f, value;

    // assert(hsv > 0 || hsv < 256);

    switch (hsv) 
	{
    case 0:
        rgp->red   = 0.0;
        rgp->blue  = 0.0;
        rgp->green = 0.0;
        value = 0.0;
        break;

    case 1:
        rgp->red   = 1.0;
        rgp->green = 0.0;
        rgp->blue  = 0.0;
        value = 1.0;
        break;

    case 2:
        rgp->red   = 1.0;
        rgp->green = 1.0;
        rgp->blue  = 0.0;
        value = 1.0;
        break;

    case 3:
        rgp->red   = 0.0;
        rgp->green = 1.0;
        rgp->blue  = 0.0;
        value = 1.0;
        break;

    case 4:
        rgp->red   = 0.0;
        rgp->green = 1.0;
        rgp->blue  = 1.0;
        value = 1.0;
        break;

    case 5:
        rgp->red   = 0.0;
        rgp->green = 0.0;
        rgp->blue  = 1.0;
        value = 1.0;
        break;

    case 6:
        rgp->red   = 1.0;
        rgp->green = 0.0;
        rgp->blue  = 1.0;
        value = 1.0;
        break;

    case 7:
    case 8:
    case 9:
        rgp->red   = 1.0;
        rgp->green = 1.0;
        rgp->blue  = 1.0;
        value = 1.0;
        break;

    default:
       if (hsv > 9 && hsv < 250) 
	   {
            /* Apply the algorithm from Foley & van Dam to turn HSV into RGB values */
            ih = (hsv - 10) / 10;		/* Integer hue value. */
            if (ih >= 24)				/* Range is 0-23. */
			{
                ih -= 24;
			}
            vs = hsv % 10;				/* Encoded value and saturation */
            h = ih / 4.;				/* Map into range [0.0,6.0) */
            ih = (int)h;				/* The integer part. */
            f = h - ih;					/* Fractional part. */
            value = brightfac[vs >> 1]; /* Value in [0,1] */
            s = vs & 1 ? halfsat : 1.0; /* Saturation */

            switch (ih) 
			{
            case 0:
                rgp->red   = 1.0;
                rgp->green = (double) (1.0 - s * (1.0 - f));
                rgp->blue  = (double) (1.0 - s);
                break;

            case 1:
                rgp->red   = (double) (1.0 - s * f);
                rgp->green = 1.0;
                rgp->blue  = (double) (1 - s);
                break;

            case 2:
                rgp->red   = (double) (1.0 - s);
                rgp->green = 1.0;
                rgp->blue  = (double) (1.0 - s *(1.0 - f));
                break;

            case 3:
                rgp->red   = (double) (1.0 - s);
                rgp->green = (double) (1.0 - s * f);
                rgp->blue  = 1.0;
                break;

            case 4:
                rgp->red   = (double) (1.0 - s * (1.0 - f));
                rgp->green = (double) (1.0 - s);
                rgp->blue  = 1.0;
                break;

            case 5:
                rgp->red   = 1.0;
                rgp->green = (double) (1.0 - s);
                rgp->blue  = (double) (1.0 - s * f);
                break;
            }
        } 
	   else 
	   {
            /* Define some extra colours from dark grey to white in the 250 to 255 slots */
            value = 0.33 + (hsv - 250) * 0.134;
            rgp->red   = 1.0;
            rgp->green = 1.0;
            rgp->blue  = 1.0;
        }
        break;                        /* Default */
    }
    rgp->red   *= value;              /* Apply lightness scale factor */
    rgp->green *= value;              /* to components resulting from */
    rgp->blue  *= value;              /* hue and saturation. */
}

static int dragsampler(ads_point pt0, ads_matrix mat)
{
	double        D;
	double        angle;
	ads_point       pt, tp;
	int             axis;
	
	// Move操作时,没有基点,正交不起作用
	//使得正交(Ortho)和捕捉(SNAP)起作用
	CapturePoint(g_nDragFlag ? NULL:Base, pt0, pt); 
	switch(KwIndex) 
	{
	case MXYZ:
		/* generate translation matrix */
		ads_subvec(pt, Base, tp);
		ads_mat_x_vec(mat, tp, tp);
		mat[X][T] = tp[X];
		mat[Y][T] = tp[Y];
		mat[Z][T] = tp[Z];
		break;
	case SXYZ:
		/* generate uniformly scaled matrix */
		D = ads_dist(pt, Base)/scr_h*10;  // SCALE = DIST / (SCR_H/10)
		if (D < .0001)
		{
			D = .0001;
		}
		ads_mat_scale(D,D, D, mat);
		
		/* calculate new translation point */
		ads_mat_x_vec(mat, Base, tp);
		ads_subvec(Base, tp, tp);
		mat[X][T] = tp[X];
		mat[Y][T] = tp[Y];
		mat[Z][T] = tp[Z];
		break;
		
	case RX:
	case RY:
	case RZ:
		switch (KwIndex) 
		{
		case RX:
			axis = X;
			break;
		case RY:
			axis = Y;
			break;
		case RZ:
			axis = Z;
			break;
		}
		/* calculate angle of line between LastPoint and tp */
		ads_subvec(pt, Base, tp);
		angle = ads_angle(Base, pt);
		
		/* generate rotation matrix about axis */
		ads_mat_rot(angle, axis, mat);
		
		/* calculate new translation point */
		ads_mat_x_vec(mat, Base, tp);
		ads_subvec(Base, tp, tp);
		mat[X][T] = tp[X];
		mat[Y][T] = tp[Y];
		mat[Z][T] = tp[Z];
		
		break;
		case EXIT:
			return RTCAN;
		case NOP:
		default:
			return RTNONE;
	}
	
	memcpy(CTM, mat, sizeof(ads_matrix));
	return RTNORM;
}

static int MoveSampler(ads_point pt0, ads_matrix mat)
{
	// Move操作时,没有基点,正交不起作用
	XPoint pt;
	pt = Ucs2Wcs(pt);
	CapturePoint(NULL, pt0, pt); //使得正交(Ortho)和捕捉(SNAP)起作用
	pt = Ucs2Wcs(pt);
	Ucs2Wcs(g_ptBase).GetMoveMatrix(pt, mat);
	return RTNORM;
}

static int DragRotateCallBack(ads_point pt0, ads_matrix mat)
{
	// Move操作时,没有基点,正交不起作用
	XPoint pt;
	CapturePoint(&g_ptBase.x, pt0, pt); //使得正交(Ortho)和捕捉(SNAP)起作用
	pt = Ucs2Wcs(pt);
	Ucs2Wcs(g_ptBase).GetRotationMatrix(ads_angle(Ucs2Wcs(g_ptBase), pt), mat);
	return RTNORM;
}


/*static int CompareAcRxClass(const AcRxClass *p1, const void *p2)
{
	const AcRxClass *pp2 = (const AcRxClass *)p2;
	if (p1 == pp2)
	{
		return 0;
	}
	return 1;
}
*/

int XExport::MoveSamplerStatic(ads_point pt0, ads_matrix mat)
{
	return MoveSampler(pt0, mat);
}

AcDbObjectId XExport::AddToModelSpace(AcDbEntity *pEntity, Adesk::Boolean bDoneClose ,Adesk::Boolean bWorkset)
{
	AcDbObjectId idEnt;
	AcDbDatabase* pDb = acdbCurDwg();
	if (pDb != NULL)
	{
		AcDbBlockTable* pTable = NULL;
		if (Acad::eOk == pDb->getBlockTable(pTable,AcDb::kForRead))
		{
			AcDbBlockTableRecord* pRecord = NULL;
			if (Acad::eOk == pTable->getAt(ACDB_MODEL_SPACE,pRecord,AcDb::kForWrite))
			{
				pRecord->appendAcDbEntity(idEnt,pEntity);
				if (bDoneClose) 
				{
					pEntity->close();
				}
				pRecord->close();
			}
			pTable->close();
		}
	}

	// add by zjq on 100824 考虑工作集
	if (bWorkset)
	{
		//get current work set
		AcApDocument *pCurDoc = curDoc();
		if (pCurDoc != NULL)
		{
			AcDbObjectId idLT = acapLongTransactionManagerPtr()->currentLongTransactionFor (pCurDoc);
			AcDbLongTransaction *pLT = NULL;
			acdbOpenObject(pLT,idLT,AcDb::kForWrite);
			if (pLT != NULL)
			{
				pLT->addToWorkSet(idEnt);
				pLT->close();
			}
		}
	}

	return idEnt;
}

AcDbObjectId XExport::AddToPaperSpace(AcDbEntity *pEntity, Adesk::Boolean bDoneClose ,Adesk::Boolean bWorkset)
{
	XBlockTableRecPtr mspace(ACDB_PAPER_SPACE, AcDb::kForWrite);
	if (!mspace) 
	{
		return AcDbObjectId::kNull;
	}

	AcDbBlockTableRecord &rec = mspace;
	rec.appendAcDbEntity(pEntity);
	if (bDoneClose)
	{
		pEntity->close();
	}
	
	// modify by zjq on 100824 考虑工作集
	//return pEntity->objectId();
	AcDbObjectId idEnt = pEntity->objectId();
	if (bWorkset)
	{
		//get current work set
		AcApDocument *pCurDoc = curDoc();
		if (pCurDoc != NULL)
		{
			AcDbObjectId idLT = acapLongTransactionManagerPtr()->currentLongTransactionFor (pCurDoc);
			AcDbLongTransaction *pLT = NULL;
			acdbOpenObject(pLT,idLT,AcDb::kForWrite);
			if (pLT != NULL)
			{
				pLT->addToWorkSet(idEnt);
				pLT->close();
			}
		}
	}
	return idEnt;
}


AcDbObjectId XExport::AddToCurrentSpace(AcDbEntity *pEntity, Adesk::Boolean bDoneClose ,Adesk::Boolean bWorkset)
{
	int cvport = 0;
	int tilemode;
	xg_getvar(_T("TILEMODE"), &tilemode);
	xg_getvar(_T("CVPORT"), &cvport);

	// modify by zjq on 100824 考虑工作集
	//return ((tilemode == 0 && cvport == 1) ? XExport::AddToPaperSpace(pEntity, bDoneClose) : XExport::AddToModelSpace(pEntity, bDoneClose));
	return ((tilemode == 0 && cvport == 1) ? XExport::AddToPaperSpace(pEntity, bDoneClose, bWorkset) : XExport::AddToModelSpace(pEntity, bDoneClose,bWorkset));
}

#if (ARX>15)
bool XExport::FindRT_MANIFEST()
{
	HMODULE hExe = AfxGetInstanceHandle(); 
	if (hExe == NULL) 
	{
		return false;
	}
	
	HRSRC hRes = FindResource(hExe,MAKEINTRESOURCE(1),RT_MANIFEST); 
	if (hRes == NULL)
	{
		return false;
	}
	return true;
}
#endif


BOOL XExport::GetBlcCtrlPoint(AcDbObjectId id, XPoint &ptMax)
{
	AcDbBlockTableRecord *pBlockTableRecord = NULL;
	if (acdbOpenObject(pBlockTableRecord, id, AcDb::kForRead) != Acad::eOk)
	{
		return FALSE;
	}
	
	AcDbBlockTableRecordIterator *pIter = NULL;
	pBlockTableRecord->newIterator(pIter);
	pBlockTableRecord->close();
	
	AcGePoint3dArray points;
	for (pIter->start(); !pIter->done(); pIter->step())
	{
		AcDbEntity *pEnt = NULL;
		if (pIter->getEntity(pEnt, AcDb::kForRead) != Acad::eOk)
		{
			continue;
		}
		
		
		if (pEnt->isKindOf(AcDbPoint::desc()))
		{
			TCHAR *layer = pEnt->layer();
			{
				AcGePoint3d pt = ((AcDbPoint*)pEnt)->position();
				points.append(pt);
			}
			delete []layer;
		}
		pEnt->close();
	}
	delete pIter;
	
	int numPt = points.length();
	if (numPt == 1)
	{
		ptMax = points[0];
	}
	else if (numPt == 2)
	{
		ptMax = points[0];
		if (points[0].x < points[1].x)
		{
			ptMax = points[1];
		}
	}
	else
	{
		AcDbExtents ext;
		AcDbBlockReference block;
		block.setBlockTableRecord(id);
		block.getGeomExtents(ext);
		ptMax  = ext.maxPoint();
	}
	
	return TRUE;
}

int XExport::ConvertDwgCodePage(const TCHAR *tmpFile)
{
#if (ARX<16)
	XPathParser parser(tmpFile);
	BOOL bDwg = (_tcsicmp(parser.m_sExt, _T(".DWG")) == 0);
	BOOL bDxf = (_tcsicmp(parser.m_sExt, _T(".DXF")) == 0);
	if (!bDwg && !bDxf)
	{
		return RTERROR;
	}

	int nRet = RTNONE;
	AcDbDwgVersion dwgVer = bDwg ? getDwgVersion(tmpFile) : getDxfVersion(tmpFile);
	if (dwgVer != kDHL_Unknown && dwgVer >= kDHL_1009 && dwgVer <= kDHL_1014) 
	{
		CString cpName;
		XString sSysCodePage;
		if (xg_getvar(_T("SYSCODEPAGE"), sSysCodePage) == RTNORM) 
		{
			CString csTmpFile = tmpFile, csSysCodePage = sSysCodePage;
			BOOL bRet = bDwg ? getDwgCodePage(csTmpFile, cpName) : getDxfCodePage(csTmpFile, cpName);
			if (!bRet)
			{
				return RTERROR;
			}
			if (_tcsicmp(cpName, csSysCodePage) != 0) 
			{
				if (bDwg)
				{
					setDwgCodePage(csTmpFile, csSysCodePage);
				}
				else
				{
					setDxfCodePage(csTmpFile, csSysCodePage);
				}
				return RTNORM;
			}
		}
	} 
	else if (dwgVer == kDHL_Unknown && bDwg) 
	{
		XString sSysCodePage;
		VERIFY(xg_getvar(_T("SYSCODEPAGE"), sSysCodePage) == RTNORM);
		if (sSysCodePage == _T("ANSI_936")) 
		{
			FILE *fp = _tfopen(tmpFile, _T("r+b"));
			if (fp) 
			{
				TCHAR szBuf[21];
				if (fread(szBuf, 1, 21, fp) == 21) 
				{
					TCHAR *pTo = szBuf;
					pTo += 7;
					TCHAR szHead[7];
					StrCpy(szHead, szBuf, pTo);
					szHead[7] = EOS;
					if (strcmp(szHead, _T("AC1015")) == 0 && szBuf[19] != 0x27) 
					{
						szBuf[19] = 0x27;
						fseek( fp, 0L, SEEK_SET );
						fwrite(szBuf, 1, 21, fp);
						nRet = RTNORM;
					}
				}
				fclose(fp);
			}
		}
	}
	return nRet;
#else
	return RTNONE;
#endif
}

/* * * 定 义 对 给 定 的 目 标 点 进 行 正 交 和 咬 住 捕 捉 的 函 数 * * */
// ptBase(IN) -- 参考基点
// ptDest(IN) -- 目标点
// ptCapture(OUT) -- 对ptDest进行捕捉修正后的点
void XExport::CapturePoint(const ads_point ptBase, const ads_point ptDest, ads_point ptCapture)
{
	double nSnapAngle = 0.0;
	int nOthoMode = 0, nSnapMode = 0, nSnapStyl = 0;
	XPoint ptSnapUnit, ptSnapBase;
	xg_getvar(_T("SNAPANG"), &nSnapAngle);
	xg_getvar(_T("ORTHOMODE"), &nOthoMode);
	xg_getvar(_T("SNAPSTYL"), &nSnapStyl);
	xg_getvar(_T("SNAPMODE"), &nSnapMode);
	xg_getvar(_T("SNAPUNIT"), &ptSnapUnit);
	xg_getvar(_T("SNAPBASE"), &ptSnapBase);
	
	XPoint ptResult = ptDest;
	if (nSnapStyl) 
	{
		ptResult > ptCapture;
		return;
	}
	
	XPoint ptDest1 = ptDest;

	if (nOthoMode && ptBase) 
	{ //正交方式打开
		XLine lnX(ptBase, nSnapAngle),
			  lnY(ptBase, XExport::CT_std_angle(nSnapAngle+PI/2.0));
		XPoint ptProjectX, ptProjectY;
		ptDest1.Project(&lnX, ptProjectX);
		ptDest1.Project(&lnY, ptProjectY);
		
		if (ads_distance(ptDest, ptProjectX) < ads_distance(ptDest, ptProjectY))
		{
			ptResult = ptProjectX;
		}
		else 
		{
			ptResult = ptProjectY;
		}
	}
	
	if (nSnapMode) 
	{ //咬住方式打开
		XLine lnX(ptSnapBase, nSnapAngle),
			  lnY(ptSnapBase, XExport::CT_std_angle(nSnapAngle + PI / 2.0));
		XPoint ptProjectX, ptProjectY;
		ptResult.Project(&lnX, ptProjectX);
		ptResult.Project(&lnY, ptProjectY);
		
		double nDistToSnapBaseX = ads_distance(ptSnapBase, ptProjectX),
			     nDistToSnapBaseY = ads_distance(ptSnapBase, ptProjectY);
		if (fabs(ptSnapUnit.x) > 1.0E-6) 
		{
			int nStepX = (int)(nDistToSnapBaseX / ptSnapUnit.x);
			double nLeftX = nDistToSnapBaseX - nStepX * ptSnapUnit.x;
			if (nLeftX > ptSnapUnit.x / 2.0)
			{
				nStepX += 1;
			}
			nDistToSnapBaseX = nStepX*ptSnapUnit.x;
		}
		
		if (fabs(ptSnapUnit.y) > 1.0E-6) 
		{
			int nStepY = (int)(nDistToSnapBaseY/ptSnapUnit.y);
			double nLeftY = nDistToSnapBaseY - nStepY * ptSnapUnit.y;
			if (nLeftY>ptSnapUnit.y/2.0) 
			{
				nStepY += 1;
			}
			nDistToSnapBaseY = nStepY*ptSnapUnit.y;
		}
        
		XPoint ptOnAxisX, ptOnAxisY;
		ads_polar(ptSnapBase, ads_angle(ptSnapBase, ptProjectX), nDistToSnapBaseX, ptOnAxisX);
		ads_polar(ptSnapBase, ads_angle(ptSnapBase, ptProjectY), nDistToSnapBaseY, ptOnAxisY);
		
		XLine lnYY(ptOnAxisX, nSnapAngle + PI / 2.0);
		XLine lnXX(ptOnAxisY, nSnapAngle);
	
		int nInters = lnXX.Intersection(&lnYY, ptResult);
		assert(nInters == 1);
	}
	ptResult.z = ptDest1.z;
	ptResult > ptCapture;
}


// ptBase--UCS
int XExport::DragMovePickSet(PickSet &ss, const TCHAR *pszPrompt, const XPoint &ptBase, XPoint &ptFinal)
{
    ptFinal = ptBase;
    g_ptBase = ptBase;
    ss.RedrawAll(2);

    int rc = ads_draggen(ss, pszPrompt, 0, MoveSampler, ptFinal);
    switch (rc) 
	{
    case RTNORM: 
		{
			ads_matrix mat;
			Ucs2Wcs(g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);
			if (ads_xformss(ss, mat) != RTNORM) 
			{
				  XPushVar<int> vOsMode(_T("OSMODE"), 0);
				  SHads_command(RTSTR, _T("MOVE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							  RT3DPOINT, &g_ptBase, RT3DPOINT, &ptFinal, RTNONE);
  			}
        }
        break;
    default:
        break;
    }
    ss.RedrawAll(1);
    return rc;
}

// ptBase--UCS
int XExport::DragMovePickSet(PickSet &ss, const TCHAR *pszPrompt, const XPoint &ptBase, XPoint &ptFinal,const TCHAR* sKeyword)
{
    ptFinal = ptBase;
    g_ptBase = ptBase;
    ss.RedrawAll(2);
	
	int rc;
	INITGET_BEG(0,sKeyword);
    rc = ads_draggen(ss, pszPrompt, 0, MoveSampler, ptFinal);
	INITGET_END();

    switch (rc) 
	{
    case RTNORM: 
		{
			ads_matrix mat;
			Ucs2Wcs(g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);
			if (ads_xformss(ss, mat) != RTNORM) 
			{
				  XPushVar<int> vOsMode(_T("OSMODE"), 0);
				  SHads_command(RTSTR, _T("MOVE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							  RT3DPOINT, &g_ptBase, RT3DPOINT, &ptFinal, RTNONE);
			}
        }
        break;
    default:
        break;
    }
    ss.RedrawAll(1);
    return rc;
}

int XExport::DragRotatePickSet(PickSet &ss, const TCHAR *pszPrompt, XPoint ptBase)
{
    g_ptBase = ptBase;
    XPoint ptFinal;
	ss.RedrawAll(2);
    ads_initget(RSG_OTHER, NULL);
    int rc = ads_draggen(ss, pszPrompt, 0, DragRotateCallBack, ptFinal);
    switch (rc) 
	{
    case RTNORM: 
		{
			XExport::CapturePoint(g_ptBase, XPoint(ptFinal), ptFinal);

			ads_matrix mat;
			Ucs2Wcs(g_ptBase).GetRotationMatrix(ads_angle(Ucs2Wcs(g_ptBase), Ucs2Wcs(ptFinal)), mat);
			VERIFY(ads_xformss(ss, mat) == RTNORM);
        }
        break;
    case RTSTR: 
		{
			XString tstr;
			double res;
			ads_getinput(tstr);
			if (ads_distof(tstr, 2, &res) != RTNORM) 
			{
				rc = RTERROR;
			} 
			else 
			{
				SHads_command(RTSTR, _T("ROTATE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &g_ptBase, RTREAL, res, RTNONE);
				rc = RTNORM;
			}
        }
        break;
    default:
        break;
    }
    return rc;
}

int XExport::DragPickSet(PickSet &ss, XPoint &ptBase)
{
    int rc;
    TCHAR draggenprompt[512] = _T("");
    const TCHAR *szPrompt = _T("\n点取位置或 [转90度(A)/左右翻(S)/上下翻(D)/对齐(F)/改转角(R)/改基点(T)]<退出>:");
    int cur = 0;
    XPoint ptFinal;
    cur = 0;
    g_ptBase = ptBase;
    XGeLib::adsout << szPrompt;
LAB_DRAG:    
    ss.Redraw(2);
    INITGET_BEG(RSG_OTHER, _T("A S D F R T"));
    rc = ads_draggen(ss,draggenprompt, cur, MoveSampler, ptFinal);
    INITGET_END();
    if (rc == RTKWORD) 
	{
        XPoint g_ptNewBase = GetCursorWcs();
        XString sKeyChar;
        VERIFY(ads_getinput(sKeyChar) == RTNORM);
        double nScale = 1.0;
        XPoint vtMove = g_ptNewBase-Ucs2Wcs(g_ptBase);
        ads_matrix mat = {	{1.0, 0.0, 0.0, vtMove.x},
							{0.0, 1.0, 0.0, vtMove.y},
							{0.0, 0.0, 1.0, vtMove.z},
							{0.0, 0.0, 0.0, 1.0}};
        VERIFY(ads_xformss(ss, mat) == RTNORM);
        
        ads_printf(_T("%c%c %c"), 8,8,8);
        g_ptBase = Wcs2Ucs(g_ptNewBase);
        if (sKeyChar[0] == _T('A') || sKeyChar[0] == _T('S') || sKeyChar[0] == _T('D')) 
		{
            XPushVar<int> nMode(_T("OSMODE"), 0);
            if (sKeyChar[0] == _T('S')) 
			{
                XPoint ptOther = g_ptBase+XPoint(0,100,0);
                SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
					        RT3DPOINT, &g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
            }
			else if (sKeyChar[0] == _T('D')) 
			{
                XPoint ptOther = g_ptBase+XPoint(100,0,0);
                SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
                
            }
			else if (sKeyChar[0] == _T('A')) 
			{
                SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
					        RT3DPOINT, &g_ptBase, RTREAL, 90.0, RTNONE);
            
            }
            rc = RTNORM;
        } 
		else if (sKeyChar[0] == _T('F')) 
		{
            int nOsMode = 0;
            xg_getvar(_T("OSMODE"), &nOsMode);
            nOsMode &= ~0x4000;
            nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
            XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
            XPoint pt1 = g_ptBase, pt2, qt1, qt2;
            if (ads_getpoint(NULL, _T("\n对齐参考点："), pt1) == RTNORM &&
                ads_getpoint(pt1,  _T("\n对齐参考轴："), pt2) == RTNORM &&
                ads_getpoint(NULL, _T("\n对齐目标点："), qt1) == RTNORM &&
                ads_getpoint(qt1,  _T("\n对齐目标轴："), qt2) == RTNORM) 
			{
                XPushVar<int> osmode(_T("OSMODE"), 0);
                double nRot = XExport::CT_std_angle(ads_angle(qt1, qt2)-ads_angle(pt1, pt2));
                SHads_command(RTSTR, _T(".MOVE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
					        RT3DPOINT, &pt1, RT3DPOINT, &qt1, RTNONE);
                SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &qt1, RTREAL, nRot*180/PI, RTNONE);
                rc = RTNORM;
                return rc;
            }
            rc = RTNORM;
        } 
		else if (sKeyChar[0] == _T('R')) 
		{
            double nRot = 0.0;
            XGeLib::adsout << _T("\n旋转角度: ");
            rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss,
						     RTSTR, _T(""), RT3DPOINT, &g_ptBase, RTSTR, _T("\\"), RTNONE);
            if (rc == RTNORM)
			{
                XGeLib::adsout << szPrompt;
			}
        }  
		else if (sKeyChar[0] == _T('T')) 
		{
            int nOsMode = 0;
            xg_getvar(_T("OSMODE"), &nOsMode);
            nOsMode &= ~0x4000;
            nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
            XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
            rc = XGetPoint(NULL, _T("\n输入插入点"), g_ptBase);
            if (rc == RTNORM) 
			{
                XGeLib::adsout << szPrompt;
                ptBase = g_ptBase;
            }
        }
        if (rc == RTNORM)
		{
            goto LAB_DRAG;
		}
    }
    ptBase = g_ptBase;

    switch (rc) 
	{
    case RTNORM: 
		{
			ptFinal = Ucs2Wcs(ptFinal);
			XPoint vtMove = ptFinal-Ucs2Wcs(g_ptBase);
			ads_matrix mat = {	{1.0, 0.0, 0.0, vtMove.x},
								{0.0, 1.0, 0.0, vtMove.y},
								{0.0, 0.0, 1.0, vtMove.z},
								{0.0, 0.0, 0.0, 1.0}};
        
			VERIFY(ads_xformss(ss, mat) == RTNORM);
			XPoint pt0 = Ucs2Wcs(ptBase);
			ptBase = pt0.TransformAs(mat);
			ptBase = Wcs2Ucs(ptBase);
        }
        break;
    case RTCAN:
    case RTNONE: 
    case RTERROR:
        break;
    }
    ss.Redraw(1);

	 return rc;
}

int XExport::DragPickSet1(PickSet &ss, XPoint &ptBase)
{
    int         rc;
    TCHAR        draggenprompt[512] = _T("");
    const TCHAR *szPrompt = _T("\n点取位置或 [转90度(A)/左右翻(S)/上下翻(D)/对齐(F)/改转角(R)/改基点(T)]<退出>:");
    int         cur = 0;
    XPoint ptFinal;
	XAdvanceSampler::Init(ptBase, 1);
    XGeLib::adsout << szPrompt;

LAB_DRAG:    
    ss.Redraw(2);
    INITGET_BEG(RSG_OTHER, _T("A S D F R T"));
    rc = ads_draggen(ss,draggenprompt,cur,XAdvanceSampler::MoveSampler,ptFinal);
    INITGET_END();
	XScreenDc dc(-1);
	dc << XLine(XAdvanceSampler::g_ptBase, XAdvanceSampler::g_ptLastTemp);

    if (rc == RTKWORD) 
	{
        XString sKeyChar;
        VERIFY(ads_getinput(sKeyChar) == RTNORM);
        ads_printf(_T("%c%c %c"), 8,8,8);

        if (sKeyChar[0] == _T('A') || sKeyChar[0] == _T('S') || sKeyChar[0] == _T('D')) 
		{
            XPushVar<int> nMode(_T("OSMODE"), 0);
            if (sKeyChar[0] == _T('S')) 
			{
                XPoint ptOther = XAdvanceSampler::g_ptBase+XPoint(0,100,0);
                SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &XAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
            }
			else if (sKeyChar[0] == _T('D')) 
			{
                XPoint ptOther = XAdvanceSampler::g_ptBase+XPoint(100,0,0);
                SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &XAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
            } 
			else if (sKeyChar[0] == _T('A')) 
			{
                SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &XAdvanceSampler::g_ptBase, RTREAL, 90.0, RTNONE);
            }
            rc = RTNORM;
        }
		else if (sKeyChar[0] == _T('F')) 
		{
            int nOsMode = 0;
            xg_getvar(_T("OSMODE"), &nOsMode);
            nOsMode &= ~0x4000;
            nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
            XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
            XPoint pt1 = XAdvanceSampler::g_ptBase, pt2, qt1, qt2;
            if (ads_getpoint(NULL, _T("\n对齐参考点："), pt1) == RTNORM &&
                ads_getpoint(pt1,  _T("\n对齐参考轴："), pt2) == RTNORM &&
                ads_getpoint(NULL, _T("\n对齐目标点："), qt1) == RTNORM &&
                ads_getpoint(qt1,  _T("\n对齐目标轴："), qt2) == RTNORM) 
			{
                XPushVar<int> osmode(_T("OSMODE"), 0);
                double nRot = XExport::CT_std_angle(ads_angle(qt1, qt2)-ads_angle(pt1, pt2));
                SHads_command(RTSTR, _T(".MOVE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
					        RT3DPOINT, &pt1, RT3DPOINT, &qt1, RTNONE);
                SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss, RTSTR, _T(""),
							RT3DPOINT, &qt1, RTREAL, nRot*180/PI, RTNONE);
                rc = RTNORM;
                return rc;
            }
            rc = RTNORM;
        } 
		else if (sKeyChar[0] == _T('R')) 
		{
            double nRot = 0.0;
            XGeLib::adsout << _T("\n旋转角度: ");
            rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (LONG_PTR *)ss,
						     RTSTR, _T(""), RT3DPOINT, &XAdvanceSampler::g_ptBase, RTSTR, _T("\\"), RTNONE); //ss.Rotate(g_ptBase, &nRot);
            if (rc == RTNORM)
			{
                XGeLib::adsout << szPrompt;
			}
        }  
		else if (sKeyChar[0] == _T('T')) 
		{
			ss.Redraw(1);

            int nOsMode = 0;
            xg_getvar(_T("OSMODE"), &nOsMode);
            nOsMode &= ~0x4000;
            nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
            XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
            rc = XGetPoint(NULL, _T("\n输入插入点"), XAdvanceSampler::g_ptBase);
            if (rc == RTNORM) 
			{
                XGeLib::adsout << szPrompt;
                ptBase = XAdvanceSampler::g_ptBase;
            }
        }
        if (rc == RTNORM) 
		{
			XAdvanceSampler::g_ptLastTemp = XAdvanceSampler::g_ptBase;
            goto LAB_DRAG;
		}
    }
    ptBase = XAdvanceSampler::g_ptBase;

    switch (rc) 
	{
	case RTSTR:
    case RTNORM: 
		{
			if (rc == RTSTR) 
			{
				XString str;
				ads_getinput(str);
				ads_polar(XAdvanceSampler::g_ptBase, XAdvanceSampler::g_nDirection, _tstof(str), ptFinal);
			}
			else 
			{
				XExport::CapturePoint(XAdvanceSampler::g_ptBase, XPoint(ptFinal), ptFinal);
			}
			ptFinal = Ucs2Wcs(ptFinal);
			XPoint vtMove = ptFinal-Ucs2Wcs(XAdvanceSampler::g_ptBase);
			ads_matrix mat = {	{1.0, 0.0, 0.0, vtMove.x},
								{0.0, 1.0, 0.0, vtMove.y},
								{0.0, 0.0, 1.0, vtMove.z},
								{0.0, 0.0, 0.0, 1.0}};
        
			VERIFY(ads_xformss(ss, mat) == RTNORM);
			XPoint pt0 = Ucs2Wcs(ptBase);
			ptBase = pt0.TransformAs(mat);
			ptBase = Wcs2Ucs(ptBase);
			rc = RTNORM;
        }
        break;
    case RTCAN:
    case RTNONE: 
    case RTERROR:
        break;
    }
    ss.Redraw(1);
    return rc;
}

int XExport::AT_scale(ads_name ssname, ads_point bpt, double *res)
{
	int         rc, ret_tag;
	long        i;
	Adesk::Int32 slen;
	TCHAR       tstr[512];
	TCHAR       draggenprompt[512];
	int         cur;
	ads_point   tp, p3;
	struct resbuf viewsize;
	ads_name ett;
	
	ads_mat_ident(CTM);
	cur = 0;
	ads_getvar(_T("VIEWSIZE"), &viewsize);
	scr_h = viewsize.resval.rreal;
	KwIndex = SXYZ; //NOP;
	rc = ads_sslength(ssname, &slen);
	if (rc != RTNORM || slen == 0L) 
	{
		return RTERROR;
	}
	for (i = 0; i<slen; i++)
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 2);
	}
	
	Base[0] = bpt[0]; Base[1] = bpt[1]; Base[2] = bpt[2];
	_tcscpy(draggenprompt, sMsgPrompt[1]);
	ads_initget(RSG_OTHER, NULL);
	rc = ads_draggen(ssname,draggenprompt,cur,dragsampler,p3);
	for (i = 0; i < slen; i++) 
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 1);
	}
	
	switch (rc) 
	{
	case RTNORM:
		{
			ret_tag = rc;
			*res = ads_distance(bpt, p3)/scr_h*10.0;
			if (ads_xformss(ssname, CTM) != RTNORM) 
			{
				XPushVar<int> vOsMode(_T("OSMODE"), 0);
				SHads_command(RTSTR, _T("SCALE"), RTPICKS, ssname,
							RTSTR, _T(""), RT3DPOINT, bpt, RTREAL, (*res), RTNONE);
			}
		}
		break;
	case RTCAN:
		ret_tag = RTCAN;
		break;
	case RTNONE: 
		*res = 1.0;
		ret_tag = RTNORM;
		break;
	case RTSTR:
		{
			ads_getinput(tstr);
			if (ads_distof(tstr, 2, res) != RTNORM) 
			{
				ads_printf(sMsgPrompt[2]);
				ret_tag = XExport::AT_scale(ssname, bpt, res);
			}
			else 
			{
				ads_mat_ident(CTM);
				ads_mat_scale(*res, *res, *res, CTM);
				ads_mat_x_vec(CTM, bpt, tp);
				ads_subvec(bpt, tp, tp);
				CTM[X][T] = tp[X];
				CTM[Y][T] = tp[Y];
				CTM[Z][T] = tp[Z];
				if (ads_xformss(ssname, CTM) != RTNORM)
				{
					XPushVar<int> vOsMode(_T("OSMODE"), 0);
					SHads_command(RTSTR, _T("SCALE"), RTPICKS, ssname,
								RTSTR, _T(""), RT3DPOINT, bpt, RTREAL, (*res), RTNONE);
				}
				ret_tag = RTNORM;
			}
		}
		break;
	case RTERROR:
	default:
		ads_printf(_T("\nDrag operation failed\n"));
		ret_tag = RTERROR;
		break;
	}
	return ret_tag;
}

int XExport::AT_rotate(ads_name ssname, ads_point bpt, double *res)
{
	int         rc, ret_tag;
	long        i;
	Adesk::Int32 slen;
	TCHAR       tstr[512];
	TCHAR       draggenprompt[512];
	int         cur;
	ads_point   tp, p3;
	ads_name    ett;
	
	ads_mat_ident(CTM);
	cur = 0;
	
	KwIndex = RZ; 
	rc = ads_sslength(ssname, &slen);
	if (rc != RTNORM || slen == 0L)
	{
		return RTERROR;
	}
	for (i = 0; i<slen; i++)
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 2);
	}
	
	Base[0] = bpt[0]; Base[1] = bpt[1]; Base[2] = bpt[2];
	_tcscpy(draggenprompt, sMsgPrompt[3]);
	ads_initget(RSG_OTHER, NULL);
	rc = ads_draggen(ssname,draggenprompt,cur,dragsampler,p3);
	for (i = 0; i<slen; i++) 
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 1);
	}
	
	switch (rc)
	{
	case RTNORM:
		ret_tag = rc;
		*res = ads_angle(bpt, p3)*180.0/3.1415926897932;
		if (ads_xformss(ssname, CTM) != RTNORM)
		{
			XPushVar<int> vOsMode(_T("OSMODE"), 0);
			SHads_command(RTSTR, _T("ROTATE"), RTPICKS, ssname, RTSTR, _T(""),
						RT3DPOINT, bpt, RTREAL, *res, RTNONE);
		}
		break;
	case RTCAN:
		ret_tag = RTCAN;
		break;
	case RTNONE: 
		*res = 0.0;
		ret_tag = RTNORM;
		break;
	case RTSTR:
		ads_getinput(tstr);
		if (ads_distof(tstr, 2, res) != RTNORM) 
		{
			ads_printf(sMsgPrompt[2]); // Invalid input
			ret_tag = XExport::AT_rotate(ssname, bpt, res);
		}
		else
		{
			ads_mat_ident(CTM);
			ads_mat_rot((*res)*3.14159/180.0, Z, CTM);
			ads_mat_x_vec(CTM, bpt, tp);
			ads_subvec(bpt, tp, tp);
			CTM[X][T] = tp[X];
			CTM[Y][T] = tp[Y];
			CTM[Z][T] = tp[Z];
			if (ads_xformss(ssname, CTM) != RTNORM)
			{
				SHads_command(RTSTR, _T("ROTATE"), RTPICKS, ssname, RTSTR, _T(""),
							RT3DPOINT, bpt, RTREAL, *res, RTNONE);
			}
			ret_tag = RTNORM;
		}
		break;
		
	case RTERROR:
	default:
		ads_printf(/*MSG20*/_T("\nDrag operation failed\n"));
		ret_tag = RTERROR;
		break;
	}
	return ret_tag;
}

int XExport::AT_move(ads_name ssname, ads_point bpt, ads_point res)
{
	int         rc, ret_tag;
	Adesk::Int32 slen;
	long i;
	TCHAR        draggenprompt[512];
	int         cur, nOldFlag;
	ads_name    ett;
	
	ads_mat_ident(CTM);
	cur = 0;
	
	KwIndex = MXYZ; //NOP;
	rc = ads_sslength(ssname, &slen);
	if (rc != RTNORM || slen == 0L) 
	{
		return RTERROR;
	}
	for (i = 0; i<slen; i++) 
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 2);
	}
	
	Base[0] = bpt[0];
	Base[1] = bpt[1];
	Base[2] = bpt[2];
	_tcscpy(draggenprompt, sMsgPrompt[0]);
	nOldFlag = g_nDragFlag;
	g_nDragFlag = 1; //Move
	ads_initget(0, NULL);
	rc = ads_draggen(ssname,draggenprompt,cur,dragsampler,res);
	g_nDragFlag = nOldFlag;
	for (i = 0; i<slen; i++) 
	{
		ads_ssname(ssname, i, ett);
		ads_redraw(ett, 1);
	}
	
	switch (rc) 
	{
	case RTNORM:
		if (ads_xformss(ssname, CTM) != RTNORM) 
		{
			XPushVar<int> vOsMode(_T("OSMODE"), 0);
			SHads_command(RTSTR, _T("MOVE"), RTPICKS, ssname, RTSTR, _T(""),
				RT3DPOINT, bpt, RT3DPOINT, res, RTNONE);
		}
		ret_tag = rc;
		break;
	case RTCAN:
		ret_tag = RTCAN;
		break;
	case RTNONE: 
		ret_tag = RTNONE;
		break;
	case RTERROR:
	default:
		ads_printf(_T("\nDrag operation failed\n"));
		ret_tag = RTERROR;
		break;
	}
	return ret_tag;
}

void XExport::arxZoomCursor(XPoint ptDcs, double nScale)
{
	int viewmode;
	VERIFY(xg_getvar(_T("VIEWMODE"), &viewmode) == RTNORM);
	
	double nWidth, nHeight;
	AT_ScrSize(&nWidth, &nHeight);
	nWidth *= nScale;
	nHeight *= nScale;
	Groups g1(1), g0(0);
	if (!viewmode) 
	{
		AcDbViewTableRecord view;
		XPoint vtViewDir;
		view.setCenterPoint(ptDcs.AsAcGePoint2d());
		view.setHeight( nHeight);
		view.setWidth( nWidth ); 
		VERIFY(xg_getvar(_T("VIEWDIR"), &vtViewDir) == RTNORM);
		ads_trans(XPoint(vtViewDir), (resbuf *)&g1, (resbuf *)&g0, 1, vtViewDir);
		view.setViewDirection(vtViewDir);
		
		double viewtwist = 0.0;
		VERIFY(xg_getvar(_T("VIEWTWIST"), &viewtwist) == RTNORM);
		view.setViewTwist(viewtwist);
		
		XPoint target;
		VERIFY(xg_getvar(_T("TARGET"), &target) == RTNORM);
		ads_trans(XPoint(target), (resbuf *)&g1, (resbuf *)&g0, 0, target);
		view.setTarget(target);
		
		int nCurVp;
		VERIFY(xg_getvar(_T("CVPORT"), &nCurVp) == RTNORM);
		view.setIsPaperspaceView(nCurVp == 1);
		Acad::ErrorStatus es = Acad::eOk;
		es = acdbSetCurrentView( &view, NULL );
	}
	else 
	{ //透视方式
        AcDbViewTableRecord view;
        XPoint vtViewDir;
        view.setCenterPoint(ptDcs.AsAcGePoint2d()); 
        view.setHeight( nHeight);
        view.setWidth( nWidth ); 
        VERIFY(xg_getvar(_T("VIEWDIR"), &vtViewDir) == RTNORM);
        ads_trans(XPoint(vtViewDir), (resbuf *)&g1, (resbuf *)&g0, 1, vtViewDir);
        vtViewDir.x *= nScale;
        vtViewDir.y *= nScale;
        vtViewDir.z *= nScale;
        view.setViewDirection(vtViewDir);

         //view.setElevation(ptDcs.z); // New added
        if (viewmode&0x01) 
		{
             view.setPerspectiveEnabled(true);
             if (viewmode&0x04) 
			 {// Back Clip On
                 double backz = 0.0;
                 VERIFY(xg_getvar(_T("BACKZ"), &backz) == RTNORM);
                 view.setBackClipEnabled(true);
                 view.setBackClipDistance(backz);
             }
             if (viewmode&0x02) 
			 { // Front Clip On
                 view.setFrontClipEnabled(true);
                 if (viewmode&0x10) 
				 { // front clip not at eye
                     view.setFrontClipAtEye(false);
                     double frontz = 0.0;
                     VERIFY(xg_getvar(_T("FRONTZ"), &frontz) == RTNORM);
                     view.setFrontClipDistance(frontz);
                 } 
				 else 
				 {
                     view.setFrontClipAtEye(true);
                 }
             }
             double lenslength = 0.0;
             VERIFY(xg_getvar(_T("LENSLENGTH"), &lenslength) == RTNORM);
             view.setLensLength(lenslength);

             double viewtwist = 0.0;
             VERIFY(xg_getvar(_T("VIEWTWIST"), &viewtwist) == RTNORM);
             view.setViewTwist(viewtwist);

             XPoint target;
             VERIFY(xg_getvar(_T("TARGET"), &target) == RTNORM);
             ads_trans(XPoint(target), (resbuf *)&g1, (resbuf *)&g0, 0, target);
             view.setTarget(target);
         }

         Acad::ErrorStatus es = Acad::eOk;
         es = acdbSetCurrentView( &view, NULL );
    }
}

// 让GsView固定下来
BOOL XExport::PersistGsView(AcGsView *pGsView)
{
    if (!pGsView) 
	{
        int nVportId = 0;
        xg_getvar(_T("CVPORT"), &nVportId);
#if ARX < 20
        pGsView = acgsGetGsView(nVportId, false);
#else
		pGsView = NULL;
#endif
    }
    if (pGsView) 
	{
        AcDbViewTableRecord view;
        AcGeVector3d vtViewDir = pGsView->position() - pGsView->target();
        view.setCenterPoint(AcGePoint2d(0,0));
        view.setHeight(pGsView->fieldHeight());
        view.setWidth(pGsView->fieldWidth()); 
        view.setViewDirection(vtViewDir);
        view.setPerspectiveEnabled(pGsView->isPerspective());
        view.setBackClipEnabled(pGsView->isBackClipped());
        view.setBackClipDistance(pGsView->backClip());
        view.setFrontClipEnabled(pGsView->isFrontClipped());
        view.setFrontClipAtEye(!pGsView->isFrontClipped() ? true : false);
        view.setFrontClipDistance(pGsView->frontClip());
        double nLens = 25;
        xg_getvar(_T("LENSLENGTH"), &nLens);
        view.setLensLength(nLens);
        view.setViewTwist(0.0);
        view.setTarget(pGsView->target());

        BOOL bRet = (acedSetCurrentView( &view, NULL ) == Acad::eOk);
        return bRet;
    }
    return FALSE;
}

Acad::ErrorStatus XExport::ExplodeBlockRef(const AcDbBlockTableRecord &blockRec, const AcGeMatrix3d &mat, AcDbVoidPtrArray &entSet)
{
    AcDbBlockTableRecordIterator* pBlockIterator;
    Acad::ErrorStatus es = ((AcDbBlockTableRecord &)blockRec).newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk);
	
    for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())     
	{
        AcDbEntity *pEntity;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
        ASSERT(es == Acad::eOk);
		
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            pEntity->close();
            continue;
        }
		
        AcDbEntity *pEntCopy = NULL;
        Acad::ErrorStatus es1;
        if ((es1 = pEntity->getTransformedCopy(mat, pEntCopy)) == Acad::eOk && pEntCopy) 
		{
            entSet.append(pEntCopy);
        } 
		else 
		{
            es = es1;
		}
        pEntity->close();
    }
    delete pBlockIterator;
    return es;
}



// 从块表中取所有的曲线: 包括LINE,ARC,CIRCLE,POLYLINE,LWPOLYLINE,以及在INSERT中的前述实体
void XExport::Get2DCurveFromBlock(AcDbBlockTableRecord &blockRec,  ads_matrix matForInsert)
{
    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = blockRec.newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
    ASSERT(es == Acad::eOk && !!pBlockIterator);

    for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())    
	{
        AcDbEntity *pEntity = NULL;
        pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
		if (pEntity == NULL)
		{
			continue;
		}

		if (pEntity->isKindOf(AcDbPolyline::desc()) || pEntity->isKindOf(AcDb2dPolyline::desc())) 
		{
			AcDbVoidPtrArray entSet;
			pEntity->explode(entSet);
			for (long i = 0;i<entSet.length();i++)
			{
				AcDbEntity*pEnt = (AcDbEntity*)entSet[i],*pNewEnt = NULL;
				pEnt->getTransformedCopy(AsAcGeMatrix3d(matForInsert),pNewEnt);
				if (pNewEnt != NULL)
				{
					if (XExport::AddToCurrentSpace(pNewEnt,Adesk::kTrue) == AcDbObjectId::kNull)
					{
						delete pNewEnt;
					}
				}
			}
			ReleaseEntSet(entSet);
        }
		else if (pEntity->isKindOf(AcDbBlockReference::desc()))
		{ //嵌套图块
            AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
            ASSERT(pInsert);
            XPoint ptLoc = pInsert->position();
            double nRot = pInsert->rotation();
            AcGeScale3d scale = pInsert->scaleFactors();
            AcDbObjectId idBlock = pInsert->blockTableRecord();
            XDbObject objBlock(idBlock, AcDb::kForRead);
            ASSERT(!!objBlock);
            AcDbBlockTableRecord *pRec = AcDbBlockTableRecord::cast(objBlock.m_pObject);
            ASSERT(pRec);
            XPoint ptBase = pRec->origin();
            ads_matrix mat1, mat2;
            get_matrix(ptBase, ptLoc, scale[0], scale[1], scale[2], nRot, mat1);
            AT_multiply_matrix(matForInsert, mat1, mat2);
            XExport::Get2DCurveFromBlock(*pRec, mat2);
        }
		else
		{
			AcDbEntity* pNewEnt = NULL;
			pEntity->getTransformedCopy(AsAcGeMatrix3d(matForInsert),pNewEnt);
			if (pNewEnt != NULL)
			{
				if (XExport::AddToCurrentSpace(pNewEnt,Adesk::kTrue) == AcDbObjectId::kNull)
				{
					delete pNewEnt;
				}
			}
		}
        pEntity->close();
    }
    delete pBlockIterator;
}



// 由二维图块提取二维曲线段,ssRes中将加入当前数据库空间
int XExport::GetCurveFromInsert2D(Entity &ent, PickSet &ssRes)
{
    if (!ent.Is(_T("INSERT")) && !ent.Is(_T("AEC_BLOCK_INSERT")) && !ent.Is(_T("AEC_MVINSERT")))
	{
        return RTERROR;
	}

    ads_matrix mat;
    GetInsertMatrix(ent, mat);
    XString sBlockName(256);
	int nCode = (ent.Is(_T("AEC_MVINSERT"))? 1 : 2);
    VERIFY(ent.GetData(nCode, (TCHAR *)sBlockName) == RTNORM);
    XBlockTableRecPtr rec(sBlockName, AcDb::kForRead);
    ASSERT(!!rec);

	ssRes.IncludeBegin();
    XExport::Get2DCurveFromBlock(*rec.m_pBlockTableRec, mat);
	ssRes.IncludeEnd();

    return RTNORM;
}




//模拟insert命令，可以处理属性
void XExport::InsertInCurrentSpace(AcDbObjectId idBlockRecord,AcGePoint3d ptIns,AcGeScale3d scale,double angle)
{
	AcDbBlockReference *pBlockRef = new AcDbBlockReference;
	pBlockRef->setBlockTableRecord(idBlockRecord);
	pBlockRef->setPosition(ptIns);
	pBlockRef->setScaleFactors(scale);
	pBlockRef->setRotation(angle);
	XExport::AddToCurrentSpace(pBlockRef,Adesk::kFalse);

	AcDbBlockTableRecord *pBlockRecord = NULL;
	acdbOpenObject(pBlockRecord,idBlockRecord,AcDb::kForRead);
	if (pBlockRecord != NULL)
	{
		if (pBlockRecord->hasAttributeDefinitions())//有属性
		{
			AcDbBlockTableRecordIterator *pIter = NULL;
			pBlockRecord->newIterator(pIter);
			if (pIter != NULL)
			{
				AcGeMatrix3d mat = pBlockRef->blockTransform();

				for (pIter->start();!pIter->done();pIter->step())
				{
					AcDbEntity *pEnt = NULL;
					pIter->getEntity(pEnt,AcDb::kForRead);
					if (pEnt != NULL)
					{
						AcDbAttributeDefinition*pAttDef = AcDbAttributeDefinition::cast(pEnt);
						if (pAttDef != NULL)
						{
							AcDbAttribute *pAttr = new AcDbAttribute;
							pAttr->setAttributeFromBlock(pAttDef,mat);
							pBlockRef->appendAttribute(pAttr);
							pAttr->close();
						}

						pEnt->close();
					}
				}

				delete pIter;
			}
		}
		pBlockRecord->close();
	}

	pBlockRef->close();
}

int XExport::GetPickSetByGroup(const TCHAR *szGroup, PickSet &ss)
{
    AcDbDictionary* pGroupDict;
    if (acdbCurDwg()->getGroupDictionary(pGroupDict, AcDb::kForRead) != Acad::eOk)
	{
       return RTERROR;
	}
    assert(pGroupDict);
    AcDbObjectId groupId;
    int nRet = RTERROR;
    if (pGroupDict->getAt(szGroup, groupId) == Acad::eOk) 
	{
       AcDbGroup *pGroup;
       acdbOpenObject(pGroup, groupId, AcDb::kForRead);
       assert(pGroup);
       AcDbGroupIterator *pIter = pGroup->newIterator();
       for ( ; !pIter->done(); pIter->next()) 
	   {
           ads_name ent;
           acdbGetAdsName(ent, pIter->objectId());
           ss += Entity(ent);
       }
       delete pIter;
       pGroup->close();
       nRet = RTNORM;
    }
    pGroupDict->close();
    return nRet;
}

int XExport::MakeGroup(PickSet &ss, const TCHAR *pGroupName, BOOL bClearOld)
{
	Acad::ErrorStatus es;
	AcDbObjectId groupobjId;
	AcDbGroup *pGroup = NULL;
	AcDbDictionary *pGroupDict = NULL;
	
	es = acdbCurDwg()->getGroupDictionary(pGroupDict,AcDb::kForWrite);
	if (es != Acad::eOk)
	{
		return RTERROR;
	}
	
	es = pGroupDict->getAt(pGroupName,groupobjId);
	if (es == Acad::eOk)
	{
		// 取得pGroup并清空
		es = acdbOpenObject(pGroup, groupobjId, AcDb::kForWrite);
		if (es != Acad::eOk)
		{
			pGroupDict->close();
			return RTERROR;
		}
		pGroup->setSelectable(Adesk::kFalse);
		if (bClearOld) 
		{
			pGroup->clear();
		}
	}
	else 
	{
		//新建一组,并添入字典
		pGroup = new AcDbGroup;
		pGroup->setSelectable(Adesk::kFalse);
		es = pGroupDict->setAt(pGroupName,pGroup,groupobjId);
		assert(es == Acad::eOk);
	}
	pGroupDict->close();
	
	//往组中添加选择集中的实体
	AcDbObjectId objectId;
	long nLen = ss.Length();
	
	for (long i = 0L; i < nLen; i++) 
	{
		Entity en = ss[i];
		if (acdbGetObjectId(objectId,en) != Acad::eOk) 
		{
			pGroup->close();
			return RTERROR;
		}
		if (pGroup->append(objectId) != Acad::eOk)
		{
			pGroup->close();
			return RTERROR;
		}
	}
	pGroup->close();
	
	return RTNORM;
	
}

// 把象素值转化为当前坐标系下的长度
double XExport::PixelToWcs(int nPixel)
{
	XPoint ptScreenSize;
    double nViewSize;
	xg_getvar(_T("ScreenSize"), &ptScreenSize);
	xg_getvar(_T("ViewSize"), &nViewSize);
    if (ptScreenSize.y < 1.0E-6 || nViewSize < 1.0E-6)
	{
        return 0.0;
	}
	double hight = (nViewSize / ptScreenSize.y) * nPixel;
    return hight;
}

// 得到耙区在WCS下的大小
double XExport::GetApertureWcs()
{
    int nAperture = 1;
    VERIFY(xg_getvar(_T("APERTURE"), &nAperture) == RTNORM);
    if (nAperture < 1)
	{
        return 0.0;
	}
    double nApertureWcs = XExport::PixelToWcs(nAperture);
    ASSERT(nApertureWcs > 0.0);
    return nApertureWcs;
}

double XExport::GetPickBoxWcs()
{
    int nAperture = 1;
    VERIFY(xg_getvar(_T("PICKBOX"), &nAperture) == RTNORM);
    if (nAperture < 1)
	{
        return 0.0;
	}
    double nApertureWcs = XExport::PixelToWcs(nAperture);
    ASSERT(nApertureWcs > 0.0);
    return nApertureWcs;
}

void XExport::get_matrix(const XPoint &ptBase, const XPoint &ptInsert,
					 double sx, double sy, double sz, double rot, ads_matrix result)
{
      // XPoint mv = insPt-blkTab.base;
      // 先移动base到原点, Scale, Rotation, 再平移到insPt
      ads_matrix mvMat1 = { {1, 0, 0, -ptBase.x},
							{0, 1, 0, -ptBase.y},
							{0, 0, 1, -ptBase.z},
							{0, 0, 0, 1},};

      ads_matrix sclMat = { {sx, 0, 0, 0},
							{0,  sy, 0, 0},
							{0,  0,  sz, 0},
							{0, 0, 0, 1},};

      ads_matrix rotMat = { {cos(rot), -sin(rot), 0, 0},
							{sin(rot),  cos(rot), 0, 0},
							{0,         0,        1, 0},
							{0,         0,        0, 1},};

      ads_matrix mvMat2 = { {1, 0, 0, ptInsert.x},
							{0, 1, 0, ptInsert.y},
							{0, 0, 1, ptInsert.z},
							{0, 0, 0, 1},};

      MatrixMultiply(result, mvMat2, rotMat, sclMat, mvMat1, NULL);
}

int XExport::GetBlockExtents(AcDbObjectId idBlock, XPoint &ptLow, XPoint &ptUp)
{
	XPoint ptMin, ptMax;
	BOOL bInit = FALSE;
	
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	ASSERT(pBlock);
	
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
	ASSERT(es == Acad::eOk && pBlockIterator);
	for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step()) 
	{
		AcDbEntity *pEntity = NULL;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
		ASSERT(es == Acad::eOk);
		XDbObject obj(pEntity);
		XPoint pt1, pt2;
		if (pEntity->isKindOf(AcDbRasterImage::desc()) || pEntity->isKindOf(AcDbAttributeDefinition::desc())) 
		{
			continue;
		}
		else if (pEntity->isKindOf(AcDbBlockReference::desc())) 
		{
			AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
			AcGeMatrix3d mat = BlockTransform(pInsert);
			if (XExport::GetBlockExtents(pInsert->blockTableRecord(), pt1, pt2) != RTNORM)
			{
				continue;
			}
			((AcGePoint3d &)pt1).transformBy(mat);
			((AcGePoint3d &)pt2).transformBy(mat);
		} 
		else
		{
			AcDbExtents extent;
			if (pEntity->getGeomExtents(extent) != Acad::eOk) 
			{
				continue;
			}
			pt1 = extent.minPoint();
			pt2 = extent.maxPoint();
		}
		if (!bInit) 
		{
			ptMin = pt1;
			ptMax = pt2;
			bInit = TRUE;
		} 
		else 
		{
			ptMin = Min(pt1, ptMin);
			ptMax = Max(pt2, ptMax);
		}
	}
	delete pBlockIterator;
	OPENOBJ_END();
	
	if (bInit)
	{
		ptLow = ptMin;
		ptUp = ptMax;
	}
	return (bInit? RTNORM : RTERROR);
}

// 取图块的尺寸信息
int XExport::GetBlockRefSizeInfo(const AcDbBlockReference *pBlkRef, XPoint &ptBase, double *nRot,
						XPoint &ptCen, double *nSizeX, double *nSizeY, double *nSizeZ)
{
    ASSERT(pBlkRef);
    if (!pBlkRef)
	{
        return RTERROR;
	}
	
    *nRot = pBlkRef->rotation();
    ptBase = pBlkRef->position();
	
    ads_matrix mat;
    ptBase.GetRotationMatrix(*nRot, mat);
	
    XPoint ptMin, ptMax;
    if (XExport::GetBlockExtents(pBlkRef->blockTableRecord(), ptMin, ptMax) != RTNORM)
	{
        return RTERROR;
	}
    AcGeScale3d scale = pBlkRef->scaleFactors();
    *nSizeX = fabs(ptMax.x - ptMin.x)*scale[0];
    *nSizeY = fabs(ptMax.y - ptMin.y)*scale[1];
    *nSizeZ = fabs(ptMax.z - ptMin.z)*scale[2];
	
    AcGeMatrix3d mat3d = BlockTransform(pBlkRef);
    ((AcGePoint3d &)ptMin).transformBy(mat3d);
    ((AcGePoint3d &)ptMax).transformBy(mat3d);
    Midpoint(ptMin, ptMax, ptCen); 
    return RTNORM;
}

// 由字符串换算线型的id
AcDbObjectId XExport::GetLinetypeIdFromString(const TCHAR* pStr,  AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}
    AcDbObjectId id;
    if (pStr) 
	{
        AcDbLinetypeTable* pLinetypeTable = NULL;

        Acad::ErrorStatus err = pDb->getLinetypeTable(pLinetypeTable, AcDb::kForRead);
        if (err == Acad::eOk && pLinetypeTable) 
		{
            err = pLinetypeTable->getAt(pStr, id);
            pLinetypeTable->close();
        }
    }
    return id;
}

// 由字符串换算层的id
AcDbObjectId XExport::GetLayerIdFromString(const TCHAR* pStr, AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}
    AcDbObjectId id;
    if (pStr) 
	{
        AcDbLayerTable* pLayerTable = NULL;
        Acad::ErrorStatus err = pDb->getLayerTable(pLayerTable,AcDb::kForRead);
        if (err == Acad::eOk && pLayerTable) 
		{
            err = pLayerTable->getAt(pStr, id);
            pLayerTable->close();
        }
    }
    return id;
}

// 由字型名称求ID
AcDbObjectId XExport::GetTextStyleId(const TCHAR *styleName, AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}
    AcDbTextStyleTable *pStyleTable;
    Acad::ErrorStatus es = pDb->getTextStyleTable(pStyleTable, AcDb::kForRead);
    AcDbObjectId styleId;
    if (es == Acad::eOk) 
	{
        es = pStyleTable->getAt(styleName, styleId);
        pStyleTable->close();
    }
    return styleId;
}

AcDbObjectId XExport::GetDimStyleId(const TCHAR  *styleName, AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}

    AcDbDimStyleTable *pStyleTable;
    Acad::ErrorStatus es = pDb->getDimStyleTable(pStyleTable, AcDb::kForRead);
    AcDbObjectId styleId;
    if (es == Acad::eOk) 
	{
        es = pStyleTable->getAt(styleName, styleId);
        pStyleTable->close();
    }
    return styleId;
}

AcDbObjectId XExport::InitLineType(const TCHAR *szLineType, AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}
    AcDbObjectId idLineType = XExport::GetLinetypeIdFromString(szLineType, pDb);
    if (!idLineType) 
	{
        pDb->loadLineTypeFile(szLineType, _T("acad.lin"));
        idLineType = XExport::GetLinetypeIdFromString(szLineType, pDb);
    }
    return idLineType;
}

 AcDbObjectId XExport::InitTchLineType(const TCHAR *szLineType, AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}
    AcDbObjectId idLineType = XExport::GetLinetypeIdFromString(szLineType, pDb);
    if (!idLineType)
	{
        pDb->loadLineTypeFile(szLineType, _T("Aec.lin"));
        idLineType = XExport::GetLinetypeIdFromString(szLineType, pDb);
    }
    return idLineType;
}

 AcDbObjectId XExport::GetBlockIdFromString(const TCHAR *pszBlock, AcDbDatabase *pDb)
{
    XBlockTableRecPtr blk(pszBlock, AcDb::kForRead, pDb);
    AcDbObjectId id;
	if (!!blk)
	{
		id = blk.m_pBlockTableRec->objectId();
	}
	return id;
}

extern Acad::ErrorStatus fromAcDbTextStyle(AcGiTextStyle& style,  const AcDbObjectId&  AcDbStyleId);
// 把AcDbTextStyle转成AcGiTextStyle
Acad::ErrorStatus XExport::GetAcGiTextStyle(AcDbObjectId styleId, AcGiTextStyle &newStyle)
{
    return fromAcDbTextStyle(newStyle, styleId);
}

// 确定文字尺寸, 优先顺序
//   style默认尺寸--当前字型尺寸--当前文字尺寸
double XExport::GetTextSize(const TCHAR *m_sTextStyle)
{
    double dTextSize = 0.0;
    VERIFY(xg_getvar(_T("TEXTSIZE"), &dTextSize) == RTNORM);

    XString sTextStyle;
    if (!m_sTextStyle) 
	{
        xg_getvar(_T("TEXTSTYLE"), sTextStyle);
    }
	else 
	{
        sTextStyle = m_sTextStyle;
    }

    AcDbObjectId idTextStyle = GetTextStyleId(sTextStyle);
    if (!idTextStyle)
	{
        return dTextSize;
	}
    XDbObject obj(idTextStyle, AcDb::kForRead);
    if (!obj)
	{
        return dTextSize;
	}

    AcDbTextStyleTableRecord *newStyle = AcDbTextStyleTableRecord::cast(obj.m_pObject);
    ASSERT(newStyle);


    if (newStyle->textSize() > 1.0E-6) 
	{
         dTextSize = newStyle->textSize();
    }
    return dTextSize;
}

// 释放实体集合 entSet通常是炸碎的结果
void XExport::ReleaseEntSet(AcDbVoidPtrArray &entSet)
{
    while(!entSet.isEmpty()) 
	{
        AcDbEntity *pEnt = AcDbEntity::cast((AcDbEntity *)entSet[0]);
		if (pEnt != NULL)
		{
			delete pEnt;
		}
        entSet.removeAt(0);
    }
}

void XExport::InitView(AcDbViewTableRecord &view)
{
    int viewmode;
    VERIFY(xg_getvar(_T("VIEWMODE"), &viewmode) == RTNORM);

    XPoint ptViewCtr;
    VERIFY(xg_getvar(_T("VIEWCTR"), &ptViewCtr) == RTNORM);
    XPoint ptDcs;
    ads_trans(ptViewCtr, Groups(1), Groups(2), 0, ptDcs);

    int nCurVp;
    VERIFY(xg_getvar(_T("CVPORT"), &nCurVp) == RTNORM);
    view.setIsPaperspaceView(nCurVp == 1);
    view.setCenterPoint(ptDcs.AsAcGePoint2d());

    double nWidth, nHeight;
    AT_ScrSize(&nWidth, &nHeight);
    view.setHeight( nHeight);
    view.setWidth( nWidth ); 

    XPoint vtViewDir;
    VERIFY(xg_getvar(_T("VIEWDIR"), &vtViewDir) == RTNORM);

	Groups g0(0), g1(1);

    ads_trans(XPoint(vtViewDir), (resbuf *)&g1, (resbuf *)&g0, 1, vtViewDir);
    view.setViewDirection(vtViewDir);

    double viewtwist = 0.0;
    VERIFY(xg_getvar(_T("VIEWTWIST"), &viewtwist) == RTNORM);
    view.setViewTwist(viewtwist);

    XPoint target;
    VERIFY(xg_getvar(_T("TARGET"), &target) == RTNORM);
    ads_trans(XPoint(target), (resbuf *)&g1, (resbuf *)&g0, 0, target);
    view.setTarget(target);

    if (viewmode&0x01) 
	{
         view.setPerspectiveEnabled(true);
         if (viewmode&0x04) 
		 {// Back Clip On
             double backz = 0.0;
             VERIFY(xg_getvar(_T("BACKZ"), &backz) == RTNORM);
             view.setBackClipEnabled(true);
             view.setBackClipDistance(backz);
         }
         if (viewmode&0x02) 
		 { // Front Clip On
             view.setFrontClipEnabled(true);
             if (viewmode&0x10)
			 { // front clip not at eye
                 view.setFrontClipAtEye(false);
                 double frontz = 0.0;
                 VERIFY(xg_getvar(_T("FRONTZ"), &frontz) == RTNORM);
                 view.setFrontClipDistance(frontz);
             }
			 else
			 {
                 view.setFrontClipAtEye(true);
             }
         }
         double lenslength = 0.0;
         VERIFY(xg_getvar(_T("LENSLENGTH"), &lenslength) == RTNORM);
         view.setLensLength(lenslength);
     }
}

// 用ARX实现ZOOM, 不调用'ZOOM命令
Acad::ErrorStatus XExport::arxZoom(const XPoint &ptLow, const XPoint &ptUp)
{
	AcDbViewTableRecord view;
	InitView(view);
	AcGePoint2d max_2d = ptUp, min_2d = ptLow; 
	XPoint ptCen, vtViewDir;
	Midpoint(ptLow, ptUp, ptCen);
	XPoint ptDcs;
	ads_trans(ptCen, Groups(0), Groups(2), 0, ptDcs);
	view.setCenterPoint(ptDcs.AsAcGePoint2d());
	view.setHeight( fabs(ptUp.y-ptLow.y) );
	view.setWidth( fabs(ptUp.x - ptLow.x) ); 

	Acad::ErrorStatus es = acedSetCurrentView( &view, NULL );
	return es;
}

//add by zjq 100520 优化获取选择集速度
CMapPtrToPtr g_mapDbToModelRecZone;
void XExport::BeginModelRecordZone()
{
	XBlockTableRecordZone* pZone = NULL;
	if (g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone))
	{
	}
	else
	{
		pZone = new XBlockTableRecordZone;
		g_mapDbToModelRecZone.SetAt((void*)acdbCurDwg(),pZone);
	}
	pZone->setActive(true);
}

void XExport::ModifyModelRecordZone(const AcDbObject* pObj)
{
	AcDbEntity* pEnt = AcDbEntity::cast(pObj);
	if (pEnt == NULL) return;
	
	XBlockTableRecordZone* pZone = NULL;
	if (g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone))
	{
		if (pObj->objectId().isValid())
		{
			pZone->remove(pObj->objectId());
		}
	}
}

bool XExport::GetGeomExtentsInRecordZone(AcDbObjectId& id,AcDbExtents& ext)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL)
	{
		return pZone->getGeomExtents(id,ext);
	}	
	return false;
}



//选单个实体,优先从全局选择集中筛选
int XExport::SelectEntity(const TCHAR *szPrompt, Entity &entResult, RBList &rbBaseMask)
{
    Entity ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect(szPrompt, rbBaseMask);
    if (nRet == RTNORM)
	{
        entResult = ent;
	}
    return nRet;
}

//  选单个实体,优先从全局选择集中筛选, ptPick--UCS
int XExport::SelectEntity(const TCHAR *szPrompt, Entity &entResult, XPoint &ptPick, RBList &rbBaseMask)
{
    Entity ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect(szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM) 
	{
        entResult = ent;
    }
    return nRet;
}

//  选单个实体,优先从全局选择集中筛选
int XExport::SelectEntity1(const TCHAR *szPrompt, Entity &entResult, XPoint &ptPick, RBList &rbBaseMask)
{
    Entity ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect1(GetPickBoxWcs()/2, szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM)
	{
        entResult = ent;
	}
    return nRet;
}

//  选单个实体,优先从全局选择集中筛选
int XExport::SelectEntity1(double nPrec, const TCHAR *szPrompt, Entity &entResult, XPoint &ptPick, RBList &rbBaseMask)
{
    Entity ent;
    int nRet = RTERROR;
    nRet = ent.FilterSelect1(nPrec, szPrompt, rbBaseMask, ptPick);
    if (nRet == RTNORM)
	{
        entResult = ent;
	}
    return nRet;
}

//选多个实体，优先从全局选择集中筛选
int XExport::SelectEntities(const TCHAR *szPrompt, PickSet &ssResult, RBList &rbBaseMask)
{
    PickSet ssPickFirst(SS_FREE|SS_CREATE);
    ssPickFirst.BaseFilter(rbBaseMask);

   int nRetCode = RTNORM;
   int nCount = ssPickFirst.Length();
   if (!ssPickFirst || !ssPickFirst.Length()) 
   {
       const TCHAR *szPrompts[2] = { szPrompt, _T("移除物体") };
       ads_sssetfirst(NULL, NULL);
       nRetCode = ssResult.Get(_T(":$"), szPrompts,NULL,rbBaseMask);
   }
   else 
   {
       ads_sssetfirst(NULL, NULL);
       ssResult += ssPickFirst;
   }
   return nRetCode;
}


int XExport::SelectEntities(const TCHAR *szPrompt, PickSet &ssResult, RBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
{
	int nRet;
	INITGET_BEG(-2,szKeyword)
	nRet = XExport::SelectEntities(szPrompt, ssResult, rbBaseMask);
	INITGET_END();
	if (g_cKeyword != 0)
	{
		cRet = g_cKeyword;
		ssResult.Free();
		return RTKWORD;
	}
	return nRet;
}

int XExport::SelectEntity(const TCHAR *szPrompt, Entity &entResult, XPoint &ptPick, RBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
{
	int nRet;
	INITGET_BEG(-2,szKeyword)
	nRet = XExport::SelectEntity(szPrompt, entResult,ptPick, rbBaseMask);
	INITGET_END();
	if (g_cKeyword != 0)
	{
		cRet = g_cKeyword;
		return RTKWORD;
	}
	return nRet;
}

void XExport::EndModelRecordZone()
{
	XBlockTableRecordZone* pZone = NULL;
	if (g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone))
	{
		pZone->setActive(false);
	}
}

//real cross corner select 
 void RealCornerSel(PickSet &ss,BOOL bCrossing,const XPoint &ptLow,const XPoint &ptUp,AcDbEntity* pEntity)
 {
	AcDbExtents ext;
	pEntity->getGeomExtents(ext);

	if ( ptLow.x - ext.minPoint().x < 1.e-10 && ptLow.y - ext.minPoint().y < 1.e-10 &&
		 ptUp.x  - ext.maxPoint().x > -1.e-10 && ptUp.y - ext.maxPoint().y  > 1.e-10 )
	{
		Entity ent;
		VERIFY(acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk);
		ss += ent;
	}
	else if(bCrossing)//intersect with
	{
		AcDbLine line[4];
		AcGePoint3d pt1,pt2;

		//
		//     +---------------+ ptup
		//     |               |
		//	   |               |
		//     |               |
		//     +---------------+
		//     ptlow
		double dW = ptUp.x - ptLow.x;
		double dH = ptUp.y - ptLow.y;

		pt1 = ptLow.AsAcGePoint3d();
		pt2 = ptLow;
		pt2 += AcGeVector3d::kXAxis * dW;
		line[0].setStartPoint(pt1);
		line[0].setEndPoint(pt2);

		pt2 = ptLow;
		pt2 += AcGeVector3d::kYAxis * dH;
		line[1].setStartPoint(pt1);
		line[1].setEndPoint(pt2);

		pt1 = ptUp.AsAcGePoint3d();
		pt2 = ptUp - AcGeVector3d::kXAxis * dW;
		line[2].setStartPoint(pt1);
		line[2].setEndPoint(pt2);

		pt2 = ptUp - AcGeVector3d::kYAxis * dH;
		line[3].setStartPoint(pt1);
		line[3].setEndPoint(pt2);

		AcGePoint3dArray pts;
		for (int i = 0;i < 4;i++)
		{
			line[i].intersectWith(pEntity,AcDb::kOnBothOperands,pts);

			if (pts.length() > 0)
			{
				Entity ent;
				VERIFY(acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk);
				ss += ent;
				break;
			}
		}
	}
 }

 void RealCornerSel(AcDbObjectIdArray &arIDs,BOOL bCrossing,const XPoint &ptLow,const XPoint &ptUp,AcDbEntity* pEntity)
 {
	AcDbExtents ext;
	pEntity->getGeomExtents(ext);

	if ( ptLow.x - ext.minPoint().x < 1.e-10 && ptLow.y - ext.minPoint().y < 1.e-10 &&
		 ptUp.x  - ext.maxPoint().x > -1.e-10 && ptUp.y - ext.maxPoint().y  > 1.e-10 )
	{
		arIDs.append(pEntity->objectId());
	}
	else if(bCrossing)//intersect with
	{
		AcDbLine line[4];
		AcGePoint3d pt1,pt2;

		//
		//     +---------------+ ptup
		//     |               |
		//	   |               |
		//     |               |
		//     +---------------+
		//     ptlow
		double dW = ptUp.x - ptLow.x;
		double dH = ptUp.y - ptLow.y;

		pt1 = ptLow.AsAcGePoint3d();
		pt2 = ptLow;
		pt2 += AcGeVector3d::kXAxis * dW;
		line[0].setStartPoint(pt1);
		line[0].setEndPoint(pt2);

		pt2 = ptLow;
		pt2 += AcGeVector3d::kYAxis * dH;
		line[1].setStartPoint(pt1);
		line[1].setEndPoint(pt2);

		pt1 = ptUp.AsAcGePoint3d();
		pt2 = ptUp - AcGeVector3d::kXAxis * dW;
		line[2].setStartPoint(pt1);
		line[2].setEndPoint(pt2);

		pt2 = ptUp - AcGeVector3d::kYAxis * dH;
		line[3].setStartPoint(pt1);
		line[3].setEndPoint(pt2);

		AcGePoint3dArray pts;
		for (int i = 0;i < 4;i++)
		{
			line[i].intersectWith(pEntity,AcDb::kOnBothOperands,pts);

			if (pts.length() > 0)
			{
				arIDs.append(pEntity->objectId());
				break;
			}
		}
	}
 }

//Acad::ErrorStatus XExport::GetViewSafeSelection(AcDbObjectIdArray &arIDs, BOOL bCrossing, const XPoint &ptLow, const XPoint &ptUp,const TCHAR* pszDxf,BOOL bRealCornerSel)
//{
//	XPoint ptLow0 = ptLow;
//	XPoint ptUp0 = ptUp;
//
//	//1.first select ent normaly
//	PickSet ss(SS_CREATE);
//	GetSafeSelection(ss,bCrossing,ptLow0,ptUp0,pszDxf,bRealCornerSel);
//
//	//2.sepc deal with blk ref
//	ss.AsIdArray(arIDs);
//
//	//3.mat- inv
//	AcGeMatrix3d mat;
//	AcDbEntity* pEnt = NULL;
//	XPoint ptLow1,ptUp1;
//
//	for (long i = 0;i < arIDs.length();i++)
//	{
//		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arIDs.at(i),AcDb::kForRead))
//		{
//			AcDbBlockReference* pRef = AcDbBlockReference::cast(pEnt);
//			if (pRef != NULL)
//			{
//				mat = pRef->blockTransform();
//				mat.invert();
//				
//				ptLow1 = ptLow0;
//				ptUp1 = ptUp0;
//				ptLow1.TransformBy(mat);
//				ptUp1.TransformBy(mat);
//
//				//add by zjq on 110315重新计算包围盒
//				double dX0 = __min(ptLow1.x,ptUp1.x);
//				double dY0 = __min(ptLow1.y,ptUp1.y);
//
//				double dX1 = __max(ptLow1.x,ptUp1.x);
//				double dY1 = __max(ptLow1.y,ptUp1.y);
//
//				ptLow1.x = dX0;
//				ptLow1.y = dY0;
//				ptUp1.x = dX1;
//				ptUp1.y = dY1;
//
//				//3.1 safe select inside record
//				AcDbObjectIdArray arIDs2;
//				XExport::GetSafeSelection(arIDs2,bCrossing,ptLow1,ptUp1,pszDxf,pRef->blockTableRecord(),bRealCornerSel);
//
//				arIDs.removeAt(i);
//
//				for (long j = 0;j < arIDs2.length();j++)
//				{
//					arIDs.append(arIDs2.at(j));
//				}
//
//				i--;
//			}
//			pEnt->close();
//		}
//	}
//	return Acad::eOk;
//}

//Acad::ErrorStatus XExport::GetViewSafeSelection(AcDbObjectIdArray &arIDs, BOOL bCrossing, const XPoint &ptLow, const XPoint &ptUp,
//												  const AcRxClass* pClass,BOOL bRealCornerSel)
//{
//	XPoint ptLow0 = ptLow;
//	XPoint ptUp0 = ptUp;
//
//	//1.first select ent normaly
//	PickSet ss(SS_CREATE);
//	GetSafeSelection(ss,bCrossing,ptLow0,ptUp0,pClass);
//
//	//2.sepc deal with blk ref
//	ss.AsIdArray(arIDs);
//
//	//3.mat- inv
//	AcGeMatrix3d mat;
//	AcDbEntity* pEnt = NULL;
//	XPoint ptLow1,ptUp1;
//
//	for (long i = 0;i < arIDs.length();i++)
//	{
//		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arIDs.at(i),AcDb::kForRead))
//		{
//			AcDbBlockReference* pRef = AcDbBlockReference::cast(pEnt);
//			if (pRef != NULL)
//			{
//				mat = pRef->blockTransform();
//				mat.invert();
//				
//				ptLow1 = ptLow0;
//				ptUp1 = ptUp0;
//
//				ptLow1.TransformBy(mat);
//				ptUp1.TransformBy(mat);
//				
//				//add by zjq on 110315重新计算包围盒
//				double dX0 = __min(ptLow1.x,ptUp1.x);
//				double dY0 = __min(ptLow1.y,ptUp1.y);
//
//				double dX1 = __max(ptLow1.x,ptUp1.x);
//				double dY1 = __max(ptLow1.y,ptUp1.y);
//
//				ptLow1.x = dX0;
//				ptLow1.y = dY0;
//				ptUp1.x = dX1;
//				ptUp1.y = dY1;
//
//				//3.1 safe select inside record
//				AcDbObjectIdArray arIDs2;
//				XExport::GetSafeSelection(arIDs2,bCrossing,ptLow1,ptUp1,pClass,pRef->blockTableRecord(),bRealCornerSel);
//
//				arIDs.removeAt(i);
//
//				for (long j = 0;j < arIDs2.length();j++)
//				{
//					arIDs.append(arIDs2.at(j));
//				}
//
//				i--;
//			}
//			pEnt->close();
//		}
//	}
//	return Acad::eOk;
//}

//Acad::ErrorStatus XExport::GetSafeSelection(AcDbObjectIdArray &arIDs, BOOL bCrossing, const XPoint &ptLow, 
//											  const XPoint &ptUp, const TCHAR *pDxfWizard,
//											  AcDbObjectId idBlock,BOOL bRealCornerSel)
//{
//	XBlockTableRecordZone* pZone = NULL;
//	Acad::ErrorStatus esRet = Acad::eNotApplicable;
//	XBlockTableRecPtr objMSpace(idBlock);
//	if (!objMSpace)
//	{
//		return esRet;
//	}
//	
//	CString sDxfWiz;
//    if (pDxfWizard)
//	{
//        sDxfWiz = pDxfWizard;
//	}
//
//	XPoint ptMid;
//	Midpoint(ptLow, ptUp, ptMid);
//	XRectAngle rect(ptLow, ptUp);
//	
//	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
//	Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
//	ASSERT(es == Acad::eOk && pBlockIterator != NULL);
//	
//	for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
//	{
//		AcDbEntity *pEntity = NULL;
//		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
//		if (es != Acad::eOk) 
//		{
//			continue;
//		}
//		ASSERT(pEntity);
//		
//		XDbObject vTemp(pEntity);
//		if (pEntity->visibility() == AcDb::kInvisible) 
//		{
//			continue;
//		}
//
//		AcRxClass *pRxInfo = pEntity->isA();
//		CString str=pRxInfo->dxfName();
//		if (!pDxfWizard ||  /*ads_wcmatch(pRxInfo->dxfName(), sDxfWiz) == RTNORM*/ sDxfWiz.Find(pRxInfo->dxfName(),0) != -1) 
//		{
//			if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc()))
//			{
//				AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
//				XPoint ptCurve; 
//				if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
//					ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
//					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
//				{
//					/*Entity ent;
//					VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
//					ss += ent;*/
//					bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pCurve->objectId());
//					esRet = Acad::eOk;
//				}
//			}
//			else 
//			{
//				bool bHasExt = false;
//				AcDbExtents ext;
//
//				//modify by zjq
//				if (pZone != NULL)
//				{
//					if (pZone->getGeomExtents(pEntity->objectId(),ext))
//					{
//						bHasExt = true;
//					}
//				}
//
//				if (bHasExt)
//				{
//					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
//					ptExtMin.z = ptExtMax.z = 0;
//					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
//					{
//					}
//					else 
//					{
//						/*Entity ent;
//						acdbGetAdsName(ent.name, pEntity->objectId());
//						ss += ent;*/
//						bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pEntity->objectId());
//						
//						esRet = Acad::eOk;
//					}
//				}
//				else
//				{
//					if ( pEntity->getGeomExtents(ext) == Acad::eOk)
//					{
//						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);
//
//						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
//						ptExtMin.z = ptExtMax.z = 0;
//						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
//						{
//						}
//						else 
//						{
//							/*Entity ent;
//							acdbGetAdsName(ent.name, pEntity->objectId());
//							ss += ent;*/
//							bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pEntity->objectId());
//							esRet = Acad::eOk;
//						}
//					}
//				}
//			}
//		}	
//	}
//	delete pBlockIterator;
//	return esRet;
//}

//Acad::ErrorStatus XExport::GetSafeSelection(AcDbObjectIdArray &arIDs, BOOL bCrossing, const XPoint &ptLow, 
//											  const XPoint &ptUp, const AcRxClass *pClass,AcDbObjectId idBlock,
//											  BOOL bRealCornerSel)
//{
//	XBlockTableRecordZone* pZone = NULL;
//	Acad::ErrorStatus esRet = Acad::eNotApplicable;
//	XBlockTableRecPtr objMSpace(idBlock);
//	if (!objMSpace)
//	{
//		return esRet;
//	}
//	
//	XPoint ptMid;
//	Midpoint(ptLow, ptUp, ptMid);
//	XRectAngle rect(ptLow, ptUp);
//	
//	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
//	Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
//	ASSERT(es == Acad::eOk && pBlockIterator != NULL);
//	
//	for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
//	{
//		AcDbEntity *pEntity = NULL;
//		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
//		if (es != Acad::eOk) 
//		{
//			continue;
//		}
//		ASSERT(pEntity);
//		
//		XDbObject vTemp(pEntity);
//		if (pEntity->visibility() == AcDb::kInvisible) 
//		{
//			continue;
//		}
//		AcRxClass *pRxInfo = pEntity->isA();
//		
//		if (!pClass ||  pRxInfo == pClass) 
//		{
//			if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc()))
//			{
//				AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
//				XPoint ptCurve; 
//				if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
//					ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
//					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
//				{
//					/*Entity ent;
//					VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
//					ss += ent;*/
//					bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pEntity->objectId());
//					esRet = Acad::eOk;
//				}
//			}
//			else 
//			{
//				bool bHasExt = false;
//				AcDbExtents ext;
//
//				//modify by zjq
//				if (pZone != NULL)
//				{
//					if (pZone->getGeomExtents(pEntity->objectId(),ext))
//					{
//						bHasExt = true;
//					}
//				}
//
//				if (bHasExt)
//				{
//					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
//					ptExtMin.z = ptExtMax.z = 0;
//					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
//					{
//					}
//					else 
//					{
//						/*Entity ent;
//						acdbGetAdsName(ent.name, pEntity->objectId());
//						ss += ent;*/
//						bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pEntity->objectId());
//						esRet = Acad::eOk;
//					}
//				}
//				else
//				{
//					if ( pEntity->getGeomExtents(ext) == Acad::eOk)
//					{
//						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);
//
//						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
//						ptExtMin.z = ptExtMax.z = 0;
//						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
//						{
//						}
//						else 
//						{
//							/*Entity ent;
//							acdbGetAdsName(ent.name, pEntity->objectId());
//							ss += ent;*/
//							bRealCornerSel ? RealCornerSel(arIDs,bCrossing,ptLow,ptUp,pEntity) : arIDs.append(pEntity->objectId());
//							esRet = Acad::eOk;
//						}
//					}
//				}
//			}
//		}	
//	}
//	delete pBlockIterator;
//	return esRet;
//}


 //安全模式开窗口搜索选择集
 //目前只验证过"C"方式
 //bCrossing  :  FALSE-对曲线加速
Acad::ErrorStatus XExport::GetSafeSelection(PickSet &ss, BOOL bCrossing, const XPoint &ptLow,
											  const XPoint &ptUp, const AcRxClass *pClass,BOOL bRealCornerSel)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}
	
	Acad::ErrorStatus esRet = Acad::eNotApplicable;
	XBlockTableRecPtr objMSpace;
	if (!objMSpace)
	{
		return esRet;
	}
	
	XPoint ptMid;
	Midpoint(ptLow, ptUp, ptMid);
	XRectAngle rect(ptLow, ptUp);
	
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	
	for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
		AcDbEntity *pEntity = NULL;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
		if (es != Acad::eOk)
		{
			continue;
		}
		ASSERT(pEntity);

		//pEntity没有close? zjq
		
		XDbObject vTemp(pEntity);
		//不处理不可见的实体
		if (pEntity->visibility() == AcDb::kInvisible) 
		{
			continue;
		}
		AcRxClass *pRxInfo = pEntity->isA();
		
		if (!pClass ||  pRxInfo == pClass) 
		{
			if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
			{ //用于加速目的，光标移动时自动捕捉时使用
				AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
				XPoint ptCurve; 
				if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
					ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
				{
					Entity ent;
					VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);

					if (bRealCornerSel)
						RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
					else
						ss += ent;

					esRet = Acad::eOk;
				}
			} 
			else 
			{
				bool bHasExt = false;
				AcDbExtents ext;

				//modify by zjq on 100520 优化求包围盒算法
				if ( pZone != NULL )
				{
					if (pZone->getGeomExtents(pEntity->objectId(),ext))
					{
						bHasExt = true;
					}
				}

				if (bHasExt)
				{
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y)
					{
					} 
					else 
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());

						if (bRealCornerSel)
							RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
						else
							ss += ent;

						esRet = Acad::eOk;
					}	
				}
				else
				{
					if (pEntity->getGeomExtents(ext) == Acad::eOk)
					{
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);

						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y)
						{
						} 
						else 
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());

							if (bRealCornerSel)
								RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
							else
								ss += ent;

							esRet = Acad::eOk;
						}
					}
				}
			}
		}
		
	}
	delete pBlockIterator;
	return esRet;
}

Acad::ErrorStatus XExport::GetSafeSelection(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
											  const XPoint &ptUp, const AcRxClass *pClass,AcDbObjectId idBlock)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}

	Acad::ErrorStatus esRet = Acad::eNotApplicable;
	XBlockTableRecPtr objMSpace(idBlock);
	if (!objMSpace)
	{
		return esRet;
	}
	
	XPoint ptMid;
	Midpoint(ptLow, ptUp, ptMid);
	XRectAngle rect(ptLow, ptUp);
	
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	
	for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
		AcDbEntity *pEntity = NULL;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
		if (es != Acad::eOk) 
		{
			continue;
		}
		ASSERT(pEntity);
		//pEntity没有close? zjq
		
		XDbObject vTemp(pEntity);
		//不处理不可见的实体
		if (pEntity->visibility() == AcDb::kInvisible) 
		{
			continue;
		}
		AcRxClass *pRxInfo = pEntity->isA();
		
		if (!pClass ||  pRxInfo == pClass) 
		{
			if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc()))
			{ //用于加速目的，光标移动时自动捕捉时使用
				AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
				XPoint ptCurve; 
				if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
					ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
				{
					Entity ent;
					VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
					ss += ent;
					esRet = Acad::eOk;
				}
			}
			else 
			{
				bool bHasExt = false;
				AcDbExtents ext;

				//modify by zjq on 100520 优化求包围盒算法
				if (pZone != NULL)
				{
					if (pZone->getGeomExtents(pEntity->objectId(),ext))
					{
						bHasExt = true;
					}
				}

				if (bHasExt)
				{
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					{
					}
					else 
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else
				{
					if ( pEntity->getGeomExtents(ext) == Acad::eOk)
					{
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);

						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						{
						}
						else 
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());
							ss += ent;
							esRet = Acad::eOk;
						}
					}
				}
			}
		}	
	}
	delete pBlockIterator;
	return esRet;
}

Acad::ErrorStatus XExport::GetSafeSelectionEx(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
												const XPoint &ptUp, const AcRxClass *pClass)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}

    Acad::ErrorStatus esRet = Acad::eNotApplicable;
    XBlockTableRecPtr objMSpace;
    if (!objMSpace)
	{
        return esRet;
	}

    XPoint ptMid;
    Midpoint(ptLow, ptUp, ptMid);
    XRectAngle rect(ptLow, ptUp);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk) continue;
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible)
		{
           continue;
        }
		if (!pClass ||  pEntity->isKindOf(pClass)) 
		{
            if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc()))
			{ //用于加速目的，光标移动时自动捕捉时使用
                AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
                XPoint ptCurve; 
                if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
                    ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y)
				{
                    Entity ent;
                    VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
                    ss += ent;
                    esRet = Acad::eOk;
                }
            } 
			else 
			{
				bool bHasExt = false;
				AcDbExtents ext;
				
				//modify by zjq on 100520 优化求包围盒算法
				if (pZone != NULL)
				{
					if (pZone->getGeomExtents(pEntity->objectId(),ext) )
					{
						bHasExt = true;
					}
				}

				if (bHasExt)
				{
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					{
					} 
					else
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else
				{
					if (pEntity->getGeomExtents(ext) == Acad::eOk)
					{
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);

						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						{
						} 
						else
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());
							ss += ent;
							esRet = Acad::eOk;
						}
					}
                }
            }
        }
    }
   delete pBlockIterator;
   return esRet;
}

Acad::ErrorStatus XExport::GetSafeSelectionEx(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
												const XPoint &ptUp, const AcRxClass *pClass,AcDbObjectId idBlock)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}

    Acad::ErrorStatus esRet = Acad::eNotApplicable;
    XBlockTableRecPtr objMSpace(idBlock);
    if (!objMSpace)
        return esRet;

    XPoint ptMid;
    Midpoint(ptLow, ptUp, ptMid);
    XRectAngle rect(ptLow, ptUp);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk) continue;
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            continue;
        }
		if (!pClass ||  pEntity->isKindOf(pClass)) 
		{
            if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
			{ //用于加速目的，光标移动时自动捕捉时使用
                AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
                XPoint ptCurve; 
                if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
                    ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
				{
                    Entity ent;
                    VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
                    ss += ent;
                    esRet = Acad::eOk;
                }
            } 
			else 
			{
				bool bHasExt = false;
				AcDbExtents ext;

				//modify by zjq on 100520 优化求包围盒算法
				if (pZone != NULL)
				{
					if (pZone->getGeomExtents(pEntity->objectId(),ext))
					{
						bHasExt = true;
					}
				}
				
				if (bHasExt)
				{
					//加速2003/9/12
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					{
					} 
					else
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else
				{
					if (pEntity->getGeomExtents(ext) == Acad::eOk)
					{ 
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);

						//加速2003/9/12
						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						{
						} 
						else
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());
							ss += ent;
							esRet = Acad::eOk;
						}
					}
				}
            }
        }
    }
   delete pBlockIterator;
   return esRet;
}

// 确保点在屏幕之内
Acad::ErrorStatus XExport::AssureInCurrentView(const XPoint &ptLow, const XPoint &ptUp)
{
    XPoint lowCorner, upCorner;
    AT_ScrCorner(lowCorner, upCorner);
    XPoint pt1 = ptLow, pt2 = ptUp;
    pt1.z = pt2.z = lowCorner.z;
    XPoint ptMin = Min(pt1, lowCorner), ptMax = Max(pt2, upCorner);
    Acad::ErrorStatus es = Acad::eNotApplicable;

    if (ptMin != lowCorner || ptMax != upCorner)  
	{ //点不在屏幕当前视图之内
        if (fabs(ptUp.x-ptLow.x) < fabs(upCorner.x-lowCorner.x) &&
            fabs(ptUp.y-ptLow.y) < fabs(upCorner.y-lowCorner.y)) 
		{ 
            //目标矩形的尺寸小于当前视图的尺寸, 用PAN的方式
            XPoint ptFrom, ptTo;
            Midpoint(lowCorner, upCorner, ptFrom);
            Midpoint(ptLow, ptUp, ptTo);
            XPoint vtPan = ptTo-ptFrom;
            es = arxPan(vtPan);
        } 
		else 
		{
			XPoint ptCen;
			Midpoint(ptLow, ptUp, ptCen);
			es = arxZoomTo(ptCen, ptUp.x-ptLow.x, ptUp.y-ptLow.y);
        }
    }
    return es;
}

Acad::ErrorStatus XExport::GetSafeSelection(PickSet &ss,  const XPoint &ptLow, const XPoint &ptUp,
								   std::list<AcRxClass*> &lstClass, AcDbObjectId idLayer)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}

    Acad::ErrorStatus esRet = Acad::eNotApplicable;
    XBlockTableRecPtr objMSpace;
    if (!objMSpace)
	{
        return esRet;
	}

    XPoint ptMid;
    Midpoint(ptLow, ptUp, ptMid);
    XRectAngle rect(ptLow, ptUp);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk) continue;
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体zjq
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            continue;
        }
		if (!!idLayer)
		{
			AcDbObjectId idLay = pEntity->layerId();
			if (idLayer != idLay)
			{
				continue;
			}
		}
        AcRxClass *pRxInfo = pEntity->isA();

        //if (lstClass.FindNode(pRxInfo, CompareAcRxClass)) 
		if (std::find(lstClass.begin(),lstClass.end(),pRxInfo) != lstClass.end() )
		{
            if (pEntity->isKindOf(AcDbCurve::desc())) 
			{ //用于加速目的，光标移动时自动捕捉时使用
                AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
                XPoint ptCurve; 
                if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
                    ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
				{
                    Entity ent;
                    VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
                    ss += ent;
                    esRet = Acad::eOk;
                }
            } 
			else
			{
				bool bHasExt = false;
				AcDbExtents ext;

				//modify by zjq on 100520 优化求包围盒算法
				if (pZone != NULL)
				{
					if (pZone->getGeomExtents(pEntity->objectId(),ext))
					{
						bHasExt = true;
					}
				}

				if (bHasExt)
				{
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					{
					} 
					else 
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else
				{
					if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					{
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);

						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						{
						} 
						else 
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());
							ss += ent;
							esRet = Acad::eOk;
						}
					}
				}
            }
        }
    }
   delete pBlockIterator;
   return esRet;
}

BOOL XExport::MakeDir(const TCHAR *pDir)
{
	XString sDir(pDir);
	TCHAR *p = sDir;
	while(p = _tcschr(p, _T('\\'))) 
	{
		*p = 0;
		if (_tmkdir(sDir) != 0) 
		{
			if (errno == ENOENT)
			{
				return FALSE;
			}
		}
		*p = _T('\\');
		p++;
	}
	return TRUE;
}

Acad::ErrorStatus XExport::GetEntFromBlockByClass(DList<AcDbObjectId> &lstObjects, AcRxClass *pClass,
													int nCmpMethod, AcDbObjectId idBlock,LPVOID pReserve)
{
    XBlockTableRecPtr objMSpace(idBlock);
    if (!objMSpace)
	{
        return Acad::eNotApplicable;
	}

	bool bLookUpExt = false;
	AcDbExtents ext,ext2;
	if (pReserve != NULL)
	{
		typedef CMap<LONG_PTR,LONG_PTR,AcDbExtents,AcDbExtents> CMapLongToExtents;
		CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
		if (pMap->Lookup(idBlock.asOldId(),ext))
		{
			bLookUpExt = true;
		}
	}
	
    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	
    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);
		
        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
			continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (pRxInfo == pClass)
			{
				if (bLookUpExt)
				{
					if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
					{
						XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
							ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
						{
						}
						else 
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				}
				else
				{
					lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
				}
			}
        }
		else 
		{
            if (pEntity->isKindOf(pClass))
			{
				if (bLookUpExt)
				{
					if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
					{
						XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
							ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
						{
						}
						else 
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				}
				else
				{
					lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
				}
			}
        }
	}
	delete pBlockIterator;
	return Acad::eOk;
}

Acad::ErrorStatus XExport::GetEntFromBlockByClass(DList<AcDbObjectId> &lstObjects, AcRxClass *pClass, 
													int nCmpMethod, const TCHAR *pszBlk,LPVOID pReserve)
{
    XBlockTableRecPtr objMSpace(pszBlk);
    if (!objMSpace)
	{
        return Acad::eNotApplicable;
	}

	bool bLookUpExt = false;
	AcDbExtents ext,ext2;
	if (pReserve != NULL)
	{
		typedef CMap<LONG_PTR,LONG_PTR,AcDbExtents,AcDbExtents> CMapLongToExtents;
		CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
		if (pMap->Lookup(objMSpace.m_pBlockTableRec->objectId().asOldId(),ext))
		{
			bLookUpExt = true;
		}
	}

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
           continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (pRxInfo == pClass)
			{
				if (bLookUpExt)
				{
					if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
					{
						XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
							ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
						{
						}
						else 
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				}
				else
				{
					lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
				}
			}
        }
		else 
		{
            if (pEntity->isKindOf(pClass))
			{
				if (bLookUpExt)
				{
					if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
					{
						XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
							ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
						{
						}
						else 
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				}
				else
				{
					lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
				}
			}
        }
   }
   delete pBlockIterator;
   return Acad::eOk;
}


CView *XExport::GetCurDwgView()
{
    if (g_nAcadVer>15.0001)
	{
        return acedGetAcadDwgView();
	}
	
    CDocument *pDoc = curDoc()->cDoc();
    if (!pDoc)
	{
        return NULL;
	}
    POSITION pos = pDoc->GetFirstViewPosition();
    if (!pos)
	{
        return NULL;
	}
    CView *pView = pDoc->GetNextView(pos);
    return pView;
}

// 判断是否是DwgView窗口
// 在OpenGL加速窗口下，窗口类名称是CTempWnd
BOOL XExport::IsAcadDwgView(HWND hwnd)
{
	if (acedGetAcadDwgView() == NULL)
		return FALSE;

	if ( acedGetAcadDwgView()->m_hWnd == hwnd)
	{
		return TRUE;
	}
    CWnd *pFromWnd = CWnd::FromHandle(hwnd);
    CRuntimeClass *pClassInfo = pFromWnd->GetRuntimeClass();
   
	ASSERT(pFromWnd && pClassInfo);
    
	const char *pClassName = pClassInfo->m_lpszClassName;
	BOOL bTrue = FALSE;
	TCHAR szClassName[256] = _T("");
    if (pClassName) 
	{
		if(strcmp(pClassName, "CDwgView") == 0)
		{
			bTrue = TRUE;
		}
#if (ARX>15)
		else if(GetClassName(hwnd, szClassName, 255))
		{
			if(_tcscmp(szClassName, _T("GsTransparentWindow")) == 0)  
			{ //OpenGL透视图
				return TRUE;
			}
#else
		else if(_tcscmp(pClassName, _T("CTempWnd")) == 0) 
		{
			CWnd *pParent = pFromWnd->GetParent();
			if(pParent) 
			{
				CRuntimeClass *pClass = pParent->GetRuntimeClass();
				if(pClass && pClass->m_lpszClassName && _tcsicmp(pClass->m_lpszClassName, _T("CTempWnd")) == 0)
				{
					bTrue = TRUE;
				}
			}
#endif
		}	
	}	

	return bTrue;
}
	
BOOL XExport::IsCurDwgView(HWND hwnd)
{
	CView *pView = GetCurDwgView();
	if (!pView)
	{
		return FALSE;
	}
	if (hwnd == pView->m_hWnd)
	{
		return TRUE;
	}
	TCHAR szClassName[256] = _T("");
	if (GetClassName(hwnd, szClassName, 255))
	{ //OpenGL透视图
		if (_tcscmp(szClassName, _T("GsTransparentWindow")) == 0)
		{
			return TRUE;
		}
	}
	return FALSE;
}

void XExport::PostCommand(const TCHAR *pszCmd, bool bEcho)
{
	acDocManager->sendStringToExecute(curDoc(), pszCmd, true, false, bEcho);
}

XString XExport::GetSymbolName(AcDbObjectId idSymbolRec)
{
    XString sName;
    OPENOBJ_BEGIN(idSymbolRec, AcDb::kForRead, AcDbSymbolTableRecord, pStyleRec);
    if (pStyleRec) 
	{
        const TCHAR *pszName = NULL;
        pStyleRec->getName(pszName);
        if (pszName)
		{
            sName = pszName;
		}
    }
    OPENOBJ_END();
    return sName;
}

XString XExport::GetTempSymbolName(const TCHAR *symb)
{
    XString sName;
    int i = 0;
    do 
	{
        sName[0] = EOS;
        sName << _T("TMP");
        sName<<i;
        i++;
    } while(!!XSymbolTable(symb, sName));

    return sName;
}

XString XExport::GetTempSymbolName(const TCHAR *symb, const TCHAR *prefix)
{
    XString sName;
    int i = 0;
    do 
	{
        sName[0] = EOS;
        sName << prefix;
        sName<<i;
        i++;
    } while(!!XSymbolTable(symb, sName));

    return sName;
}

XString XExport::GetTempFileName(const TCHAR *pExt)
{
    ASSERT(pExt);
    XString sPath(256), sFullPath(256);
    GetTempPath(255, sPath);
    int i = 1;
    do 
	{
        sFullPath[0] = EOS;
        sFullPath << sPath << _T("tmp") << i << pExt;
        i++;
    } while(FindFile(sFullPath));

    return sFullPath;
}

BOOL XExport::GetWcsCursor(XPoint &ptLoc) 
{
    CPoint ptCursor;
    if (GetCursorPos(&ptCursor)) 
	{
        acedGetAcadDwgView()->ScreenToClient(&ptCursor);
        int nCurVp = 0;
        VERIFY(xg_getvar(_T("CVPORT"), &nCurVp) == RTNORM);
        BOOL bRetCode = acedCoordFromPixelToWorld(nCurVp, ptCursor, ptLoc);
        return bRetCode;
    }
    return FALSE;
}

int XExport::ExpInsertDwg(const TCHAR *pszDwg, XPoint ptInsert)
{
    AcDbDatabase db(false, true);
#if ARX >= 21
	if (db.readDwgFile(pszDwg, AcDbDatabase::kForReadAndAllShare) != Acad::eOk)
#else
	if (db.readDwgFile(pszDwg, _SH_DENYNO) != Acad::eOk)
#endif
	{
        return RTERROR;
	}
    XPoint ptOrg = db.insbase();
    ads_matrix mat;
    ptOrg.GetMoveMatrix(ptInsert, mat);

    if (acdbCurDwg()->insert(AsAcGeMatrix3d(mat), &db, Adesk::kFalse) != Acad::eOk)
	{
        return RTERROR;
	}
    return RTNORM;
}

int XExport::ExpInsertDwg0(const TCHAR* pszDwg,XPoint ptBase,XPoint ptMin,XPoint ptMax,XPoint ptInsert)
{
    AcDbDatabase db(false, true);
#if ARX >= 21
	if (db.readDwgFile(pszDwg, AcDbDatabase::kForReadAndAllShare) != Acad::eOk)
#else
	if (db.readDwgFile(pszDwg, _SH_DENYNO) != Acad::eOk)
#endif
	{
        return RTERROR;
	}

	DList<AcDbObjectId> idList;
	GetEntityFromDatabase(idList,db,ACDB_MODEL_SPACE,ptMin,ptMax);
	if (idList.Length() <= 0)
	{
		return RTNORM;
	}

	AcDbObjectIdArray idArray;
	idArray.setLogicalLength(idList.Length());
	for (long i = 0; i < idList.Length();i++)
	{
		idArray[i] = *idList[i]; 
	}

	AcDbDatabase* pDbTemp = NULL;
	Acad::ErrorStatus es = db.wblock(pDbTemp,idArray,ptBase);//有的图第二次失败！
	if (es != Acad::eOk || pDbTemp == NULL)
	{
		return RTERROR;
	}

    ads_matrix mat;
    ptBase.GetMoveMatrix(ptInsert, mat);

    if (acdbCurDwg()->insert(AsAcGeMatrix3d(mat), pDbTemp, Adesk::kFalse) != Acad::eOk)
	{
		delete pDbTemp;
		return RTERROR;
	}
	delete pDbTemp;
	return RTNORM;
}

//删除模型空间包围盒外的内容
Acad::ErrorStatus XExport::EraseEntityFromDatabase(AcDbDatabase &db,XPoint ptMin,XPoint ptMax)
{
    AcDbBlockTable *pBlockTable = NULL;
    Acad::ErrorStatus es = db.getBlockTable(pBlockTable, AcDb::kForRead);
    if (!pBlockTable) 
	{
		return es;
	}
    ASSERT(es == Acad::eOk);
	
    AcDbBlockTableRecord *pBlockTableRec = NULL;
    es = pBlockTable->getAt(ACDB_MODEL_SPACE, pBlockTableRec, AcDb::kForRead);
    pBlockTable->close();
	
    if (!pBlockTableRec)
	{
        return es;
	}
    ASSERT(pBlockTableRec);
	
    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    es = pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	
    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step())
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);
		
        XDbObject vTemp(pEntity);
		
		AcDbExtents ext;
		if (pEntity->getGeomExtents(ext) != Acad::eOk ||
			ext.minPoint().x < ptMin.x - 1E-6 ||
			ext.minPoint().y < ptMin.y - 1E-6 ||
			ext.maxPoint().x > ptMax.x + 1E-6 ||
			ext.maxPoint().y > ptMax.y + 1E-6)
		{
			if (pEntity->upgradeOpen() == Acad::eOk)
			{
				pEntity->erase();
			}
		}
    }
	delete pBlockIterator;
	
	pBlockTableRec->close();
	return Acad::eOk;
}

int XExport::ExpInsertDwg(const TCHAR *pszDwg,XPoint ptBase,XPoint ptMin,XPoint ptMax,XPoint ptInsert)
{
    AcDbDatabase db(false, true);
#if ARX >= 21
	if (db.readDwgFile(pszDwg, AcDbDatabase::kForReadAndAllShare) != Acad::eOk)
#else
	if (db.readDwgFile(pszDwg, _SH_DENYNO) != Acad::eOk)
#endif
	{
        return RTERROR;
	}

	EraseEntityFromDatabase(db,ptMin,ptMax);

    ads_matrix mat;
    ptBase.GetMoveMatrix(ptInsert, mat);

    if (acdbCurDwg()->insert(AsAcGeMatrix3d(mat), &db, Adesk::kFalse) != Acad::eOk)
	{
        return RTERROR;
	}
    return RTNORM;
}

BOOL XExport::IsKeyPressed(int vk)
{
    SHORT nState = GetKeyState(vk);
    return ((nState&256) != 0);
}

void XExport::MakeVisible(PickSet &ss, bool bTrue)
{
	long len = ss.Length();
	for (long i = 0;i<len;i++)		   
	{
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
        if (pEnt)
		{
			pEnt->setVisibility(bTrue ? AcDb::kVisible : AcDb::kInvisible);
		}
        OPENOBJ_END();
	}
}

AcDbObjectId XExport::AddLayer(AcDbLayerTableRecord *pLay, BOOL bDoneClosed, AcDbDatabase *pDb)
{
    AcDbDatabase *pCurDwg = pDb ? pDb : acdbCurDwg();
    AcDbLayerTable *pVPTable = NULL;
    AcDbObjectId id;
    if (pCurDwg->getSymbolTable(pVPTable, AcDb::kForWrite) == Acad::eOk)
	{
		Acad::ErrorStatus es = pVPTable->add(id, pLay);
		pVPTable->close();
		if (es == Acad::eOk && bDoneClosed)
		{
			pLay->close();
		}
	}
    return id;
}


BOOL XExport::IsValidPath(const TCHAR *szPath)
{
    XString csGatherLoc = szPath;
    int nStrLen = _tcslen(csGatherLoc);
    if (!nStrLen)
	{
        return FALSE;
	}
    if (csGatherLoc[nStrLen-1] == _T('\\'))
	{
        csGatherLoc[nStrLen-1] = 0;
	}
	return FindFile(csGatherLoc); 
}

BOOL XExport::AsStdPath(XString &sPath)
{
	XString csPath(256);
	csPath << sPath;
    if (!IsValidPath(csPath))
	{
        return FALSE;
	}
    int nLen = _tcslen(csPath);
    if (csPath[nLen-1] != _T('\\'))
	{
        csPath << _T("\\");
	}
	sPath = csPath;
    return TRUE;
}

BOOL XExport::arxWBlock(PickSet &ss, const TCHAR* szFileName, XPoint ptIns)
{
	AcDbObjectIdArray cloneSet;
 
	long len = ss.Length();
	for (long i = 0;i<len;i++)
	{
		Entity ent = ss[i];
		AcDbObjectId id;
		acdbGetObjectId(id, ent);
		cloneSet.append(id);
	}
	AcDbDatabase db;
	AcDbObjectId idMSpace = db.currentSpaceId();
	AcDbIdMapping idMap;
	acdbCurDwg()->wblockCloneObjects(cloneSet, idMSpace, idMap, AcDb::kDrcIgnore, false);
	AcDbBlockTable *pTable = NULL;
	db.getBlockTable(pTable, AcDb::kForRead);
	if (!pTable)
	{
		return FALSE;
	}

	AcGeMatrix3d mat;
	mat.setToTranslation(AcGeVector3d(-ptIns[0], -ptIns[1], -ptIns[2]));
	AcDbBlockTableRecord *pBlockTableRecord = NULL;
	VERIFY(pTable->getAt(ACDB_MODEL_SPACE, pBlockTableRecord,AcDb::kForRead) == Acad::eOk);
	pTable->close();
	if (!pBlockTableRecord)
	{
		return FALSE;
	}
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;

	pBlockTableRecord->newIterator(pBlockIterator);
	if (!pBlockIterator)
	{
		pBlockTableRecord->close();
		return FALSE;
	}
	for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) 
	{
		AcDbEntity *pEnt = NULL;
		pBlockIterator->getEntity(pEnt,AcDb::kForWrite);
		if (pEnt)
		{
			pEnt->transformBy(mat);
			pEnt->close();
		}
	}
	delete pBlockIterator;
	pBlockTableRecord->close();
#if (ARX>15)
	return (acdbSaveAs2000(&db, szFileName) == Acad::eOk);
#else
	return (db.saveAs(szFileName) == Acad::eOk);
#endif
}

BOOL XExport::IsModelSpace(AcDbObjectId idBlock)
{
	const TCHAR* sName = NULL;
	AcDbBlockTableRecord *pRecord = NULL;
	acdbOpenObject(pRecord,idBlock,AcDb::kForRead);
	if (pRecord != NULL)
	{
		pRecord->getName(sName);
		pRecord->close();
	}

	if (sName == NULL)
	{
		return FALSE;
	}

	return _tcsicmp(sName,ACDB_MODEL_SPACE) == 0;
}

#ifdef _REF_EDIT_PATCH
AcDbLongTransWorkSetIterator* XExport::GetCurrentWorkSet()
{
	AcDbLongTransWorkSetIterator *pIter = NULL;
	AcApDocument *pCurDoc = curDoc();
	if (pCurDoc == NULL)
	{
		return pIter;
	}

	AcDbObjectId idLT = acapLongTransactionManagerPtr()->currentLongTransactionFor (pCurDoc);
	AcDbLongTransaction *pLT = NULL;
	acdbOpenObject(pLT,idLT,AcDb::kForRead);
	if (pLT != NULL)
	{
		pLT->newWorkSetIterator(pIter);
		pLT->close();
	}

	return pIter;
}

BOOL XExport::WorkSetHas(AcDbObjectId idEnt)
{
	AcDbLongTransWorkSetIterator *pIter = NULL;
	AcApDocument *pCurDoc = curDoc();
	if (pCurDoc == NULL)
	{
		return FALSE;
	}

	AcDbObjectId idLT = acapLongTransactionManagerPtr()->currentLongTransactionFor (pCurDoc);
	AcDbLongTransaction *pLT = NULL;
	acdbOpenObject(pLT,idLT,AcDb::kForRead);
	if (pLT != NULL)
	{
		BOOL bRet = pLT->workSetHas(idEnt);
		pLT->close();

		return bRet;
	}
	else
	{
		return TRUE;
	}
}
#endif //#ifdef _REF_EDIT_PATCH

Acad::ErrorStatus XExport::GetSafeSelection2(PickSet &ss, BOOL bCrossing, const XPoint &ptLow,
											   const XPoint &ptUp, const AcRxClass *pClass)
{
#ifdef _REF_EDIT_PATCH
	AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
	if (pBlockIterator != NULL)//当前工作集存在
	{
	    Acad::ErrorStatus esRet = Acad::eNotApplicable;

		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idMSpace = mspace.m_pBlockTableRec->objectId();
			mspace.Close();
		}

		XPoint ptMid;
		Midpoint(ptLow, ptUp, ptMid);
		XRectAngle rect(ptLow, ptUp);

		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
		{
			AcDbEntity *pEntity = NULL;
			acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
			if (pEntity == NULL)
			{
				continue;
			}

			XDbObject vTemp(pEntity);

			//防止有非模型空间的的混入                                                                         
			if (pEntity->ownerId() != idMSpace)
			{
				continue;
			}
			        
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) 
			{
				continue;
			}

			AcRxClass *pRxInfo = pEntity->isA();

			if (!pClass ||  pRxInfo == pClass) 
			{
				if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
				{ //用于加速目的，光标移动时自动捕捉时使用
					AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
					XPoint ptCurve; 
					if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk   && 
						ptCurve.x > rect.lowLeft.x && ptCurve.x < rect.upRight.x &&
						ptCurve.y > rect.lowLeft.y && ptCurve.y < rect.upRight.y) 
					{
						Entity ent;
						VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else
				{
				   AcDbExtents ext;
				   if (pEntity->getGeomExtents(ext) == Acad::eOk) { //加速2003/9/12
					   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					   ptExtMin.z = ptExtMax.z = 0;
					   if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					   {
					   }
					   else 
					   {
						   Entity ent;
						   acdbGetAdsName(ent.name, pEntity->objectId());
						   ss += ent;
						   esRet = Acad::eOk;
					   }
					}
				}
			}
		}

		delete pBlockIterator;
		return esRet;
	}
#endif //#ifdef _REF_EDIT_PATCH
	return XExport::GetSafeSelection(ss, bCrossing, ptLow, ptUp,pClass);
}

Acad::ErrorStatus XExport::GetSafeSelection2(PickSet &ss, BOOL bCrossing, const XPoint &ptLow,
											   const XPoint &ptUp, const AcRxClass *pClass,AcDbObjectId idBlock)
{
#ifdef _REF_EDIT_PATCH
	if (IsModelSpace(idBlock))
	{
		AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
		if (pBlockIterator != NULL)//当前工作集存在
		{
			Acad::ErrorStatus esRet = Acad::eNotApplicable;

			XPoint ptMid;
			Midpoint(ptLow, ptUp, ptMid);
			XRectAngle rect(ptLow, ptUp);

			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
				if (pEntity == NULL)
				{
					continue;
				}

				XDbObject vTemp(pEntity);

				//防止有非模型空间的的混入                                                                         
				if (pEntity->ownerId() != idBlock)
				{
					continue;
				}
				        
				//不处理不可见的实体
				if (pEntity->visibility() == AcDb::kInvisible) 
				{
					continue;
				}

				AcRxClass *pRxInfo = pEntity->isA();

				if (!pClass ||  pRxInfo == pClass)
				{
					if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc()))
					{ //用于加速目的，光标移动时自动捕捉时使用
						AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
						XPoint ptCurve; 
						if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
							ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
							ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y)
						{
							Entity ent;
							VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
							ss += ent;
							esRet = Acad::eOk;
						}
					} 
					else 
					{
					   AcDbExtents ext;
					   if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					   {
						   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						   ptExtMin.z = ptExtMax.z = 0;
						   if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y)
						   {
						   }
						   else 
						   {
							   Entity ent;
							   acdbGetAdsName(ent.name, pEntity->objectId());
							   ss += ent;
							   esRet = Acad::eOk;
						   }
						}
					}
				}
			}

			delete pBlockIterator;
			return esRet;
		}
	}
#endif#ifdef _REF_EDIT_PATCH

	return XExport::GetSafeSelection(ss, bCrossing, ptLow, ptUp,pClass,idBlock);
}

Acad::ErrorStatus XExport::GetSafeSelectionEx2(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, const XPoint &ptUp,
												 const AcRxClass *pClass)
{
#ifdef _REF_EDIT_PATCH
	AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
	if (pBlockIterator != NULL)//当前工作集存在
	{
	    Acad::ErrorStatus esRet = Acad::eNotApplicable;

		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idMSpace = mspace.m_pBlockTableRec->objectId();
			mspace.Close();
		}

		XPoint ptMid;
		Midpoint(ptLow, ptUp, ptMid);
		XRectAngle rect(ptLow, ptUp);

		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
		{
			AcDbEntity *pEntity = NULL;
			acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
			if (pEntity == NULL)
			{
				continue;
			}

			XDbObject vTemp(pEntity);

			//防止有非模型空间的的混入                                                                         
			if (pEntity->ownerId() != idMSpace)
			{
				continue;
			}
			        
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) 
			{
				continue;
			}

			if (!pClass ||  pEntity->isKindOf(pClass)) 
			{
				if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
				{ //用于加速目的，光标移动时自动捕捉时使用
					AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
					XPoint ptCurve; 
					if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
						ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
						ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y)
					{
						Entity ent;
						VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
						ss += ent;
						esRet = Acad::eOk;
					}
				}
				else 
				{
				   AcDbExtents ext;
				   if (pEntity->getGeomExtents(ext) == Acad::eOk) 
				   { 
					   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					   ptExtMin.z = ptExtMax.z = 0;

					   if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					   {
					   }
					   else
					   {
						   Entity ent;
						   acdbGetAdsName(ent.name, pEntity->objectId());
						   ss += ent;
						   esRet = Acad::eOk;
					   }
					}
				}
			}
		}

		delete pBlockIterator;
		return esRet;
	}
#endif//#ifdef _REF_EDIT_PATCH

	return XExport::GetSafeSelectionEx(ss, bCrossing, ptLow, ptUp,pClass);
}

Acad::ErrorStatus XExport::GetSafeSelectionEx2(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
												 const XPoint &ptUp, const AcRxClass *pClass,AcDbObjectId idBlock)
{
#ifdef _REF_EDIT_PATCH
	if (IsModelSpace(idBlock))
	{
		AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
		if (pBlockIterator != NULL)//当前工作集存在
		{
			Acad::ErrorStatus esRet = Acad::eNotApplicable;

			XPoint ptMid;
			Midpoint(ptLow, ptUp, ptMid);
			XRectAngle rect(ptLow, ptUp);

			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
				if (pEntity == NULL)
					continue;

				XDbObject vTemp(pEntity);

				//防止有非模型空间的的混入                                                                         
				if (pEntity->ownerId() != idBlock)
				{
					continue;
				}
				        
				//不处理不可见的实体
				if (pEntity->visibility() == AcDb::kInvisible) 
				{
					continue;
				}

				if (!pClass ||  pEntity->isKindOf(pClass)) 
				{
					if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
					{ //用于加速目的，光标移动时自动捕捉时使用
						AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
						XPoint ptCurve; 
						if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
							ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
							ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
						{
							Entity ent;
							VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
							ss += ent;
							esRet = Acad::eOk;
						}
					}
					else
					{
					   AcDbExtents ext;
					   if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					   {
						   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						   ptExtMin.z = ptExtMax.z = 0;
						   if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						   {
						   }
						   else 
						   {
							   Entity ent;
							   acdbGetAdsName(ent.name, pEntity->objectId());
							   ss += ent;
							   esRet = Acad::eOk;
						   }
						}
					}
				}
			}

			delete pBlockIterator;
			return esRet;
		}
	}
#endif//#ifdef _REF_EDIT_PATCH

	return XExport::GetSafeSelectionEx(ss, bCrossing, ptLow, ptUp,pClass,idBlock);
}

// 安全模式开窗口搜索选择集
// 目前只验证过"C"方式
// bCrossing  :  FALSE-对曲线加速
Acad::ErrorStatus XExport::GetSafeSelection2(PickSet &ss,  const XPoint &ptLow, const XPoint &ptUp,
									std::list<AcRxClass*> &lstClass, AcDbObjectId idLayer)
{
#ifdef _REF_EDIT_PATCH
	AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
	if (pBlockIterator != NULL)//当前工作集存在
	{
	    Acad::ErrorStatus esRet = Acad::eNotApplicable;

		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idMSpace = mspace.m_pBlockTableRec->objectId();
			mspace.Close();
		}

		XPoint ptMid;
		Midpoint(ptLow, ptUp, ptMid);
		XRectAngle rect(ptLow, ptUp);

		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
		{
			AcDbEntity *pEntity = NULL;
			acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
			if (pEntity == NULL)
			{
				continue;
			}

			XDbObject vTemp(pEntity);

			//防止有非模型空间的的混入                                                                         
			if (pEntity->ownerId() != idMSpace)
			{
				continue;
			}
			        
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) 
			{
				continue;
			}

			if (!!idLayer) 
			{
				AcDbObjectId idLay = pEntity->layerId();
				if (idLayer != idLay)
				{
					continue;
				}
			}
			AcRxClass *pRxInfo = pEntity->isA();

			//if (lstClass.FindNode(pRxInfo, CompareAcRxClass)) 
			if (std::find(lstClass.begin(),lstClass.end(),pRxInfo) != lstClass.end())
			{
				if (pEntity->isKindOf(AcDbCurve::desc()))
				{ //用于加速目的，光标移动时自动捕捉时使用
					AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
					XPoint ptCurve; 
					if (pCurve->getClosestPointTo(ptMid, ptCurve) == Acad::eOk && 
						ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
						ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) 
					{
						Entity ent;
						VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
						ss += ent;
						esRet = Acad::eOk;
					}
				} 
				else
				{
				   AcDbExtents ext;
					if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					{
					   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					   ptExtMin.z = ptExtMax.z = 0;
					   if (ptUp.x<ptExtMin.x ||
						   ptUp.y<ptExtMin.y ||
						   ptLow.x>ptExtMax.x ||
						   ptLow.y>ptExtMax.y) 
					   {
					   } 
					   else
					   {
						   Entity ent;
						   acdbGetAdsName(ent.name, pEntity->objectId());
						   ss += ent;
						   esRet = Acad::eOk;
					   }
					}
				}
			}
		}

		delete pBlockIterator;
		return esRet;
	}
#endif//#ifdef _REF_EDIT_PATCH

	return XExport::GetSafeSelection(ss, ptLow, ptUp,lstClass,idLayer);
}

// nCmpMethod: 0--use equal;  1--Use isKindOf
Acad::ErrorStatus XExport::GetEntFromBlockByClass2(DList<AcDbObjectId> &lstObjects,AcRxClass *pClass,
													 int nCmpMethod, AcDbObjectId idBlock,LPVOID pReserve)
{
#ifdef _REF_EDIT_PATCH
 	if (IsModelSpace(idBlock))
	{
		bool bLookUpExt = false;
		AcDbExtents ext,ext2;
		if (pReserve != NULL)
		{
			typedef CMap<LONG_PTR,LONG_PTR,AcDbExtents,AcDbExtents> CMapLongToExtents;
			CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
			if (pMap->Lookup(idBlock.asOldId(),ext))
			{
				bLookUpExt = true;
			}
		}

		AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
		if (pBlockIterator != NULL)//当前工作集存在
		{
			Acad::ErrorStatus esRet = Acad::eNotApplicable;

			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
				if (pEntity == NULL)
				{
					continue;
				}

				XDbObject vTemp(pEntity);

				//防止有非模型空间的的混入                                                                         
				if (pEntity->ownerId() != idBlock)
				{
					continue;
				}
				        
				//不处理不可见的实体
				if (pEntity->visibility() == AcDb::kInvisible) 
				{
					continue;
				}

				AcRxClass *pRxInfo = pEntity->isA();
				if (nCmpMethod == 0) 
				{
					if (pRxInfo == pClass)
					{
						if (bLookUpExt)
						{
							if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
							{
								XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
								ptExtMin.z = ptExtMax.z = 0;
								if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
									ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
								{
								}
								else 
								{
									lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
								}
							}
						}
						else
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				} 
				else 
				{
					if (pEntity->isKindOf(pClass))
					{
						if (bLookUpExt)
						{
							if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
							{
								XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
								ptExtMin.z = ptExtMax.z = 0;
								if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
									ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
								{
								}
								else 
								{
									lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
								}
							}
						}
						else
						{
							lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
						}
					}
				}
			}

			delete pBlockIterator;
			return esRet;
		}
	}
#endif//#ifdef _REF_EDIT_PATCH

	return XExport::GetEntFromBlockByClass(lstObjects,pClass,nCmpMethod,idBlock,pReserve);
}

//得到块内可见对象
void XExport::GetVisibleEnts(AcDbObjectIdArray &idArray,AcDbObjectId idBlock,bool bAEntityBaseCast,LPVOID pReserve)
{
	bool bLookUpExt = false;
	AcDbExtents ext,ext2;
	if (pReserve != NULL)
	{
		typedef CMap<LONG_PTR,LONG_PTR,AcDbExtents,AcDbExtents> CMapLongToExtents;
		CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
		if (pMap->Lookup(idBlock.asOldId(),ext))
		{
			bLookUpExt = true;
		}
	}
	
	AEntityBase* pEntBase = NULL;
#ifdef _REF_EDIT_PATCH
	if (idBlock.isNull()||IsModelSpace(idBlock))
	{
		AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
		if (pBlockIterator != NULL)//当前工作集存在
		{
			if (idBlock.isNull())
			{
				XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
				AcDbObjectId idMSpace;
				if (mspace.m_pBlockTableRec != NULL)
				{
					idBlock = mspace.m_pBlockTableRec->objectId();
				}
			}

			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
				if (pEntity != NULL)
				{                                                                        
					if (bAEntityBaseCast)
					{
						pEntBase = AEntityBase::Cast(pEntity);
						if (pEntBase == NULL)
						{
							pEntity->close();
							continue;
						}
					}
					if (pEntity->ownerId() == idBlock&&//防止有非模型空间的的混入 
					   pEntity->visibility() == AcDb::kVisible)
					{

						if (bLookUpExt)
						{
							if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
							{
								XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
								ptExtMin.z = ptExtMax.z = 0;
								if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
									ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
								{
								}
								else 
								{
									idArray.append(pEntity->objectId());
								}
							}
						}
						else
						{
							idArray.append(pEntity->objectId());
						}
					}

					pEntity->close();
				}
			}

			delete pBlockIterator;
			return;
		}
	}
#endif //#ifdef _REF_EDIT_PATCH

	if (idBlock.isNull())
	{
		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idBlock = mspace.m_pBlockTableRec->objectId();
		}
	}

	Acad::ErrorStatus es;
	AcDbBlockTableRecord *pRecord = NULL;
	acdbOpenObject(pRecord,idBlock,AcDb::kForRead);
	if (pRecord != NULL)
	{
		AcDbBlockTableRecordIterator*pBlockIterator = NULL;
		pRecord->newIterator(pBlockIterator);
		pRecord->close();

		if (pBlockIterator != NULL)
		{
			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				es = pBlockIterator->getEntity(pEntity,AcDb::kForRead);


				if (pEntity != NULL)
				{
					if (bAEntityBaseCast)
					{
						pEntBase = AEntityBase::Cast(pEntity);
						if (pEntBase == NULL)
						{
							pEntity->close();
							continue;
						}
					}

					if (pEntity->visibility() == AcDb::kVisible) 
					{
						
						if (bLookUpExt)
						{
							if (pEntity->getGeomExtents(ext2) == Acad::eOk) 
							{
								XPoint ptExtMin = ext2.minPoint(), ptExtMax = ext2.maxPoint();
								ptExtMin.z = ptExtMax.z = 0;
								if (ext.maxPoint().x<ptExtMin.x || ext.maxPoint().y<ptExtMin.y ||
									ext.minPoint().x>ptExtMax.x || ext.minPoint().y>ptExtMax.y) 
								{
								}
								else 
								{
									idArray.append(pEntity->objectId());
								}
							}
						}
						else
						{
							idArray.append(pEntity->objectId());
						}
					}

					pEntity->close();
				}
				else
				{
					//如果对象之前以写的方式已经打开，此处就不判断范围，直接加入 zjq 2009-7-12
					AcDbObjectId idT;
					pBlockIterator->getEntityId(idT);
					idArray.append(idT);
				}
			}

			delete pBlockIterator;
		}
	}
}

int XExport::SplitSlbName(const TCHAR *totalName, TCHAR *slbFile, TCHAR *sldFile)
{
	if (!totalName || !slbFile || !sldFile)
	{
		return RTERROR;
	}

	XString fullName = totalName;
	TCHAR *p1 = fullName.StrChr(_T('('));
	//acutPrintf(_T("\nfullname= %s"),totalName);

	TCHAR dwgFile[256] = _T("");
	if (p1) 
	{
		*p1 = 0;
		p1++;
		_tcscpy(dwgFile, p1);
		TCHAR *p2 = _tcschr(dwgFile, _T(')'));
		if (p2)
		{
			*p2 = 0;
		}
		else
		{
			return RTERROR;
		}
	}
	else 
	{
		return RTERROR;
	}
	
	_tcscpy(slbFile, fullName);
	_tcscpy(sldFile, dwgFile);
	return RTNORM;
}

BOOL XExport::SplitLibraryPath(const TCHAR *totalName, TCHAR *slbFile, TCHAR *sldFile)
{
	if (!totalName || !slbFile || !sldFile)
	{
		return FALSE;
	}

	XString fullName = totalName;
	TCHAR *p1 = fullName.StrChr(_T('('));
	//acutPrintf(_T("\nfullname= %s"),totalName);

	TCHAR dwgFile[256] = _T("");
	if (p1)
	{
		*p1 = 0;
		p1++;
		_tcscpy(dwgFile, p1);
		TCHAR *p2 = _tcschr(dwgFile, _T(')'));
		if (p2)
		{
			*p2 = 0;
		}
		else 
		{
			return FALSE;
		}
	}
	else 
	{
		return FALSE;
	}
	
	_tcscpy(slbFile, fullName);
	_tcscpy(sldFile, dwgFile);
	return TRUE;
}

int XExport::TypeOfCode(int code)
{
	int type = RTNONE;
	if (code >= RTNONE && code <= RTT) 
	{
		return code;
	}
	if (code  >= EX_INT) 
	{ // extended tag, AOL约定的组码
		if (code < EX_REAL)  
		{
			return RTSHORT;
		}
		else if (code < EX_STRING) 
		{
			return RTREAL;
		}
		else if (code < EX_HANDLE) 
		{
			return RTSTR;
		}
		else if (code < EX_STRUCT)   
		{
			return RTSTR;
		}
		else if (code < EX_END)   
		{
			return RTSTRUCT;
		}
		else 
		{
			return RTNONE;
		}
	} 
	
	if (code >= 1000 )  
	{  
		if (code == 1071)
		{
			return RTLONG;
		}
		code %= 1000;
	};

	if (code <= 49)   
	{
		if (code >= 20)
		{
			type = RTREAL;		/* 20~49 */
		}
		else if (code >= 10)
		{
			type = RT3DPOINT;	// 10~19
		}
		else if (code >= 0)  
		{
			type = RTSTR;		// 0~ 9
		}
		else if (code >= -2)
		{
			type = RTENAME;		// -1, -2
		}
		else if (code == -3)
		{
			type = RTSHORT;
		}
		else if (code == -4) 
		{
			type = RTSTR;
		}
	} 
	else 
	{
		if (code <= 59)  
		{
			type = RTANG;		// 50~59
		}
		else if (code <= 79)
		{
			type = RTSHORT;		// 60~79
		}
		else if (code <= 89)
		{
			;					//80~89 unknown
		}
		else if (code <= 99)
		{
			type = RTLONG;		//90~99
		}
		else if (code == 100 || code == 102 || code == 105)
		{
			type = RTSTR;
		}
		else if (code<110) 
		{
			;
		}
		else if (code <= 119) 
		{
			type = RT3DPOINT;	// 110~119
		}
		else if (code <= 149)
		{
			type = RTREAL;		// 120~149
		}
		else if (code < 170) 
		{
			;					// 150~169
		}
		else if (code <= 179)
		{
			type = RTSHORT;		//170~179
		}
		else if (code < 210)
		{
			;					// 180~209
		}
		else if (code <= 219) 
		{
			type = RT3DPOINT;	// 210~219
		}
		else if (code <= 239) 
		{
			type = RTREAL;		//220~239
		}
		else if (code < 270) 
		{
			;					// 240~269
		}
		else if (code <= 289)
		{
			type = RTSHORT;		//270~289
		}
		else if (code <= 299) 
		{
			;					//290~299, bool
		}
		else if (code <= 369)
		{
			type = RTSTR;		//300~369
		}
		else if (code <= 389)
		{
			type = RTSHORT;		//370~389
		}
		else if (code <= 399)
		{
			type = RTSTR;		// 390~399
		}
		else if (code <= 409)
		{
			type = RTSHORT;		//400~409
		}
		else if (code <= 419)
		{
			type = RTSTR;		//410~419
		}
		else if (code == 999)
		{
			type = RTSTR;
		}
	}

	return type; 
}

void XExport::ApplicationError(const TCHAR *msg,...)
{
	TCHAR temps[256];
	va_list vlist;
	va_start(vlist, msg);
	_vstprintf(temps, msg, vlist);
	va_end(vlist);
	ads_fail(temps);
}

int XExport::MakeEntity(int type,...)
{
	PGroups list = VBuildList(&type);

	if (list)
	{
		return ads_entmake((struct resbuf *)list);
	}
	return RTERROR;
}

void XExport::PrintList(const PGroups headList)
{
	PGroups list = headList;
	while (list)   
	{
		ads_printf(_T("(%d: "),list->code);
		switch(XExport::TypeOfCode(list->code)) 
		{
		case RTSTR : ads_printf(_T("\"%s\")"),list->string);
			break;
		case RTSHORT: ads_printf(_T("%d)"),list->shortInt);
			break;
		case RTLONG :
			ads_printf(_T("%ld)"),list->longInt);
			break;
		case RTREAL : ads_printf(_T("%lg)"),list->real);
			break;
		case RT3DPOINT:
			ads_printf(_T("%lg,%lg,%lg)"),list->point[0],list->point[1], list->point[2]);
			break;
		default :
			ads_printf(_T(" ?)"));
		}
		list = list->next;
	}
}

Acad::ErrorStatus XExport::arxZoomTo(const XPoint &ptCen, double nWidth, double nHeight)
{
	AcDbViewTableRecord view;
	InitView(view);
	XPoint ptDcs;
	ads_trans(ptCen, Groups(0), Groups(2), 0, ptDcs);
	view.setCenterPoint(ptDcs.AsAcGePoint2d());
	view.setHeight( nHeight);
	view.setWidth( nWidth ); 

	Acad::ErrorStatus es = acedSetCurrentView( &view, NULL );
	return es;
}

Acad::ErrorStatus XExport::arxPan(const XPoint &vtPan)
{
    AcDbViewTableRecord view;
    InitView(view);

    XPoint ptViewCtr = view.centerPoint();
    ptViewCtr += vtPan;
    view.setCenterPoint(ptViewCtr.AsAcGePoint2d());

	Acad::ErrorStatus es = acedSetCurrentView( &view, NULL );
	return es;
}

extern int operator & (const XPoint &pt, const XRectAngle &box);

Acad::ErrorStatus XExport::GetSafeSelection(PickSet &ss, BOOL bCrossing, const XPoint &ptLow,
											  const XPoint &ptUp, const TCHAR *pDxfWizard,BOOL bRealCornerSel)
{
	XBlockTableRecordZone* pZone = NULL;
	g_mapDbToModelRecZone.Lookup((void*)acdbCurDwg(),(void*&)pZone);
	if (pZone != NULL && !pZone->isActive())
	{
		pZone = NULL;
	}

    Acad::ErrorStatus esRet = Acad::eNotApplicable;
    XBlockTableRecPtr objMSpace;
    if (!objMSpace)
	{
        return esRet;
	}

    XPoint ptMid;
    Midpoint(ptLow, ptUp, ptMid);
    XRectAngle rect(ptLow, ptUp);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);
    CString sDxfWiz;
    if (pDxfWizard)
	{
        sDxfWiz = pDxfWizard;
	}
    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
		CString str = pRxInfo->dxfName();
        if (!pDxfWizard ||  /*ads_wcmatch(pRxInfo->dxfName(), sDxfWiz) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1) 
		{
            if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
			{
                AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
                XPoint ptCloseToCurve;
                if (pCurve->getClosestPointTo(ptMid, ptCloseToCurve) == Acad::eOk && (ptCloseToCurve & rect) == PR_INSIDE) 
				{
                    Entity ent;
                    VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);

					if (bRealCornerSel)
						RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
					else
						ss += ent;

                    esRet = Acad::eOk;
                }
            } 
			else 
			{
				bool bHasExt = false;
                AcDbExtents ext;

				//modify by zjq on 100520 优化求包围盒算法
				if (pZone != NULL)
				{
					AcDbObjectId id(pEntity->objectId());
					if (pZone->getGeomExtents(id,ext))
					{
						bHasExt = true;
					}
				}
				
				if (bHasExt)
				{
					XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					ptExtMin.z = ptExtMax.z = 0;
					if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					{
					} 
					else 
					{
						Entity ent;
						acdbGetAdsName(ent.name, pEntity->objectId());

						if (bRealCornerSel)
							RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
						else
							ss += ent;

						esRet = Acad::eOk;
					}
				}
				else
				{
					if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					{
						if (pZone != NULL) pZone->setGeomExtents(pEntity->objectId(),ext);
						
						XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
						ptExtMin.z = ptExtMax.z = 0;
						if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
						{
						} 
						else 
						{
							Entity ent;
							acdbGetAdsName(ent.name, pEntity->objectId());

							if (bRealCornerSel)
								RealCornerSel(ss, bCrossing, ptLow, ptUp, pEntity);
							else
								ss += ent;
							
							esRet = Acad::eOk;
						}
					}
				}
            }
        }
    }
   delete pBlockIterator;
   return esRet;
}

// nCmpMethod: 0--Use _tcsicmp;  1--Use ads_wcmatch
Acad::ErrorStatus XExport::GetEntityFromDatabase(DList<AcDbObjectId> &lstObjects, AcDbDatabase &db, const TCHAR *pDxfWizard, int nCmpMethod, const TCHAR *pszBlock)
{
    AcDbBlockTable *pBlockTable = NULL;
    Acad::ErrorStatus es = db.getBlockTable(pBlockTable, AcDb::kForRead);
    if (!pBlockTable)
	{
		return es;
	}
    ASSERT(es == Acad::eOk);

    AcDbBlockTableRecord *pBlockTableRec = NULL;
    es = pBlockTable->getAt(pszBlock, pBlockTableRec, AcDb::kForRead);
    pBlockTable->close();

    if (!pBlockTableRec)
	{
        return es;
	}
    ASSERT(pBlockTableRec);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    es = pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	
	CString sDxfWiz;
	if (pDxfWizard)
	{
		sDxfWiz = pDxfWizard;
	}

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible)
		{
            continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) == 0)
			{
                lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
			}
        }
		else 
		{
            if (/*ads_wcmatch(pRxInfo->dxfName(), pDxfWizard) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1)
			{
                lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
			}
        }
    }
   delete pBlockIterator;

   pBlockTableRec->close();
   return Acad::eOk;
}

Acad::ErrorStatus XExport::GetEntityFromDatabase(DList<AcDbObjectId> &lstObjects, AcDbDatabase &db, const TCHAR *pDxfWizard, int nCmpMethod, const TCHAR *pszBlock,XPoint ptMin,XPoint ptMax)
{
    AcDbBlockTable *pBlockTable = NULL;
    Acad::ErrorStatus es = db.getBlockTable(pBlockTable, AcDb::kForRead);
    if (!pBlockTable) 
	{
		return es;
	}

    ASSERT(es == Acad::eOk);

    AcDbBlockTableRecord *pBlockTableRec = NULL;
    es = pBlockTable->getAt(pszBlock, pBlockTableRec, AcDb::kForRead);
    pBlockTable->close();

    if (!pBlockTableRec)
	{
        return es;
	}
    ASSERT(pBlockTableRec);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    es = pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

	CString sDxfWiz;
	if (pDxfWizard)
	{
		sDxfWiz = pDxfWizard;
	}

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step())
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk) 
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible)
		{
            continue;
        }

        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) != 0)
			{
                continue;
			}
        } 
		else
		{
            if (/*ads_wcmatch(pRxInfo->dxfName(), pDxfWizard) != RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) == -1)
			{
                continue;
			}
        }

		AcDbExtents ext;
		if (pEntity->getGeomExtents(ext) != Acad::eOk)
		{
			continue;
		}
		if (ext.minPoint().x<ptMin.x-1E-6)
		{
			continue;
		}
		if (ext.minPoint().y<ptMin.y-1E-6)
		{
			continue;
		}
		if (ext.maxPoint().x>ptMax.x+1E-6)
		{
			continue;
		}
		if (ext.maxPoint().y>ptMax.y+1E-6)
		{
			continue;
		}

        lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
    }
   delete pBlockIterator;

   pBlockTableRec->close();
   return Acad::eOk;
}

Acad::ErrorStatus XExport::GetEntityFromDatabase(DList<AcDbObjectId> &lstObjects,AcDbDatabase &db, const TCHAR *pszBlock,XPoint ptMin,XPoint ptMax)
{
    AcDbBlockTable *pBlockTable = NULL;
    Acad::ErrorStatus es = db.getBlockTable(pBlockTable, AcDb::kForRead);
    if (!pBlockTable) 
	{
		return es;
	}
    ASSERT(es == Acad::eOk);

    AcDbBlockTableRecord *pBlockTableRec = NULL;
    es = pBlockTable->getAt(pszBlock, pBlockTableRec, AcDb::kForRead);
    pBlockTable->close();

    if (!pBlockTableRec)
	{
        return es;
	}
    ASSERT(pBlockTableRec);

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    es = pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
           continue;
        }

		AcDbExtents ext;
		if (pEntity->getGeomExtents(ext) != Acad::eOk)
		{
			continue;
		}
		if (ext.minPoint().x<ptMin.x-1E-6)
		{
			continue;
		}
		if (ext.minPoint().y<ptMin.y-1E-6)
		{
			continue;
		}
		if (ext.maxPoint().x>ptMax.x+1E-6)
		{
			continue;
		}
		if (ext.maxPoint().y>ptMax.y+1E-6)
		{
			continue;
		}

        lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
    }

   delete pBlockIterator;
   pBlockTableRec->close();
   return Acad::eOk;
}

// nCmpMethod: 0--Use _tcsicmp;  1--Use ads_wcmatch
Acad::ErrorStatus XExport::GetEntFromBlockByDxf(DList<AcDbObjectId> &lstObjects, const TCHAR *pDxfWizard, int nCmpMethod, const TCHAR *pszBlk)
{
    XBlockTableRecPtr objMSpace(pszBlk);
    if (!objMSpace)
	{
        return Acad::eNotApplicable;
	}

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

	CString sDxfWiz;
	if (pDxfWizard)
	{
		sDxfWiz = pDxfWizard;
	}

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible) 
		{
            continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) == 0)
			{
                lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
			}
        }
		else 
		{
            if (/*ads_wcmatch(pRxInfo->dxfName(), pDxfWizard) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1)
			{
                lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
			}
        }
    }
   delete pBlockIterator;
   return Acad::eOk;
}

// nCmpMethod: 0--Use _tcsicmp;  1--Use ads_wcmatch
Acad::ErrorStatus XExport::GetEntByDxf(PickSet &lstObjects, const TCHAR *pDxfWizard, int nCmpMethod)
{
    XBlockTableRecPtr objMSpace;
    if (!objMSpace)
	{
        return Acad::eNotApplicable;
	}

    AcDbBlockTableRecordIterator* pBlockIterator = NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es == Acad::eOk && pBlockIterator != NULL);

	CString sDxfWiz;
	if (pDxfWizard)
	{
		sDxfWiz = pDxfWizard;
	}

    for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
        AcDbEntity *pEntity = NULL;
        es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
        if (es != Acad::eOk)
		{
			continue;
		}
        ASSERT(pEntity);

        XDbObject vTemp(pEntity);
		//不处理不可见的实体
        if (pEntity->visibility() == AcDb::kInvisible)
		{
            continue;
        }
        AcRxClass *pRxInfo = pEntity->isA();
        if (nCmpMethod == 0) 
		{
            if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) == 0) 
			{
                Entity ent;
                if (acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk)
				{
                    lstObjects += ent;
				}
            }
        }
		else 
		{
            const TCHAR *pDxf = pRxInfo->dxfName();
            ASSERT(pDxf);
            XString xsDxfName(256);
            xsDxfName << pDxf;
            if (/*ads_wcmatch(pDxf, pDxfWizard) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1) 
			{
                Entity ent;
                if (acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk)
				{
                    lstObjects += ent;
				}
            }
        }
    }
   delete pBlockIterator;
   return Acad::eOk;
}

Acad::ErrorStatus XExport::SplitBlockName(const TCHAR *sName, XString &sDwb, XString &sDwg)
{
   TCHAR szStyle[80] = _T("");
   _tcscpy(szStyle, sName);
   if (szStyle[0] != _T('$'))
   {
       return Acad::eInvalidInput;
   }

   TCHAR *pSep = _tcschr(&szStyle[1], _T('$'));
   if (!pSep) 
   {
       return Acad::eInvalidInput;
   }
   if (pSep) 
   {
       sDwg = &pSep[1];
       *pSep = 0;
       sDwb = &szStyle[1];
   }
   return Acad::eOk;
}

//pszFileName 传入全路径或文件名
 BOOL XExport::IsArxLoaded(const TCHAR *pszFileName)
{
	CString sFullPathFileName = pszFileName;
	TCHAR szFullPathFileName[512];
	memset(szFullPathFileName,0,sizeof(szFullPathFileName));

	//到当前cad 支持路径下找文件
	if (acedFindFile(sFullPathFileName, szFullPathFileName) != RTNORM)
	{ 
		return FALSE; 
	}
	sFullPathFileName = szFullPathFileName;
	sFullPathFileName.Replace(_T("//"),_T("\\"));
	CString sFileName;
	int nIndex = sFullPathFileName.ReverseFind(_T('\\'));
	if (nIndex == -1)
	{
		//不正常
		sFileName = sFullPathFileName;
	}
	else
	{
		sFileName = sFullPathFileName.Mid(nIndex+1);
	}

	//OBJECTARX 2002\samples\polysamp\compoly\compoly.cpp(45):bool isModuleLoaded(const char* str)
    AcDbVoidPtrArray* pApps = reinterpret_cast<AcDbVoidPtrArray*>(acrxLoadedApps());
    if (pApps==NULL)
        return FALSE;

    BOOL bFound = FALSE;
    for (int i=0;i<pApps->length();i++)
    {
        if (_tcsicmp(reinterpret_cast<const TCHAR*>(pApps->at(i)),sFileName)==0)
        {
            bFound = TRUE;
            break;
        }
    }
    for (;pApps->length()>0;)
    {
        delete reinterpret_cast<TCHAR*>(pApps->at(0));
        pApps->removeAt(0);
    }
    delete pApps;
    return bFound;
}

 int XExport::LoadArxApp(const TCHAR *pszAppReg, const TCHAR *pszFileName)
{
    if (IsArxLoaded(pszFileName))
	{
        return 1;
	}
    if (!acrxLoadApp(pszAppReg))
	{
        return 0;
	}
    return 2;
}

 AcDbObjectId XExport::GetMSpaceId(AcDbDatabase *pDb)
{
	if (!pDb)
	{
		pDb = acdbCurDwg();
	}

    XBlockTableRecPtr rec(ACDB_MODEL_SPACE, AcDb::kForRead, pDb); //MSPACE
    if (!rec)
	{
        return AcDbObjectId::kNull;
	}
    AcDbObjectId id = rec.m_pBlockTableRec->objectId();
    return id;
}

 XPoint XExport::GetCursorWcs()
{
	return g_ptCursorWcs;
}

BOOL XExport::OnCharAsHotKey(UINT_PTR nChar, UINT_PTR nRepCnt, CPoint ptScreen)
{
    BOOL bRet = FALSE;
    if (!m_nPos) 
	{ //没有其它字符输入时
        int nUpChar = toupper(nChar);
        int nLen = _tcslen(g_szKeyTable);
        for (int i = 0; i<nLen; i++) 
		{
            if (g_szKeyTable[i] == _T(' '))
			{
                continue;
			}
            if (g_szKeyTable[i] == nUpChar) 
			{
                CPoint ptClient = ptScreen;
                acedGetAcadDwgView()->ScreenToClient(&ptClient);
                int nCurVp = 0;
                VERIFY(XExport::xg_getvar(_T("CVPORT"), &nCurVp) == RTNORM);
                acedCoordFromPixelToWorld(nCurVp, ptClient, g_ptCursorWcs);

				if (g_nFlag == -2)
				{
					g_cKeyword = nUpChar;
					acedPostCommand(_T(" "));
				}
				else
				{
					TCHAR szPost[3] = _T("");
					szPost[0] = nUpChar; szPost[1] = _T(' '); szPost[2] = EOS;
					acedPostCommand(szPost);
				}
                bRet = TRUE;
                break;
            }
        }
    }
    if (!bRet) 
	{
        unsigned char cChar = LOBYTE(nChar);
        //为了防止键盘缓冲区溢出
        if (cChar == 8) 
		{ //退格键
            if (m_nPos<(int)nRepCnt)
			{
                return FALSE;
			}
        }
		else if (cChar<33 || cChar>126)
		{ //控制字符
            return FALSE; 
        }
		else 
		{ //正常字符
            if (m_nPos+nRepCnt >= 1020)
			{
                return FALSE;
			}
        }
        for (UINT i = 0U; i<nRepCnt; i++) 
		{
            ASSERT(m_nPos >= 0 && m_nPos < 1023);
            if (cChar == 8)
			{//退格键
                m_szCommandStr[m_nPos] = EOS;
                m_nPos--;
            }
			else
			{
                m_szCommandStr[m_nPos] = cChar;
                m_nPos++;
            }
        }
        ASSERT(m_nPos >= 0 && m_nPos < 1023);
        m_szCommandStr[m_nPos] = EOS;
    }
    return bRet;
}

 BOOL XExport::IsOfAcadWindows(HWND hwnd)
{
    CWnd *pFromWnd = CWnd::FromHandle(hwnd);
	if (!pFromWnd)
	{
		return FALSE;
	}
    CRuntimeClass *pClassInfo = pFromWnd->GetRuntimeClass();
    ASSERT(pFromWnd && pClassInfo);
    const char *pClassName = pClassInfo->m_lpszClassName;
	//AfxMessageBox(pClassName);
    return (strcmp(pClassName, "CExpandoEditWnd") == 0 || 
			strcmp(pClassName,"CTextTerminalWnd") == 0 || 
			XExport::IsAcadDwgView(hwnd));
}

#if ARX > 22
 inline bool XExport::LocalHotKeyMonitor(MSG* msg)
#else
 inline BOOL XExport::LocalHotKeyMonitor(MSG* msg)
#endif
{
    if (!acdbCurDwg())
	{
        return FALSE;
	}
    BOOL bRet = FALSE;
	switch(msg->message) 
	{
	case WM_CHAR: 
		if (XExport::IsOfAcadWindows(msg->hwnd)) 
		{
			CPoint ptClient = msg->pt;
			bRet = OnCharAsHotKey(msg->wParam, LOWORD(msg->lParam), ptClient);
		}
		break;
	default:
		break;
	}
    return bRet;
}

 void XExport::InitLocalMsg(BOOL bTrue)
{
    
    static BOOL bLocalMsgOn = FALSE;
    if (bTrue) 
	{
        ASSERT(bLocalMsgOn == FALSE);
        bLocalMsgOn = acedRegisterFilterWinMsg(LocalHotKeyMonitor);
        if (bLocalMsgOn)
		{
            m_nPos = 0;
		}
    } 
	else 
	{
        ASSERT(bLocalMsgOn == TRUE);
        bLocalMsgOn = !acedRemoveFilterWinMsg(LocalHotKeyMonitor);
        m_nPos = 0;
		g_nFlag = 0;
    }
}

 void XExport::InitGetBegin(int nFlag, const TCHAR *szKeyTable)
{
    ASSERT(szKeyTable);
    _tcscpy(g_szKeyTable, szKeyTable);
    if (nFlag >= 0)
	{
        ads_initget(nFlag, szKeyTable);
	}
	g_nFlag = nFlag;
	g_cKeyword = 0;

	//中望不支持
	XExport::InitLocalMsg(TRUE);
}

 int XExport::GetLayerColor(AcDbObjectId idLay)
{
	int nColor = 0;
    OPENOBJ_BEGIN(idLay, AcDb::kForRead, AcDbLayerTableRecord, pLay);
	if (pLay)
	{
		nColor = pLay->color().colorIndex();
	}
	OPENOBJ_END();
	return nColor;
}

AcDbObjectId XExport::AddBlock(AcDbBlockTableRecord *pRec, BOOL bDoneClosed, AcDbDatabase *pDb)
{
    AcDbDatabase *pCurDwg = pDb? pDb : acdbCurDwg();
    AcDbBlockTable *pVPTable = NULL;
    AcDbObjectId id;
    if (pCurDwg->getSymbolTable(pVPTable, AcDb::kForWrite) == Acad::eOk)
	{
		Acad::ErrorStatus es = pVPTable->add(id, pRec);
		pVPTable->close();
		if (es == Acad::eOk && bDoneClosed)
		{
			pRec->close();
		}
	}
    return id;
}

AcDbObjectId XExport::AddTextStyle(AcDbTextStyleTableRecord *pRec, BOOL bDoneClosed, AcDbDatabase *pDb)
{
    AcDbDatabase *pCurDwg = pDb? pDb : acdbCurDwg();
    AcDbTextStyleTable *pVPTable = NULL;
    AcDbObjectId id;
	if (pCurDwg->getSymbolTable(pVPTable, AcDb::kForWrite) == Acad::eOk)
	{  
		Acad::ErrorStatus es = pVPTable->add(id, pRec);
		pVPTable->close();
		if (es == Acad::eOk && bDoneClosed)
		{
			pRec->close();
		}
	}
    return id;
}

AcDbObjectId XExport::AddDimStyle(AcDbDimStyleTableRecord *pRec, BOOL bDoneClosed, AcDbDatabase *pDb)
{
    AcDbDatabase *pCurDwg = pDb ? pDb : acdbCurDwg();
    AcDbDimStyleTable *pVPTable = NULL;
    AcDbObjectId id;
    if (pCurDwg->getSymbolTable(pVPTable, AcDb::kForWrite) == Acad::eOk)
	{
		Acad::ErrorStatus es = pVPTable->add(id, pRec);
		pVPTable->close();
		if (es == Acad::eOk && bDoneClosed)
		{
			pRec->close();
		}
	}
    return id;
}

// 是否应当排除ss中的子对象
AcDbObjectId XExport::MakeBlock(const TCHAR *szBlock, PickSet &ss, XPoint ptInsert)
{
    AcDbObjectId idBlock;
    AcDbObjectIdArray idArray;
    ss.AsIdArray(idArray);
    if (idArray.isEmpty())
	{
        return idBlock;
	}

    AcDbBlockTableRecord *pTempBlock = new AcDbBlockTableRecord;
    pTempBlock->setName(szBlock);
    idBlock = AddBlock(pTempBlock, TRUE);
    if (!idBlock) 
	{
        delete pTempBlock;
        return idBlock;
    }

    AcDbIdMapping idMap;
    VERIFY(acdbCurDwg()->deepCloneObjects(idArray,  idBlock, idMap, false) == Acad::eOk);
    if (ptInsert.Distance(XPoint(0,0,0)) > _DIST_SNAP) 
	{
        AcGeMatrix3d mat;
        mat.setToTranslation(AcGeVector3d(-ptInsert.x, -ptInsert.y, -ptInsert.z));
        
		AcDbBlockTableRecordIterator *pIter = NULL;
        
		OPENOBJ_BEGIN(idBlock, AcDb::kForWrite, AcDbBlockTableRecord, pBlock);
        VERIFY(pBlock->newIterator(pIter) == Acad::eOk);
        OPENOBJ_END();

        for (pIter->start(); !pIter->done(); pIter->step()) 
		{
            AcDbEntity *pEnt = NULL;
            VERIFY(pIter->getEntity(pEnt, AcDb::kForWrite) == Acad::eOk);
            ASSERT(pEnt);
            VERIFY(pEnt->transformBy(mat) == Acad::eOk);
            pEnt->close();
        }
        delete pIter;
    }
    return idBlock;
}



// nCmpMethod: 0--Use _tcsicmp;  1--Use ads_wcmatch
Acad::ErrorStatus XExport::GetEntFromBlockByDxf2(DList<AcDbObjectId> &lstObjects, const TCHAR *pDxfWizard, int nCmpMethod, const TCHAR *pszBlk)
{
#ifdef _REF_EDIT_PATCH
	if (_tcsicmp(pszBlk,ACDB_MODEL_SPACE) == 0)
	{
		AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
		if (pBlockIterator != NULL)//当前工作集存在
		{
			XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
			AcDbObjectId idMSpace;
			if (mspace.m_pBlockTableRec != NULL)
			{
				idMSpace = mspace.m_pBlockTableRec->objectId();
				mspace.Close();
			}

			CString sDxfWiz;
			if (pDxfWizard)
			{
				sDxfWiz = pDxfWizard;
			}

			for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
			{
				AcDbEntity *pEntity = NULL;
				acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
				if (pEntity == NULL)
				{
					continue;
				}

				XDbObject vTemp(pEntity);

				//防止有非模型空间的的混入                                                                         
				if (pEntity->ownerId() != idMSpace)
				{
					continue;
				}
				        
				//不处理不可见的实体
				if (pEntity->visibility() == AcDb::kInvisible) 
				{
					continue;
				}

				AcRxClass *pRxInfo = pEntity->isA();
				if (nCmpMethod == 0) 
				{
					if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) == 0)
					{
						lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
					}
				} 
				else 
				{
					if (/*ads_wcmatch(pRxInfo->dxfName(), pDxfWizard) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1)
					{
						lstObjects.Append(new AcDbObjectId(pEntity->objectId()));
					}
				}
			}

			delete pBlockIterator;
			return Acad::eOk;
		}
	}
#endif
	return XExport::GetEntFromBlockByDxf(lstObjects,pDxfWizard,nCmpMethod,pszBlk);
}

// nCmpMethod: 0--Use _tcsicmp;  1--Use ads_wcmatch
Acad::ErrorStatus XExport::GetEntByDxf2(PickSet &lstObjects, const TCHAR *pDxfWizard, int nCmpMethod)
{
#ifdef _REF_EDIT_PATCH
	AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
	if (pBlockIterator != NULL)//当前工作集存在
	{
		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idMSpace = mspace.m_pBlockTableRec->objectId();
			mspace.Close();
		}

		CString sDxfWiz;
		if (pDxfWizard)
		{
			sDxfWiz = pDxfWizard;
		}

		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
		{
			AcDbEntity *pEntity = NULL;
			acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
			if (pEntity == NULL)
			{
				continue;
			}

			XDbObject vTemp(pEntity);

			//防止有非模型空间的的混入                                                                         
			if (pEntity->ownerId() != idMSpace)
			{
				continue;
			}
			        
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) 
			{
				continue;
			}

			AcRxClass *pRxInfo = pEntity->isA();
			if (nCmpMethod == 0) 
			{
				if (_tcsicmp(pRxInfo->dxfName(), pDxfWizard) == 0)
				{
					Entity ent;
					if (acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk)
					{
						lstObjects += ent;
					}
				}
			} 
			else 
			{
				const TCHAR *pDxf = pRxInfo->dxfName();
				ASSERT(pDxf);
				XString xsDxfName(256);
				xsDxfName << pDxf;
				if (/*ads_wcmatch(pDxf, pDxfWizard) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1) 
				{
					Entity ent;
					if (acdbGetAdsName(ent.name, pEntity->objectId()) == Acad::eOk)
					{
						lstObjects += ent;
					}
				}
			}
		}

		delete pBlockIterator;
		return Acad::eOk;
	}
#endif
	return XExport::GetEntByDxf(lstObjects, pDxfWizard, nCmpMethod);
}

Acad::ErrorStatus XExport::GetSafeSelection(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
											 const XPoint &ptUp, const TCHAR *pDxfWizard)
{
	return GetSafeSelection2(ss,bCrossing,ptLow,ptUp,pDxfWizard);
}

Acad::ErrorStatus XExport::GetSafeSelection2(PickSet &ss, BOOL bCrossing, const XPoint &ptLow, 
											   const XPoint &ptUp, const TCHAR *pDxfWizard)
{
#ifdef _REF_EDIT_PATCH
	AcDbLongTransWorkSetIterator* pBlockIterator = GetCurrentWorkSet();
	if (pBlockIterator != NULL)//当前工作集存在
	{
	    Acad::ErrorStatus esRet = Acad::eNotApplicable;

		XBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForRead);
		AcDbObjectId idMSpace;
		if (mspace.m_pBlockTableRec != NULL)
		{
			idMSpace = mspace.m_pBlockTableRec->objectId();
			mspace.Close();
		}

		XPoint ptMid;
		Midpoint(ptLow, ptUp, ptMid);
		XRectAngle rect(ptLow, ptUp);
		
		CString sDxfWiz;
		if (pDxfWizard)
		{
			sDxfWiz = pDxfWizard;
		}

		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
		{
			AcDbEntity *pEntity = NULL;
			acdbOpenObject(pEntity,pBlockIterator->objectId(),AcDb::kForRead);
			if (pEntity == NULL)
			{
				continue;
			}

			XDbObject vTemp(pEntity);

			//防止有非模型空间的的混入                                                                         
			if (pEntity->ownerId() != idMSpace)
			{
				continue;
			}
			        
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) 
			{
				continue;
			}

			AcRxClass *pRxInfo = pEntity->isA();
			if (!pDxfWizard ||  /*ads_wcmatch(pRxInfo->dxfName(), sDxfWiz) == RTNORM*/sDxfWiz.Find(pRxInfo->dxfName(),0) != -1) 
			{
				if (!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) 
				{
					AcDbCurve *pCurve = AcDbCurve::cast(pEntity);
					XPoint ptCloseToCurve;
					if (pCurve->getClosestPointTo(ptMid, ptCloseToCurve) == Acad::eOk && (ptCloseToCurve&rect) == PR_INSIDE) 
					{
						Entity ent;
						VERIFY(acdbGetAdsName(ent.name, pCurve->objectId()) == Acad::eOk);
						ss += ent;
						esRet = Acad::eOk;
					}
				} 
				else
				{
					AcDbExtents ext;
					if (pEntity->getGeomExtents(ext) == Acad::eOk) 
					{
					   XPoint ptExtMin = ext.minPoint(), ptExtMax = ext.maxPoint();
					   ptExtMin.z = ptExtMax.z = 0;
					   if (ptUp.x<ptExtMin.x || ptUp.y<ptExtMin.y || ptLow.x>ptExtMax.x || ptLow.y>ptExtMax.y) 
					   {
					   }
					   else
					   {
						   Entity ent;
						   acdbGetAdsName(ent.name, pEntity->objectId());
						   ss += ent;
						   esRet = Acad::eOk;
					   }
					}
				}
			}
		}

		delete pBlockIterator;
		return esRet;
	}
#endif
	return XExport::GetSafeSelection(ss, bCrossing, ptLow, ptUp,pDxfWizard,FALSE);
}

int XExport::YesNoQuestion(const TCHAR *s, int nDefaultAnswer)
{
	int nRet;
	TCHAR answer[256] = _T("");
	XString sPrompt(256);
	sPrompt << s << (nDefaultAnswer == Q_YES ? _T("?[是(Y)/否(N)]<Y>: ") : _T("?[是(Y)/否(N)]<N>: "));
	INITGET_BEG(0, _T("Y N"));
	nRet = ads_getkword(sPrompt, answer);
	INITGET_END();
	
	if (nRet == RTCAN)
	{
		return RTCAN;
	}
	if (nRet == RTNONE)
	{
		return nDefaultAnswer;
	}
	
	if (_tcsicmp(answer, _T("N")) == 0)
	{
		return Q_NO;
	}
	return Q_YES;
}

int XExport::XGetPoint(const ads_point ref, const TCHAR *prompt, ads_point res)
{
   TCHAR prmt[256] = _T("");
   if (!prompt) 
   {
	   _tcscpy(prmt, _T("\n请在屏幕上点取一点"));
   }
   else
   {
	   _tcscpy(prmt, prompt);
   }

   XString prmt1(256);
   prmt1 <<  prmt << _T("或 [参考点(R)]<退出>:");

   int rt = RTKWORD;

   XPoint refPt;
   const double *base = ref;
   while(rt == RTKWORD) 
   {
      INITGET_BEG(0, _T("R"));
      rt = ads_getpoint(base, prmt1, res);
      INITGET_END();
      if (rt == RTKWORD) 
	  {
         int rc = ads_getpoint(NULL, _T("\n参考点: "), refPt);
         if (rc == RTCAN) 
		 {
			 return rc;
		 }
         else if (rc == RTNORM)
		 {
            base = &refPt.x;
		 }
      }
   }
   return rt;
}

resbuf* XExport::GetLineFence(double dist, ads_point startPoint, ads_point endPoint)
{
	ads_point pt1, pt2, pt3, pt4;
	double drt = ads_angle(startPoint, endPoint);
	ads_polar(startPoint, drt+PI/2.0, dist, pt1);
	ads_polar(startPoint, drt-PI/2.0, dist, pt2);
	ads_polar(endPoint, drt-PI/2.0, dist, pt3);
	ads_polar(endPoint, drt+PI/2.0, dist, pt4);
	resbuf *res = ads_buildlist(RT3DPOINT, pt1,
								RT3DPOINT, pt2,
								RT3DPOINT, pt3,
								RT3DPOINT, pt4,
								RT3DPOINT, pt1, NULL);
	return res;
}

resbuf* XExport::GetLinePoly(double dist, ads_point startPoint, ads_point endPoint)
{
	ads_point pt1, pt2, pt3, pt4;
	double drt = ads_angle(startPoint, endPoint);
	ads_polar(startPoint, drt+PI/2.0, dist, pt1);
	ads_polar(startPoint, drt-PI/2.0, dist, pt2);
	ads_polar(endPoint, drt-PI/2.0, dist, pt3);
	ads_polar(endPoint, drt+PI/2.0, dist, pt4);
	resbuf *res = ads_buildlist(RT3DPOINT, pt1,
								RT3DPOINT, pt2,
								RT3DPOINT, pt3,
								RT3DPOINT, pt4,
								NULL);
	return res;
}

int XExport::TextGeometry(Entity & textEnt, ads_point cen, double *w, double *h, double *ang)
{
	Point org;
	if (!textEnt.Is(_T("TEXT"))) 
	{
		return RTERROR;
	}
	textEnt.GetData(10, &org.x);
	textEnt.GetData(50, ang);
	Point lowLeft, upRight;
	if (ads_textbox(textEnt, lowLeft, upRight) != RTNORM)
	{
		return RTERROR;
	}
	lowLeft.Rotate(*ang);
	upRight.Rotate(*ang);
	*w = fabs(upRight.x-lowLeft.x);
	*h = fabs(upRight.y-lowLeft.y);
	cen[X] = org.x + (lowLeft.x+upRight.x)/2.0;
	cen[Y] = org.y + (lowLeft.y+upRight.y)/2.0;
	cen[Z] = org.z;
	return RTNORM;
}

int XExport::TextGeometry(const TCHAR *text, double *w)
{
	Point p;
	TCHAR style[80];
	XExport::xg_getvar(_T("TEXTSTYLE"), style);
	
	StyleTable textStyle(style);
	XExport::xg_getvar(_T("VIEWCTR"), &p);
	
	Entity ent;
	RBList tmp = ads_buildlist(RTDXF0, _T("TEXT"),
								1, text,
								7,  style,
								40, textStyle.height,
								41, textStyle.widthFactor,
								10, &p,
								40, 1.0,
								50, 0.0,
								NULL);
	double h;
	return XExport::TextGeometry(tmp, w, &h);
}

int XExport::IsWCS()
{
	XPoint ucsOrg, ucsXDir, ucsYDir;
	XExport::xg_getvar(_T("UCSORG"), &ucsOrg);
	XExport::xg_getvar(_T("UCSXDIR"), &ucsXDir);
	XExport::xg_getvar(_T("UCSYDIR"), &ucsYDir);
	
	XPushPrec var(_AS_SYS_UNIT(1.0E-5), 1.0E-3);
	return (ucsOrg == XPoint() && ucsXDir == XPoint(1,0,0) && ucsYDir == XPoint(0,1,0));
}

// Migrate from ASHOME-Insert.cpp
int XExport::LoadDwbBlock(const TCHAR *sDwbFile, const TCHAR *sDwgName, TCHAR *sBlockName)
{
	TCHAR drive[_MAX_DRIVE] = _T(""), dir[_MAX_DIR] = _T(""), file[_MAX_FNAME], ext[_MAX_EXT];
	_tsplitpath(sDwbFile, drive, dir, file, ext);
	_stprintf(sBlockName, _T("$%s$%s"), file, sDwgName);
	
	if (!XSymbolTable(_T("BLOCK"), sBlockName))
	{
		;
	}
	else
	{
		return RTNORM;
	}
	
	if (!XSymbolTable(_T("BLOCK"), BLOCK_SWAP))
	{
		;
	}
	else 
	{
		ads_alert(XString(_T("\n图块'%s'已经存在,请清除掉它或改名!"), BLOCK_SWAP));
		return RTERROR;
	}
	
	XString sDwbFileExt, sFullDwbFile;
	sDwbFileExt << sDwbFile;
	if (!tstrchr_new(sDwbFile, _T('.')))
	{
		sDwbFileExt << _T(".DWB");
	}
	
	if (ads_findfile(sDwbFileExt, sFullDwbFile) != RTNORM)
	{
		return RTERROR;
	}
	
	XDrawingLib dwb(sFullDwbFile, _ios::binary|_ios::in);
	int nIndex = 0;
	if (!dwb.IsExist(sDwgName, &nIndex)) 
	{
		return RTERROR;
	}
	
	XString sTempFile(256);
	sTempFile = XExport::GetTempFileName(_T(".dwg"));
	if (!dwb.Copy(nIndex, sTempFile))
	{
		return RTERROR;
	}
	
	int nRet = RTNORM;
	AcDbDatabase db(false, true);
	//acutPrintf(sTempFile);

	Acad::ErrorStatus es;
#if ARX >= 21
	es = db.readDwgFile(sTempFile, AcDbDatabase::kForReadAndAllShare,false);
#else
	es = db.readDwgFile(sTempFile,_SH_DENYNO,false);
#endif
	if(es == Acad::eOk)
	{
		AcDbObjectId _id(AcDbObjectId::kNull);
		es = acdbCurDwg()->insert(_id, sBlockName, &db,false); 
		if (es == Acad::eOk)
		{
			nRet = RTNORM;
		} 
		else 
		{
			nRet = RTERROR;
		}
	}
	_tremove(sTempFile);
	return nRet;
}

int XExport::LoadDwbBlock(const TCHAR *sDwbFile, TCHAR *sBlockName)
{
	XString sDwb, sDwg;
	if (XExport::SplitSlbName(sDwbFile, sDwb, sDwg) != RTNORM)
	{
		return RTERROR;
	}
	
	return XExport::LoadDwbBlock(sDwb, sDwg, sBlockName);
}

int XExport::LoadDwbBlock(const TCHAR *sDwbFile, const TCHAR *sDwgName, TCHAR *sBlockName,AcDbDatabase*pDb)
{
	TCHAR drive[_MAX_DRIVE] = _T(""), dir[_MAX_DIR] = _T(""), file[_MAX_FNAME], ext[_MAX_EXT];
	_tsplitpath(sDwbFile, drive, dir, file, ext);
	_stprintf(sBlockName, _T("$%s$%s"), file, sDwgName);
	if (!XBlockTableRecPtr(sBlockName, AcDb::kForRead, pDb))
	{
		;
	}
	else
	{
		return RTNORM;
	}
	
	XString sDwbFileExt, sFullDwbFile;
	sDwbFileExt << sDwbFile;
	if (!tstrchr_new(sDwbFile, _T('.')))
	{
		sDwbFileExt << _T(".DWB");
	}
	
	if (ads_findfile(sDwbFileExt, sFullDwbFile) != RTNORM)
	{
		return RTERROR;
	}
	
	XDrawingLib dwb(sFullDwbFile, _ios::binary|_ios::in);
	int nIndex = 0;
	if (!dwb.IsExist(sDwgName, &nIndex))
	{
		return RTERROR;
	}
	
	XString sTempFile(256);
	sTempFile = XExport::GetTempFileName(_T(".dwg"));
	if (!dwb.Copy(nIndex, sTempFile)) 
	{
		return RTERROR;
	}
	
	int nRet = RTNORM;
	AcDbDatabase db(false, true);
#if ARX >= 21
	AcDbObjectId __id(AcDbObjectId::kNull);
	if (db.readDwgFile(sTempFile, AcDbDatabase::kForReadAndAllShare, false) == Acad::eOk &&
		pDb->insert(__id, sBlockName, &db, false) == Acad::eOk)
#else
	if (db.readDwgFile(sTempFile, _SH_DENYNO, false) == Acad::eOk &&
		pDb->insert(AcDbObjectId(), sBlockName, &db, false) == Acad::eOk)
#endif
	{
		nRet = RTNORM;
	} 
	else 
	{
		nRet = RTERROR;
	}
	_tremove(sTempFile);
	return nRet;
}

int XExport::LoadDwbBlock(const TCHAR *sDwbFile, TCHAR *sBlockName,AcDbDatabase*pDb)
{
	XString sDwb, sDwg;
	if (XExport::SplitSlbName(sDwbFile, sDwb, sDwg) != RTNORM)
	{
		return RTERROR;
	}
	return LoadDwbBlock(sDwb, sDwg, sBlockName,pDb);
}

void XExport::GetSearchPath(XStringList &lstSearchPath)
{
   XString sAcadPath;
   if (ads_findfile(_T("zwcad.exe"), sAcadPath) != RTNORM) 
   {
	   return;
   }

   TCHAR drive[_MAX_DRIVE] = _T(""), dir[_MAX_DIR] = _T(""), file[_MAX_FNAME], ext[_MAX_EXT];
   _tsplitpath(sAcadPath, drive, dir, file, ext);
   XString sDwgPrefix(256), sAcadPrefix(1024);
   XExport::xg_getvar(_T("DWGPREFIX"), sDwgPrefix);
   XExport::xg_getvar(_T("ACADPREFIX"), sAcadPrefix);

   lstSearchPath.Append(tstrnew(sDwgPrefix));
   lstSearchPath.Append(tstrnew(XString(_T("%s%s"),drive, dir)));

   TCHAR *pBeg = sAcadPrefix, *pEnd = NULL;
   do 
   {
       XString sPath(256);
       pEnd = _tcschr(pBeg, _T(';'));
       StrCpy(sPath, pBeg, pEnd);
       if (AsStdPath(sPath))
	   {
          lstSearchPath.Append(tstrnew(sPath));
	   }
       if (pEnd)
	   {
		   pBeg = pEnd+1;
	   }
   } while(pEnd);

}

int XExport::GetColorDlg(int color)
{
	RBList cmdList = ads_buildlist(RTSTR, _T("acad_colordlg"), RTSHORT, 7, NULL);
	resbuf *rb = NULL;
	int res = color;
	if (ads_invoke(cmdList, &rb) == RTNORM && rb) 
	{
		res = rb->resval.rint;
		ads_relrb(rb);
	}

	return res;
}

// Make full path file name, with prefix same as curdwg, and different ext
void XExport::MakeFullPath(const TCHAR *pExt, XString &sFileBm1)
{
	TCHAR szDwg[80] = _T("");
	AT_GetCurDwg(szDwg);
	
	XString sDwgPrefix;
	XExport::xg_getvar(_T("DWGPREFIX"), sDwgPrefix);
	
	XString sFullPath(256);
	sFullPath << sDwgPrefix << szDwg << pExt;
	sFileBm1 = sFullPath;
}

int XExport::GetViewport(int vp, Entity &res)
{
	RBList mask = ads_buildlist(RTDXF0, _T("VIEWPORT"), NULL);
	PickSet vports(SS_FREE);
	if (vports.Get(_T("X"), NULL, NULL, mask) == RTNORM) 
	{
		long len = vports.Length();
		for (long i = 0; i<len; i++) 
		{
			Entity ent = vports[i];
			int id;
			if (ent.GetData(69, &id) == RTNORM && id == vp) 
			{
				res = ent;
				return RTNORM;
			}
		}
	}
	return RTERROR;
}

AcDbObjectId XExport::MakeLayer(const TCHAR *LayName, BOOL bApplyChange)
{
	AcDbLayerTable *pLayerTable;
	AcDbObjectId idLay;
	if (acdbCurDwg()->getLayerTable(pLayerTable,AcDb::kForWrite) != Acad::eOk)
	{
		return idLay;
	}
	if (pLayerTable->getAt(LayName, idLay) == Acad::eOk) 
	{  //层名已经存在!
		pLayerTable->close();
		return idLay;
	}
	
	AcDbLayerTableRecord *pLayerTableRecord = new AcDbLayerTableRecord;
	
	pLayerTableRecord->setName(LayName);
	
	pLayerTable->add(idLay, pLayerTableRecord);
	pLayerTableRecord->close();
	pLayerTable->close();
	if (bApplyChange) 
	{
		Acad::ErrorStatus es = applyCurDwgLayerTableChanges();
		assert(es == Acad::eOk);
	}
	return idLay;
}

AcDbObjectId XExport::MakeLayer(const TCHAR *LayName,AcDbDatabase *pDb)
{
	if (pDb == NULL||pDb == acdbCurDwg())
	{
		return XExport::MakeLayer(LayName,FALSE);
	}
	
	AcDbLayerTable *pLayerTable;
	AcDbObjectId idLay;
	if (pDb->getLayerTable(pLayerTable,AcDb::kForWrite) != Acad::eOk)
	{
		return idLay;
	}
	if (pLayerTable->getAt(LayName, idLay) == Acad::eOk) 
	{  //层名已经存在!
		pLayerTable->close();
		return idLay;
	}
	
	AcDbLayerTableRecord *pLayerTableRecord = new AcDbLayerTableRecord;
	
	pLayerTableRecord->setName(LayName);
	
	pLayerTable->add(idLay, pLayerTableRecord);
	pLayerTableRecord->close();
	pLayerTable->close();
	
	return idLay;
}

int XExport::arxAssureLayer(const TCHAR *szLayer, int nFlag)
{
	XExport::MakeLayer(szLayer, TRUE);

	XDbLayerTableRec tLayer(szLayer, AcDb::kForWrite);
	if (!tLayer) 
	{
		return RTERROR;
	}
	
	AcDbLayerTableRecord &lay = tLayer;
	
	if ((nFlag&LAYSTAT_ON) && lay.isOff())
	{
		lay.setIsOff(Adesk::kFalse);
	}
	if ((nFlag&LAYSTAT_OFF) && !lay.isOff())
	{
		lay.setIsOff(Adesk::kTrue);
	}

	if ((nFlag&LAYSTAT_THAW) && lay.isFrozen())
	{
		lay.setIsFrozen(Adesk::kFalse);
	}
	if ((nFlag&LAYSTAT_FREEZE) && !lay.isFrozen())
	{
		lay.setIsFrozen(Adesk::kTrue);
	}
	
	if ((nFlag&LAYSTAT_UNLOCK) && lay.isLocked())
	{
		lay.setIsLocked(Adesk::kFalse);
	}
	if ((nFlag&LAYSTAT_LOCK) && !lay.isLocked())
	{
		lay.setIsLocked(Adesk::kTrue);
	}
	if ((nFlag&LAYSTAT_CURRENT)) 
	{
		xg_setvar(_T("CLAYER"), szLayer);
	}
	return RTNORM;
}      

// Assure layer status
int XExport::AssureLayer(const TCHAR *szLayer, int nFlag)
{
	return XExport::arxAssureLayer(szLayer, nFlag);
}      

void XExport::AssureOnScreen(const XPoint &ptLow, const XPoint &ptUp)
{
    XPoint lowCorner, upCorner;
    AT_ScrCorner(lowCorner, upCorner);
    XPoint pt1 = ptLow, pt2 = ptUp;
    pt1.z = pt2.z = lowCorner.z;
    XPoint ptMin = Min(pt1, lowCorner), ptMax = Max(pt2, upCorner);
    if (ptMin != lowCorner || ptMax != upCorner)  
	{
        XExport::arxZoom(ptMin, ptMax);
	}
}

void XExport::AssureTileMode(int nMode)
{
	int nTileMode;
	XExport::xg_getvar(_T("TILEMODE"), &nTileMode);
	if (nTileMode != nMode) 
	{
		xg_setvar(_T("TILEMODE"), nMode);
	}
}


int XExport::GetFileDia(XString &fullName, int nFlag, const TCHAR *ext, const TCHAR *title)
{
	resbuf result;
	result.resval.rstring = NULL;
	int rc = ads_getfiled((title ? title:_T("Input File Name")), fullName, ext, nFlag, &result);
	if (rc == RTNORM) 
	{
		fullName = result.resval.rstring;
		free(result.resval.rstring);
	}
	return rc;
}

//是否全部为数字
BOOL XExport::IsDigital(const TCHAR *pStr) 
{
    ASSERT(pStr);
    int nLen=_tcslen(pStr);
    if(!nLen)
        return FALSE;
    for(int i=0; i<nLen; i++) {
        if(!isdigit(pStr[i]))
            return FALSE;
    }
    return TRUE;
}

int XExport::GetNextItem(const TCHAR *dwb, TCHAR *sld)
{
//	extern BOOL IsDigital(const TCHAR *pStr);
	XASLibMan lib(dwb, LZW_EXT, DWB_TITLE, _ios::binary|_ios::in);
	XStringList recs;
	if (!lib.GetAll(recs)) 
	{
		_tcscpy(sld, _T("00000001"));
		return RTNORM;
	}
	TCHAR *maxStr = recs.MaxValue(0);
	if (IsDigital(maxStr)) 
	{
		int nIndex = _ttoi(maxStr);
		nIndex++;
		XString sIndex = Int2Char8((unsigned)nIndex);
		_tcscpy(sld, sIndex);
	} 
	else if (maxStr && _tcslen(maxStr)>3) 
	{
		int slen = _tcslen(maxStr);
		TCHAR a1 = maxStr[slen-1], a2 = maxStr[slen-2], a3 = maxStr[slen-3];
		if (a1 >= _T('0') && a1<_T('9'))
		{
			a1++;
		}
		else if (a1 == _T('9') && a2 >= _T('0') && a2<_T('9')) 
		{
			a1 = _T('0');
			a2++; 
		}
		else if (a1 == _T('9') && a2 == _T('9') && a3 >= _T('0') && a3<_T('9')) 
		{
			a1 = a2 = _T('0'); 
			a3++; 
		}
		else 
		{
			a1++;
			if (!isalpha(a1) && !isdigit(a1))
			{
				_tcscpy(sld, _T("00000001"));
				return RTNORM;
			}
		}
		_tcscpy(sld, maxStr);
		sld[slen-1] = a1;
		sld[slen-2] = a2; 
		sld[slen-3] = a3;
	}
	else 
	{
		_tcscpy(sld, _T("00000001"));
		return RTNORM;
	}
	return RTNORM;
}

Acad::ErrorStatus XExport::ConvertToDouble(const VARIANT *val, double *pRes)
{
	double nVal = 0.0;
	switch(V_VT(val)) 
	{
	case VT_R8:
		nVal = V_R8(val);
		break;
	case VT_R4: 
		nVal = V_R4(val);
		break;
	case VT_I4:
		nVal = V_I4(val);
		break;
	case VT_I2: 
		nVal = V_I2(val);
		break;
	case VT_BSTR: 
		{
			CString csVal = (LPCTSTR)_bstr_t(val);//V_BSTR(val);
			nVal = _tstof(csVal);
			break;
		}
	default:
		return Acad::eInvalidInput;
	}
	*pRes = nVal;
	return Acad::eOk;
}

Acad::ErrorStatus XExport::ConvertToInteger(const VARIANT *val, int *pInt)
{
	int nVal = 0;
	switch(V_VT(val)) 
	{
	case VT_R8: 
		nVal = AS_INT(V_R8(val)); 
		break;
	case VT_R4:
		nVal = AS_INT(V_R4(val));
		break;
	case VT_I4:
		nVal = V_I4(val); 
		break;
	case VT_I2: 
		nVal = V_I2(val);
		break;
	case VT_BSTR:
		{
			CString csVal = (LPCTSTR)_bstr_t(val);//V_BSTR(val);
			nVal = AS_INT(_tstof(csVal));
			break;
		}
	default:
		return Acad::eInvalidInput;
	}
	*pInt = nVal;
	return Acad::eOk;
}

// 把可行的曲线转换为AcDbPolyline
AcDbPolyline * XExport::AsPolyline(const AcDbEntity *pEntity)
{
    AcDbPolyline *pline = NULL;
    if (pEntity->isKindOf(AcDbLine::desc())) 
	{
        AcDbLine *pLine = AcDbLine::cast(pEntity);
        pline = new AcDbPolyline;
		XPrivate::AsPolyline(*pLine, *pline);            
    } 
	else if (pEntity->isKindOf(AcDbArc::desc())) 
	{ //取弧上的三点进行变换,再构成弧
        AcDbArc *pArc = AcDbArc::cast(pEntity);
        pline = new AcDbPolyline;
        XPrivate::AsPolyline(*pArc, *pline);
    } 
	else if (pEntity->isKindOf(AcDbCircle::desc()))
	{ //维持圆心和X+象限点满足变换规律
        AcDbCircle *pCir = AcDbCircle::cast(pEntity);
        pline = new AcDbPolyline;
        XPrivate::AsPolyline(*pCir, *pline);
    }
	else if (pEntity->isKindOf(AcDbPolyline::desc())) 
	{
        pline = (AcDbPolyline *)pEntity->clone();
    }
	else if (pEntity->isKindOf(AcDb2dPolyline::desc())) 
	{
        AcDb2dPolyline *pline2d = AcDb2dPolyline::cast(pEntity);
        if (pline2d->polyType() == AcDb::k2dSimplePoly)
		{
            pline = new AcDbPolyline ;
            pline->	convertFrom((AcDbEntity * &)pEntity, Adesk::kFalse);
        }
    }
    return pline;
}


int XExport::DisplaySlide(CWnd *pWnd, const TCHAR *pszSlide)
{
    XString szSlide, szLib;
    if (!XExport::SplitLibraryPath(pszSlide, szLib, szSlide)) 
	{
        szSlide = pszSlide;
        szLib = _T("");
    }

    CImageDC image;
    CRect rect;
    pWnd->GetClientRect(rect);
    CDC *pDC = pWnd->GetDC();
    image.InitDC(pDC, rect, GetAcadBackColor());
    BOOL bRet = RTNORM;
    if (!szLib)
	{
        XPathParser parser(szSlide);
        XString sPath1(256), sPath2(256);
        sPath1 << parser.m_sDrive << parser.m_sDir << parser.m_sFileName << _T(".SLD");
        if (FindFile(sPath1, sPath2)) 
		{
            image.PaintSlide(sPath2);
        } 
		else
		{
            bRet = RTERROR;
        }
    }
	else 
	{
        XPathParser parser(szLib);
        XString sPath1(256), sPath2(256);
        sPath1 << parser.m_sDrive << parser.m_sDir << parser.m_sFileName << _T(".SLB");
        if (FindFile(sPath1, sPath2))
		{
            XPathParser parser1(sPath2);
            XString sFullPath(256);
            sFullPath << parser1.m_sDrive << parser1.m_sDir << parser1.m_sFileName << _T("(") << szSlide << _T(")");
            image.PaintSlide(sFullPath);
        } 
		else
		{
            bRet = RTERROR;
        }
    }
    if (!bRet)
	{
        image.PaintSlide(_T(""));
	}
    pWnd->ReleaseDC(pDC);
    return bRet;
}

int XExport::FindFile(const TCHAR *szFile, TCHAR * szPath)
{
	XString sFullPath(256);
	memset(sFullPath,0,256);

	if (ads_findfile(szFile, sFullPath) != RTNORM) 
	{
		sFullPath << g_sAppPath << szFile;
		if (FindFile(sFullPath)) 
		{
			_tcscpy(szPath, sFullPath);
		} 
		else
		{
			return 0;
		}
	} 
	else 
	{
		_tcscpy(szPath, sFullPath);
	}
	return 1;
}

void XExport::FindDirs(const TCHAR *sDir, XStringList &lstSubDirs)
{
	XString sSubDirFilter(256);
	sSubDirFilter << sDir << _T("*.*");
	
	struct _tfinddata_t fb1;
	intptr_t hand1;
	hand1 = _tfindfirst(sSubDirFilter,&fb1);
	if (hand1 == -1L) 
	{
		return;
	}
	
	//XStringList lstSubDirs;
	if (fb1.attrib & _A_SUBDIR)
	{
		if (fb1.name[0] != _T('.')) 
		{
            lstSubDirs.Append(tstrnew(fb1.name));
		}
	}

	while (!_tfindnext(hand1,&fb1)) 
	{
		if (fb1.attrib & _A_SUBDIR) 
		{
			if (fb1.name[0] != _T('.'))
			{
				lstSubDirs.Append(tstrnew(fb1.name));
			}
		}
	}
	_findclose(hand1);
}

void XExport::FindFiles(const TCHAR *sDir, const TCHAR *sFilter, XStringList &lstRes, int bIncludeSubDir, time_t tLastModify)
{
	if (sDir[_tcslen(sDir)-1]  != _T('\\'))
	{
		return;
	}
	
	XString filter(256);
	filter << sDir << sFilter;
	
	struct _tfinddata_t fb;
	intptr_t hand;
	hand = _tfindfirst(filter,&fb);
	if (hand == -1L)
	{
		;
	}
	else
	{
		if (!tLastModify || difftime(fb.time_write, tLastModify)>0)
		{
			if (fb.attrib & _A_SUBDIR)
			{
				;   // It's a dir name, ignore
			}
			else 
			{
				lstRes.Append(tstrnew(fb.name));
			}
		}

		while (!_tfindnext(hand,&fb))
		{
			if (!tLastModify || difftime(fb.time_write, tLastModify)>0) 
			{
				if (fb.attrib & _A_SUBDIR) 
				{
					;
				}
				else 
				{
					lstRes.Append(tstrnew(fb.name));
				}
			}
		}
		_findclose(hand);
	}
	
	if (bIncludeSubDir)
	{
		XStringList lstSubDirs;
		XExport::FindDirs(sDir, lstSubDirs);

		for (int i = 0; i<lstSubDirs.Length(); i++)
		{
			XStringList lstFilesInSubDir;
			XString sSubDir;
			sSubDir << sDir << lstSubDirs[i] << _T("\\");
			XExport::FindFiles(sSubDir, sFilter, lstFilesInSubDir, bIncludeSubDir, tLastModify);

			for (int n = 0; n<lstFilesInSubDir.Length(); n++)
			{
				XString sName(256);
				sName << lstSubDirs[i] << _T("\\") << lstFilesInSubDir[n];
				lstRes.Append(tstrnew(sName));
			}
		}
	}
}

int XExport::FindFile(const TCHAR *sDbfPath)
{
	int bFind = 0;
	struct _tfinddata_t fb;
	intptr_t hand;
	hand = _tfindfirst((TCHAR *)sDbfPath,&fb);
	if (hand != -1L)
	{ 
		bFind = 1;
		_findclose(hand);
	}
	
    return bFind;
}

TCHAR * XExport::CT_strnth(const TCHAR *string, int i, TCHAR *item)
{
	int num = 1;
	TCHAR *p1, *p2, *ip, str1[1000];
	
	_tcscpy(str1, string);
	p1 = str1;
	ip = item;
	
	if ( *p1 == _T('\0') || *p1 == _T('\n'))
	{
		return NULL;
	}
	while(*p1 != _T('\0'))
	{
		if (*p1 == _T(',') || *p1 == _T('\t'))
		{
			*p1 = _T(' ');
		}
		else if (*p1 == _T('\n')) 
		{
			*p1 = _T('\0');
			break;
		}
		p1++;
	}
	
	p1 = str1;
	while(*p1 == _T(' '))
	{
		p1++;
	}
	
	if (i <= 1)
	{
		for (;(*p1 != _T(' ') && *p1 != _T('\0'));p1++)
		{
			*ip = *p1;
			ip++;
		}
		*ip = _T('\0');
		return item;
	}
	
	else for (p2 = p1; *p2 != _T('\0'); p2++) 
	{
		if (*p1 == _T(' ') &&  *p2 != _T(' '))
		{ 
			num++; 
		}
		
		if (num == i) 
		{
			for (;*p2 != _T(' ') && *p2 != _T('\0');p2++)
			{
				*ip = *p2;
				ip++;
			}
			*ip = _T('\0');
			return item;
		}
		p1 = p2;
	}
	
	return NULL;
}

int XExport::CT_get_INIs(const TCHAR *ini_file, const TCHAR *topic, struct INI_struct **res)
{
	TCHAR id[80], val[80], line_rec[200];
	TCHAR tpc[80], line_r[200];
	FILE *fp;
	struct INI_struct *p, *last;
	
	*res = NULL;
	_tcscpy(tpc, _T("["));
	_tcscat(tpc, topic);
	_tcscat(tpc, _T("]"));
	fp = _tfopen(ini_file, _T("r"));
	if (!fp) 
	{
		return FALSE;
	}
	while(!feof(fp))
	{
		if (_fgetts(line_rec, 199, fp) == NULL)
		{
			continue;
		}
		if (XExport::CT_strnth(line_rec, 1, line_r) == NULL)
		{
			continue;
		}
		if (line_r[0] == _T(';'))
		{
			continue;
		}
		
		if (_tcsicmp(tpc, line_r) == 0) 
		{
			while(!feof(fp))
			{ //Under this topic
				if (_fgetts(line_rec, 199, fp) == NULL 
					|| XExport::CT_strnth(line_rec, 1, line_r) == NULL 
					|| line_r[0] == _T(';') )
				{
					continue;
				}

				if (line_r[0] == _T('['))
				{ 
					fclose(fp);
					return TRUE;
				}

				if (CT_ini_item(line_rec, 1, id))
				{
					p = (struct INI_struct *) malloc(sizeof(struct INI_struct));
					if (*res == NULL)
					{
						*res = last = p;
					}
					else last->next = p;
					p->next = NULL;
					p->desc_handle = (TCHAR *)malloc((_tcslen(id)+1)*sizeof(TCHAR));
					_tcscpy(p->desc_handle, id);
					if (CT_ini_item(line_rec, 2, val)) 
					{
						p->desc_value = (TCHAR *)malloc((_tcslen(val)+1)*sizeof(TCHAR));
						_tcscpy(p->desc_value, val);
					}
					else 
					{
						p->desc_value = NULL;
					}
					last = p;
				}
			}
			fclose(fp);
			return TRUE;
		}
	}
	
	fclose(fp);
	return FALSE;
}

//  INI tools: get description value
//  ini_file -- the file *.ini
//  topic -- the topic(section) name
//  item_id -- the description handle
//  item_value -- the result description value
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
int XExport::CT_get_INIA(const TCHAR *ini_file, const TCHAR *topic, const TCHAR *item_id, TCHAR *item_value)
{
	TCHAR id[80], val[80], line_rec[200];
	TCHAR tpc[80], line_r[200];
	FILE *fp;
	_tcscpy(tpc, _T("["));
	_tcscat(tpc, topic);
	_tcscat(tpc, _T("]"));
	fp = _tfopen(ini_file, _T("r"));
	if (!fp)
	{
		return FALSE;
	}
	while(!feof(fp)) 
	{
		if (_fgetts(line_rec, 199, fp) == NULL)
		{
			continue;
		}

		if (XExport::CT_strnth(line_rec, 1, line_r) == NULL)
		{
			continue;
		}
		
		if (line_r[0] == _T(';')) 
		{
			continue;
		}
		
		if (_tcsicmp(tpc, line_r) == 0) 
		{
			while(!feof(fp))
			{ 
				if (_fgetts(line_rec, 255, fp) == NULL 
					|| XExport::CT_strnth(line_rec, 1, line_r) == NULL 
					|| line_r[0] == _T(';') )
				{
					continue;
				}
				
				if (line_r[0] == _T('[')) 
				{
					fclose(fp);
					return FALSE;
				}

				if (CT_ini_item(line_rec, 1, id))
				{
					if (_tcsicmp(item_id, id) == 0)
					{
						if (CT_ini_item(line_rec, 2, val))
						{
							_tcscpy(item_value, val);
						}
						else
						{
							_tcscpy(item_value, _T(""));
						}

						fclose(fp);
						return TRUE;
					}
				}
			}
		}
	}
	
	fclose(fp);
	return FALSE;
}

//  INI tools: get description value
//  fp -- the file pointer of *.ini, readonly file pointer
//  topic -- the topic(section) name
//  item_id -- the description handle
//  item_value -- the result description value
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
int XExport::CT_get_INIB(FILE *fp, const TCHAR *topic, const TCHAR *item_id, TCHAR *item_value)
{
	TCHAR id[80], val[80], line_rec[200];
	TCHAR tpc[80], line_r[200];
	
	_tcscpy(tpc, _T("["));
	_tcscat(tpc, topic);
	_tcscat(tpc, _T("]"));
	fseek(fp, 0L, SEEK_SET);
	while(!feof(fp)) 
	{
		if (_fgetts(line_rec, 199, fp) == NULL) 
		{
			continue;
		}

		if (XExport::CT_strnth(line_rec, 1, line_r) == NULL)
		{
			continue;
		}

		if (line_r[0] == _T(';'))
		{
			continue;
		}
		
		if (_tcsicmp(tpc, line_r) == 0)
		{
			while(!feof(fp))
			{ //Under this topic
				if (_fgetts(line_rec, 255, fp) == NULL 
					|| XExport::CT_strnth(line_rec, 1, line_r) == NULL 
					|| line_r[0] == _T(';') )
				{
					continue;
				}

				if (line_r[0] == _T('[')) 
				{
					return FALSE;
				}
				
				if (CT_ini_item(line_rec, 1, id)) 
				{
					if (_tcsicmp(item_id, id) == 0) 
					{
						if (CT_ini_item(line_rec, 2, val))
						{
							_tcscpy(item_value, val);
						}
						else
						{
							_tcscpy(item_value, _T(""));
						}
						return TRUE;
					}
				}
			}
		}
	}
	
	return FALSE;
}

// INI tools: get description value
//  buf -- the result buffers
//  desc_handle -- the description handle
//  Return:
//    the description value if not NULL;
TCHAR * XExport::CT_get_INI2(const struct INI_struct *buf, const TCHAR *desc_handle)
{
	const struct INI_struct *p;
	
	for (p = buf; p != NULL; p = p->next) 
	{
		if (_tcscmp(desc_handle, p->desc_handle) == 0) 
		{
			return p->desc_value;
		}
	}
	return NULL;
}

//  INI tools: set description value
//  ini_file -- the file *.ini
//  topic -- the topic(section) name
//  item_id -- the description handle
//  item_value -- the description value
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
//  Note: if no such item exist in INI file, the create the item
int XExport::CT_set_INI(const TCHAR *ini_file, const TCHAR *topic, const TCHAR *item_id, const TCHAR *item_value)
{
	TCHAR id[80], line_rec[200];
	TCHAR tpc[80], line_r[200];
	FILE *fp1, *fp2;
	
	_tcscpy(tpc, _T("["));
	_tcscat(tpc, topic);
	_tcscat(tpc, _T("]"));
	CT_cp_file(ini_file, _T("temp$$$$.tmp"));
	fp1 = _tfopen(_T("temp$$$$.tmp"), _T("r"));
	fp2 = _tfopen(ini_file, _T("w"));
	if (fp1 == NULL || fp2 == NULL) 
	{
		return 0;
	}
	while(!feof(fp1)) 
	{
		if (_fgetts(line_rec, 199, fp1) == NULL)
		{
			continue;
		}

		if (XExport::CT_strnth(line_rec, 1, line_r) == NULL) 
		{
			_ftprintf(fp2, _T("\n"));
			continue;
		}
		
		if (_tcsicmp(tpc, line_r) == 0)
		{
			_ftprintf(fp2, line_rec);
			while(!feof(fp1)) 
			{ //Under this topic
				if (_fgetts(line_rec, 199, fp1) == NULL) 
				{
					continue;
				}
				if (XExport::CT_strnth(line_rec, 1, line_r) == NULL) 
				{
					_ftprintf(fp2, _T("\n"));
					continue;
				}
				if (line_r[0] == _T('[')) 
				{ // Add
					_ftprintf(fp2, _T("%s = %s\n"), item_id, item_value);
					_ftprintf(fp2, line_rec);
					break;
				}
				if (CT_ini_item(line_rec, 1, id) == TRUE) 
				{ // replace
					if (_tcsicmp(item_id, id) == 0) 
					{
						_ftprintf(fp2, _T("%s = %s\n"), item_id, item_value);
						break;
					}
				}
				_ftprintf(fp2, line_rec);
			}
		}
		else
		{
			_ftprintf(fp2, line_rec);
		}
		
	}
	fclose(fp1);
	fclose(fp2);
	_tremove(_T("temp$$$$.tmp"));
	return TRUE;
}

//  INI tools: set sereral descriptions under a topic
//  ini_file -- the file *.ini
//  topic -- the topic(section) name
//  item_id -- the description handle
//  item_value -- the description value
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
//  Note: if no such item exist in INI file, the create the item
int XExport::CT_set_INIB(const TCHAR *ini_file, const TCHAR *topic, const struct INI_struct *desc)
{
	TCHAR id[80], line_rec[200];
	TCHAR tpc[80], line_r[200];
	FILE *fp1, *fp2;
	const struct INI_struct *ip;
	int rep_tag;
	
	_tcscpy(tpc, _T("["));
	_tcscat(tpc, topic);
	_tcscat(tpc, _T("]"));
	CT_cp_file(ini_file, _T("temp$$$$.tmp"));
	fp1 = _tfopen(_T("temp$$$$.tmp"), _T("r"));
	fp2 = _tfopen(ini_file, _T("w"));
	if (fp1 == NULL || fp2 == NULL) 
	{
		return 0;
	}
	while(!feof(fp1))
	{
		if (_fgetts(line_rec, 199, fp1) == NULL)
		{
			continue;
		}
		if (XExport::CT_strnth(line_rec, 1, line_r) == NULL) 
		{
			_ftprintf(fp2, _T("\n"));
			continue;
		}
		
		if (_tcsicmp(tpc, line_r) == 0) 
		{ // 找到 Topic
			_ftprintf(fp2, line_rec);
			for (ip = desc; ip != NULL; ip = ip->next)
			{
				_ftprintf(fp2, _T("%s = %s\n"), ip->desc_handle, ip->desc_value);
			}
			while(!feof(fp1)) 
			{ //Under this topic
				if (_fgetts(line_rec, 199, fp1) == NULL) 
				{
					continue;
				}

				if (XExport::CT_strnth(line_rec, 1, line_r) == NULL) 
				{
					_ftprintf(fp2, _T("\n"));
					continue;
				}
				
				if (line_r[0] == _T('['))  
				{
					_ftprintf(fp2, line_rec);
					break; //  End This Topic and start another topic
				}
				rep_tag = 0;
				if (CT_ini_item(line_rec, 1, id) == TRUE)
				{
					for (ip = desc; ip != NULL; ip = ip->next)
					{
						if (_tcsicmp(ip->desc_handle, id) == 0)
						{
							rep_tag = 1;
							break;
						}
					}
					if (rep_tag)
					{
						continue;  // has been replaced, skip it
					}
				}
				_ftprintf(fp2, line_rec);       // keep it
			}
		}
		else
		{
			_ftprintf(fp2, line_rec);     // Continue Writing
		}
	}
	fclose(fp1);
	fclose(fp2);
	_tremove(_T("temp$$$$.tmp"));
	return TRUE;
}

// 释放 INI描述链表
int XExport::CT_free_INIs(struct INI_struct *res)
{
	struct INI_struct *p = res, *nextp;
	while(p) 
	{
		nextp = p->next;
		free(p->desc_handle);
		free(p->desc_value);
		free(p);
		p = nextp;
	}
	return TRUE;
}

// Get ini item for string like '<i1 >= <i2>,<i3>...'
//  string -- the full description item
//  i -- the subitem index based on 1
//  item -- the result subitem
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
int XExport::CT_ini_item(const TCHAR *string, int i, TCHAR *item)
{
	int c = _T('=');
	TCHAR *ip, str1[200];
	_tcscpy(str1, string);
	ip = str1;
	while(*ip)
	{
		if (*ip == _T('\n')) 
		{
			*ip = _T('\0');
			break;
		}
		ip++;
	}
	
	ip = _tcschr(str1, c);
	if (ip)
	{
		if (i == 1)
		{
			*ip = _T('\0');
			_tcscpy(item, str1);
		}
		else
		{
			ip++;
			_tcscpy(item, ip);
		}
		return TRUE;
	}
	return FALSE;
}

// Copy file from f1 to f2
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
int XExport::CT_cp_file(const TCHAR *f1, const TCHAR *f2)
{
	FILE *fp1,*fp2;
	long fsize;
	long cursize;
	TCHAR buf[501];
	if ((fp1 = _tfopen(f1,_T("rb"))) == NULL)
	{
		return FALSE;
	}
	//remove(f2);
	fp2 = _tfopen(f2,_T("wb"));
	if (!fp2)
	{
		fclose(fp1);
		return FALSE;
	}
	
	fseek(fp1,0L,2);
	fsize = ftell(fp1);
	fseek(fp1,0L,0);
	while (1) 
	{
		cursize = ftell(fp1);
		long size = cursize+500*sizeof(TCHAR);
		if (size>fsize) 
		{
			fread(buf, sizeof(TCHAR), (int)(fsize-cursize),fp1);
			fwrite(buf,sizeof(TCHAR), (int)(fsize-cursize),fp2);
			break;
		}
		else 
		{
			fread(buf,sizeof(TCHAR),500,fp1);
			fwrite(buf,sizeof(TCHAR),500,fp2);
		}
	}
	fclose(fp1);
	fclose(fp2);
	return TRUE;
}

//  translate a integer to a string, such as 3 --> _T("3").
//  num -- source integer
//  nn -- object string
//  return:
//     NULL -- error detected
//     other -- normal case
int XExport::CT_itoa(int num, TCHAR *nn)
{
	int r, dec;
	TCHAR s, str[10], ss[10];
	
	if (num < 0)
	{
		num = abs(num);
		_tcscpy(nn, _T("-"));
	}
	else 
	{
		nn[0] = _T('\0');
	}
	
	r = num % 10;
	dec = num / 10;
	s = 48 + r;
	
	str[0] = s;
	str[1] = _T('\0');
	while(dec)
	{
		r = dec % 10;
		dec  = dec / 10;
		s = 48 + r;
		ss[0] = s;
		ss[1] = _T('\0');
		_tcscat(ss,str);
		_tcscpy(str,ss);
	}
	_tcscat(nn, str);
	return TRUE;
}

// 改变字符串长度
// str -- the object string
// len -- the expected length
// Return:
//   TRUE -- normal case
//   FALSE -- error detected
int XExport::CT_stradj(TCHAR *str, int len)
{
	TCHAR *p;
	int i, slen, dlen;
	
	slen = _tcslen(str);
	dlen = len - slen;
	p = str + slen;
	if (dlen > 0) 
	{
		for (i = 0; i < dlen; i++) 
		{
			*p = _T(' ');
			p++;
		}
		*p = _T('\0');
	}
	else
	{
		*(p - dlen) = _T('\0');
	}
	
	return TRUE;
}

// 改变向量格式从点格式到长度，角度格式
// vt -- 向量
// direction -- 向量角度（弧度单位）
// dist -- 向量长度
// 返回值:
//   TRUE -- 正常
//   FALSE -- 错误
int XExport::CT_XYZtoRsita(const ads_point vt, double *direct, double *dist)
{
	*dist = sqrt(vt[0] * vt[0] + vt[1] * vt[1]);
	if (fabs(vt[0] / (*dist)) < 1.0E-4) 
	{
		if (vt[1] > 0.0)
		{
			*direct = PI / 2.0;
		}
		else
		{
			*direct = 1.5 * PI;
		}
	}
	else 
	{
		*direct = atan(vt[1] / vt[0]);
		if (vt[0] < 0.0) 
		{
			*direct += PI; //2，4象限
		}

		if (*direct < -1.0E-6)
		{
			*direct += 2.0 * PI;
		}
	}

	return TRUE;
}

//	三点确定的平面法向量
//  pt1, pt2, pt3 -- 决定一个平面的三个点
//  result -- 平面向量
int XExport::CT_vector_plan3p(const ads_point pt1, const ads_point pt2, const ads_point pt3, ads_vector result)
{
	double a1, a2, a3, b1, b2, b3;

	a1 = pt2[0] - pt1[0];
	a2 = pt2[1] - pt1[1];
	a3 = pt2[2] - pt1[2];

	b1 = pt3[0] - pt1[0];
	b2 = pt3[1] - pt1[1];
	b3 = pt3[2] - pt1[2];

	result[0] = a2 * b3 - a3 * b2;
	result[1] = a3 * b1 - a1 * b3;
	result[2] = a1 * b2 - a2 * b1;

	if (fabs(result[0]) < 0.00001 && fabs(result[1]) < 0.00001
		&& fabs(result[2]) < 0.00001) 
	{
		return FALSE;
	}

	return TRUE;
}

//	由点和法向量计算平面的标准方程
//	参数:  pt--点;   vt--向量
//  结果:      plan--存储平面的标准参数
//  返回值:
int XExport::CT_plan_equation(const ads_point pt, const ads_vector vt, struct plan_para *plan)
{
	plan->A = vt[0];
	plan->B = vt[1];
	plan->C = vt[2];
	plan->D = 0.0 - (vt[0] * pt[0] + vt[1] * pt[1] + vt[2] * pt[2]);

	return TRUE;
}

// 求线与平面的交点
// 参数: pt1, pt2 -- 线的两个端点
//       plan -- 平面
// 结果: result -- 交点
int XExport::CT_inter_line_plan1(const ads_point pt1, const ads_point pt2, const struct plan_para *plan, ads_point result)
{
	double l, m, n, t;
	double mid_var1, mid_var2;

	l = pt2[0] - pt1[0];
	m = pt2[1] - pt1[1];
	n = pt2[2] - pt1[2];

	mid_var1 = l * (plan->A) + m * (plan->B) + n * (plan->C);
	if (fabs(mid_var1) < 0.000001) 
	{
		return FALSE;
	}

	mid_var2 = (plan->D) + pt1[0] * (plan->A) + pt1[1] * (plan->B) + pt1[2] * (plan->C);
	t = 0.0 - mid_var2 / mid_var1;

	result[0] = pt1[0] + l * t;
	result[1] = pt1[1] + m * t;
	result[2] = pt1[2] + n * t;

	return TRUE;
}

// 求线与平面的交点
// 参数: pt1 -- 线上一点
//       vt -- 线的方向向量
//       plan -- 平面
// 结果: result -- 交点
int XExport::CT_inter_line_plan2(const ads_point pt1, const ads_vector vt, const struct plan_para *plan,   ads_point result)
{
	double l, m, n, t;
	double mid_var1, mid_var2;

	//  直线的参数方程
	l = vt[0];
	m = vt[1];
	n = vt[2];

	mid_var1 = l * (plan->A) + m * (plan->B) + n * (plan->C);
	if (fabs(mid_var1) < 0.000001) 
	{
		return FALSE;
	}

	mid_var2 = (plan->D) + pt1[0] * (plan->A) + pt1[1] * (plan->B) + pt1[2] * (plan->C);
	t = 0.0 - mid_var2/mid_var1;

	result[0] = pt1[0] + l * t;
	result[1] = pt1[1] + m * t;
	result[2] = pt1[2] + n * t;

	return TRUE;
}

// 点到平面的投影
// 参数: pt -- 点
//       plan -- 平面
// 结果: qt -- 投影点
int XExport::CT_point_prj_plan(const ads_point pt, const struct plan_para *plan,  ads_point qt)
{
	ads_vector vt;

	vt[0] = plan->A;
	vt[1] = plan->B;
	vt[2] = plan->C;

	return  XExport::CT_inter_line_plan2(pt, vt, plan, qt);
}

// 求两向量的夹角
double XExport::CT_VectorAngle(ads_vector pt1, ads_vector pt2)
{
	double a, b, c, d, ang;
	a = pt1[0] * pt1[0] + pt1[2] * pt1[2] + pt1[1] * pt1[1];
	b = pt2[0] * pt2[0] + pt2[2] * pt2[2] + pt2[1] * pt2[1];
	c = CT_VectorDotPlus(pt1,pt2);

	if ((a <= 0.0001) || (b <= 0.0001)) 
	{
		return 0.0;
	}

	d = c / (sqrt(a * b));

	if (CT_RealEqual(d, 1.0, 1E-5)) 
	{
		return 0.0;
	}
	else if (CT_RealEqual(d, -1.0, 1E-5)) 
	{
		return PI;
	}

	ang = acos(d);

	return ang;
}

int XExport::CT_Inverse_mat(double  *A, int order, double ep)
{
	int i, j, k, l, i2, j2, k1, k2, *me, *mf;
	double y, w, *b, *c;

	if ((b = (double *)malloc(order * sizeof(double))) == NULL)
	{
		return 0;
	}

	if ((c = (double *)malloc(order * sizeof(double))) == NULL)
	{
		return 0;
	}

	if ((me = (int *)malloc(order * sizeof(int))) == NULL)
	{
		return 0;
	}

	if ((mf = (int *)malloc(order * sizeof(int))) == NULL) 
	{
		return 0;
	}

	int nRet = TRUE;
	for (k = 0; k < order; k++) 
	{
		for (i = k, y = 0; i < order; i++)
		{	
			for (j = k; j < order; j++)
			{
				if (fabs(A[j * order + i]) > fabs(y)) 
				{
					y = A[j * order + i];
					i2 = i; 
					j2 = j;
				}
			}
		}

		if (fabs(y) < ep) 
		{
			nRet = FALSE;
			break;
		}

		if (i2 != k)
		{
			for (j = 0; j < order; j++) 
			{
				w = A[j * order + i2];
				A[j * order + i2] = A[j * order + k];
				A[j * order + k] = w;
			}
		}

		if (j2 != k)
		{
			for (j = 0; j < order; j++) 
			{
				w = A[j2 * order + j];
				A[j2 * order + j] = A[k * order + j];
				A[k * order + j] = w;
			}
		}

		me[k] = i2;
		mf[k] = j2;

		for (j = 0; j < order; j++) 
		{
			if (j == k) 
			{
				b[j] = 1.0 / y;
				c[j] = 1.0;
			}
			else 
			{
				b[j] = -A[j * order + k] / y;
				c[j] = A[k * order + j];
			}

			A[k * order + j] = 0.0;
			A[j * order + k] = 0.0;
		}

		for (i = 0; i < order; i++)
		{
			for (j = 0; j < order; j++)
			{
				A[j * order + i] = A[j * order + i] + c[i] * b[j];
			}
		}
	}

	for (l = 0; l < order; l++) 
	{
		k = order - l - 1;
		k1 = me[k];
		k2 = mf[k];

		if (k1 != k)
		{
			for (i = 0; i < order; i++) 
			{
				w = A[k1 * order + i];
				A[k1 * order + i] = A[k * order + i];
				A[k * order + i] = w;
			}
		}

		if (k2 != k)
		{
			for (j = 0; j < order; j++) 
			{
				w = A[j * order + k2];
				A[j * order + k2] = A[j * order + k];
				A[j * order + k] = w;
			}
		}
	}

	free(b);
	free(c);
	free(me);
	free(mf);

	return nRet;
}

//  change a string to alphabet string
//  str -- the source string
//  res -- the result string
//  res_size -- the size of the result string buffer
//  Return:
//    TRUE -- normal case
//    FALSE -- error detected
int XExport::CT_alphabet_str(const TCHAR *str, TCHAR *res, int res_size)
{
	int i;
	int nStrLen = _tcslen(str);
	for (i = 0; i<nStrLen; i++)
	{
		if (i == res_size)
		{
			res[res_size-1] = _T('\0'); 
			return TRUE; 
		}
		res[i] = abs(str[i]%52);
		if (res[i]<26)
		{
			res[i] = res[i] + 65;  // toloupper
		}
		else
		{
			res[i] = res[i] + 71;   // tolower
		}
	}
	res[i] = _T('\0');
	return TRUE;
}

// 清除字符数组
//  strbeg -- 字符缓冲区的起始地址
//  strsize -- 要清零的缓冲区的大小
void XExport::CT_clear_strbuf(char *strbeg, int strsize)
{
	int i;
	for (i = 0; i<strsize; i++) 
	{
		strbeg[i] = 0;
	}
}

// 去除文件名的路径,  (并不改变 FileName串)
// 返回指向文件名的位置,
//  如: FileName = _T("d:\abc\exam.dat"), 返回 _T("exam.dat")
TCHAR * XExport::CT_NoPath_FileName(TCHAR *FileName)
{
	int i;
	for (i = _tcslen(FileName)-1; i >= 0; i--) 
	{
		if (FileName[i] == _T('\\')) 
		{
			return &FileName[i+1];
		}
	}
	return FileName;
}


void XExport::get_matrix(ads_point pt1,ads_point pt2,ads_point pt3, ads_matrix tran_mt)
{
	double vsin,vcos,c;
	ads_point t_pt2,t_pt3,r1_pt2,r1_pt3,r2_pt3,pt10,pt20,pt30;
	ads_matrix  Mt,Mrx1,Mrx2,Mrz,M1,M2;

	Cpoint(pt10,pt1);
	Cpoint(pt20,pt2);
	Cpoint(pt30,pt3);

	AT_InitTranMat(Mt, 0.0 - pt10[X], 0.0 - pt10[Y], 0.0 - pt10[Z]);
	AT_xformpt(Mt,pt20,t_pt2);
	AT_xformpt(Mt,pt30,t_pt3);

	c = sqrt(t_pt2[Y] * t_pt2[Y] + t_pt2[Z] * t_pt2[Z]);
	if (c > 0.01)  
	{
		vsin = 0.0 - t_pt2[Z] / c;
		vcos = t_pt2[Y] / c;
		rota_X_init(Mrx1,vsin,vcos);
	}
	else
	{
		AT_InitIdenMat(Mrx1);
	}

	AT_multiply_matrix(Mrx1,Mt,M1);
	AT_xformpt(Mrx1,t_pt2,r1_pt2);
	AT_xformpt(Mrx1,t_pt3,r1_pt3);

	c = sqrt(r1_pt2[X] * r1_pt2[X] + r1_pt2[Y] * r1_pt2[Y]);
	if (c > 0.01)  
	{
		vsin = 0.0 - r1_pt2[Y] / c;
		vcos = r1_pt2[X] / c;
		rota_Z_init(Mrz,vsin,vcos);
	}
	else
	{
		AT_InitIdenMat(Mrz);
	}

	AT_multiply_matrix(Mrz,M1,M2);
	AT_xformpt(Mrz,r1_pt3,r2_pt3);

	c = sqrt(r2_pt3[Y] * r2_pt3[Y] + r2_pt3[Z] * r2_pt3[Z]);
	if (c > 0.01)  
	{
		vsin = 0.0 - r2_pt3[Z] / c;
		vcos = r2_pt3[Y] / c;
		rota_X_init(Mrx2,vsin,vcos);
	}
	else
	{
		AT_InitIdenMat(Mrx2);
	}

	AT_multiply_matrix(Mrx2,M2,tran_mt);
}


BOOL XExport::IsWindowsNT()
{
	OSVERSIONINFO osVer;
	osVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	VERIFY(GetVersionEx(&osVer) == TRUE);
	return (osVer.dwPlatformId == VER_PLATFORM_WIN32_NT);
}

extern void xdRemoveDupLines(PickSet &ss);
int XExport::HandleCurveDup(PickSet &ss)
{
	xdRemoveDupLines(ss);
	init_cir(ss);
	init_arc(ss);
	ads_redraw(NULL,0);
	return RTNORM;
}

void XExport::MatrixMultiply(ads_matrix result, ads_matrix m1, ads_matrix m2, ...)
{
	ads_matrix mat1, mat2, res;
	memcpy(mat1, m1, sizeof(ads_matrix));
	memcpy(mat2, m2, sizeof(ads_matrix));
	AT_multiply_matrix(m1, m2, result);
	memcpy(res, result, sizeof(ads_matrix));
	va_list vlst;
	va_start(vlst, m2);
	while(1) 
	{
		MatrixPointer r = va_arg(vlst, MatrixPointer);
		if (!r)
		{
			break;
		}

		ads_matrix mat;
		memcpy(mat, result, sizeof(ads_matrix));
		AT_multiply_matrix(mat, r, result);
	}
	va_end(vlst);
	return; 
}

int XExport::GetInsertMatrix(const Entity & e, ads_matrix result)
{
	Entity insertEnt = e;
	if (insertEnt.Is(_T("INSERT")) || insertEnt.Is(_T("AEC_BLOCK_INSERT")))
	{
		OPENOBJ_BEGIN(insertEnt,AcDb::kForRead,AcDbBlockReference,pBlock)
		if (pBlock != NULL)
		{
			AsAdsMatrix(pBlock->blockTransform(),result);
			return RTNORM;
		}
		OPENOBJ_END()
	}
	
	if (!insertEnt.Is(_T("AEC_MVINSERT"))) 
	{
		return RTERROR;
	}
	
	XPoint insPt;
	double rot, sx = 1, sy = 1, sz = 1;
	insertEnt.GetData(10, insPt);   insertEnt.GetData(50, &rot);
	insertEnt.GetData(41, &sx); insertEnt.GetData(42, &sy); insertEnt.GetData(43, &sz);

	TCHAR blk[80];
	insertEnt.GetData(2, blk);
	
	XBlockTable blkTab(blk);
	// XPoint mv = insPt-blkTab.base;
	// 先移动base到原点, Scale, Rotation, 再平移到insPt
	ads_matrix mvMat1 =  {
		{1, 0, 0, -blkTab.base.x},
		{0, 1, 0, -blkTab.base.y},
		{0, 0, 1, -blkTab.base.z},
		{0, 0, 0, 1},
	};
	ads_matrix sclMat = {
		{sx, 0, 0, 0},
		{0,  sy, 0, 0},
		{0,  0,  sz, 0},
		{0, 0, 0, 1},
	};
	ads_matrix rotMat = {
		{cos(rot), -sin(rot), 0, 0},
		{sin(rot),  cos(rot), 0, 0},
		{0,         0,        1, 0},
		{0,         0,        0, 1},
	};
	
	ads_matrix mvMat2 =  {
		{1, 0, 0, insPt.x},
		{0, 1, 0, insPt.y},
		{0, 0, 1, insPt.z},
		{0, 0, 0, 1},
	};
	
	XExport::MatrixMultiply(result, mvMat2, rotMat, sclMat, mvMat1, NULL);
	return RTNORM;
}

 int XExport::GetCirDivNum(double r, double h)
{
	ASSERT(r>0.0 && h>0.0);
	double dVal = 1.0-h/r;
	if (dVal<1.0E-6)
	{
		return 1;
	}
	double nArgCos = acos(dVal);
	int nVal = AS_INT(PI/nArgCos);
	if (nVal<1)
	{
		nVal = 1;
	}
	else if (nVal > g_nMaxCirDivNum)
	{
		nVal = g_nMaxCirDivNum;
	}

	return nVal;
}

 int XExport::ACmpLabel(const char* sLabel1,const char* sLabel2)
{
	AString s1(sLabel1),s2(sLabel2);
	AString sName1(s1.Length()),sName2(s2.Length());
	AString sDigit1(s1.Length()),sDigit2(s2.Length());
	
	long len1 = s1.Length();
	for (long i = 0;i<len1;i++)
	{
		char c = s1.GetAt(i);
		if (c >= '0'&&c <= '9')
		{//数字
			sDigit1 << c;
		}
		else
		{//字符
			sName1 << c;
			if (c<0)
			{//汉字占两位
				sName1 << s1[++i];
			}
		}
	}
	
	long len2 = s2.Length();
	for (int i = 0;i<len2;i++)
	{
		char c = s2.GetAt(i);
		if (c >= '0'&&c <= '9')
		{//数字
			sDigit2 << c;
		}
		else//字符
		{
			sName2 << c;
			if (c<0)
			{//汉字占两位
				sName2<<s2[++i];
			}
		}
	}
	int iRet = strcmp(sName1,sName2);
	if (iRet<0)
	{
		return -1;
	}
	else if (iRet>0)
	{
		return 1;
	}
	else
	{
		int num1 = atoi(sDigit1),num2 = atoi(sDigit2);
		if (num1<num2)
		{
			return -1;
		}
		else if (num1>num2)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
}

 int XExport::UCmpLabel(const wchar_t* sLabel1,const wchar_t* sLabel2)
{
	UString s1(sLabel1),s2(sLabel2);
	UString sName1(s1.Length()),sName2(s2.Length());
	UString sDigit1(s1.Length()),sDigit2(s2.Length());
	
	long len1 = s1.Length();
	for (long i = 0;i<len1;i++)
	{
		wchar_t c = s1.GetAt(i);
		if (c >= '0'&&c <= '9')
		{//数字
			sDigit1<<c;
		}
		else//字符
		{
			sName1<<c;
			if (c<0)
			{//汉字占两位
				sName1<<s1[++i];
			}
		}
	}
	
	long len2 = s2.Length();
	for (int i = 0;i<len2;i++)
	{
		wchar_t c = s2.GetAt(i);
		if (c >= '0'&&c <= '9')
		{//数字
			sDigit2<<c;
		}
		else//字符
		{
			sName2<<c;
			if (c<0)
			{//汉字占两位
				sName2<<s2[++i];
			}
		}
	}
	int iRet = wcscmp(sName1,sName2);
	if (iRet<0)
	{
		return -1;
	}
	else if (iRet>0)
	{
		return 1;
	}
	else
	{
		int num1 = _wtoi(sDigit1),num2 = _wtoi(sDigit2);
		if (num1<num2)
		{
			return -1;
		}
		else if (num1>num2)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
}

 char * XExport::strnew(const char *src)
{
	if (src == NULL)
	{
		return NULL;
	}
	
	int len = strlen(src)+1;
	char *res = new char[len];
	memcpy(res, src, len*sizeof(char));
	return res;
}

 wchar_t * XExport::wstrnew(const wchar_t *src)
{
	if (src == NULL) 
	{
		return NULL;
	}
	
	int len = wcslen(src)+1;
	wchar_t *res = new wchar_t[len];
	memcpy(res, src, len*sizeof(wchar_t));
	return res;
}

 char * XExport::strchr_new(const char *string, int c,bool bToFile)
{
	char *pstr = (char*)strchr(string,c);
	if (pstr == NULL)
	{
		return NULL;
	}
	char *pstr1 = NULL,*pstr2 = NULL;
	pstr1 = ++pstr;
	while(1)
	{
		pstr2 = strchr(pstr1,c);
		if (pstr2 == NULL)
		{
			//文件名不能有系列字符
			if (bToFile && c != '\\' && c != '/' && c != ':' && c != '*' && c != '?' && c != '"' && c != '<' && c != '>' && c != '|')
			{
				if ((pstr2 = strchr(pstr1,'\\')) != NULL)
				{
					return NULL;
				}
			}
			return --pstr;
		}
		else
		{
			pstr = pstr2;
			pstr1 = ++pstr;
		}
	}
}

 wchar_t * XExport::wstrchr_new(const wchar_t *string, int c,bool bToFile)
{
	wchar_t *pstr = (wchar_t*)wcschr(string,c);
	if (pstr == NULL)
	{
		return NULL;
	}
	wchar_t *pstr1 = NULL,*pstr2 = NULL;
	pstr1 = ++pstr;
	while(1)
	{
		pstr2 = wcschr(pstr1,c);
		if (pstr2 == NULL)
		{
			if (bToFile && c != '\\' && c != '/' && c != ':' && c != '*' && c != '?' && c != '"' && c != '<' && c != '>' && c != '|')
			{
				if ((pstr2 = wcschr(pstr1,'\\')) != NULL)
				{
					return NULL;
				}
			}
			return --pstr;
		}
		else
		{
			pstr = pstr2;
			pstr1 = ++pstr;
		}
	}
}

// General tools
// substr string from another string
//  <=  from < to, the dest include from but not include to
wchar_t * XExport::StrCpy(wchar_t *dest, const wchar_t *from, const wchar_t *to)
{
	for (const wchar_t *p = from; p != to && *p; p++, dest++)
	{
		*dest = *p;
	}
	*dest = 0;
	return dest;
}

// General tools
// substr string from another string
//  <=  from < to, the dest include from but not include to
char * XExport::StrCpy(char *dest, const char *from, const char *to)
{
	for (const char *p = from; p != to && *p; p++, dest++)
	{
		*dest = *p;
	}
	*dest = 0;
	return dest;
}

 void XExport::getdate(STDate *curDate)
{
	TCHAR sDate[9] = _T(""), mm[3] = _T(""), dd[3] = _T(""), yy[3] = _T("");
	_tstrdate(sDate);
	mm[0] = sDate[0];
	mm[1] = sDate[1];
	mm[2] = 0;

	dd[0] = sDate[3];
	dd[1] = sDate[4]; 
	dd[2] = 0;

	yy[0] = sDate[6];
	yy[1] = sDate[7];
	yy[2] = 0;
	if (yy[0]<_T('9')) 
	{
		if (yy[0] == _T('0'))
		{
			curDate->da_year = 2000+yy[1]-_T('0');
		}
		else
		{
			curDate->da_year = 2000+_ttoi(yy);
		}
	} 
	else 
	{
		if (yy[0] == _T('0')) 
		{
			curDate->da_year = 1900+yy[1]-_T('0');
		}
		else
		{
			curDate->da_year = 1900+_ttoi(yy);
		}
	}
	if (dd[0] == _T('0'))  
	{
		curDate->da_day = dd[1]-_T('0');
	}
	else  
	{
		curDate->da_day = _ttoi(dd);
	}
	if (mm[0] == _T('0')) 
	{
		curDate->da_mon = mm[1]-_T('0');
	}
	else 
	{
		curDate->da_mon = _ttoi(mm);
	}
}

 STDate XExport::operator - (STDate &d1, STDate &d2)
{
	STDate res;
	int mon = 0, year = 0;
	res.da_day  = d1.da_day - d2.da_day;
	if (res.da_day<0) 
	{
		res.da_day += 30; 
		mon = -1; 
	}
	res.da_mon = d1.da_mon - d2.da_mon+mon;
	if (res.da_mon<0) 
	{
		res.da_mon += 12; 
		year = -1; 
	}
	res.da_year = d1.da_year - d2.da_year + year;
	return res;
}

//yyyymmdd
 void XExport::GetDate(TCHAR *pDate)
{
	STDate curDate;
	XExport::getdate(&curDate);

	TCHAR dd[3] = _T(""), mm[3] = _T("");
	dd[2] = mm[2] = 0;
	_itot(curDate.da_mon, mm, 10);
	_itot(curDate.da_day, dd, 10);
	if (curDate.da_mon<10)
	{ 
		mm[1] = mm[0];
		mm[0] = _T('0');
	}
	if (curDate.da_day<10)
	{
		dd[1] = dd[0]; 
		dd[0] = _T('0'); 
	}
	_stprintf(pDate, _T("%d%s%s"), curDate.da_year, mm, dd);
}

//yyyymmdd
 int XExport::StrToDate(const TCHAR *strDate, STDate &res )
{
	if (_tcslen(strDate) != 8)
	{
		return RTERROR;
	}
	TCHAR year[5], mon[3], day[3];
	for (int i = 0; i<4; i++)
	{
		year[i] = strDate[i];
	}
	year[4] = 0;
	mon[0] = strDate[4]; mon[1] = strDate[5]; mon[3] = 0;
	day[0] = strDate[6]; day[1] = strDate[7]; day[3] = 0;
	res.da_year = _ttoi(year);
	res.da_mon = _ttoi(mon);
	res.da_day = _ttoi(day);
	return RTNORM;
}

 int XExport::StringToList(const TCHAR *s, XStringList &res)
{
	TCHAR sWord[128] = _T("");
	int i = 1;
	while(XExport::CT_strnth(s, i, sWord))
	{
		res.Append(XExport::tstrnew(sWord));
		i++;
	}
	return RTNORM;
}

Acad::ErrorStatus XExport::ExplodeAcis(const AcDbEntity *pEnt, AcDbVoidPtrArray &entSet)
{
	XPushVar<int> dispsilh(_T("DISPSILH"), 1); //确保隐藏线不露出来
	Acad::ErrorStatus es = Acad::eOk;
	int nOldNum = entSet.length();
	XAsdkCustomWorldDraw dc;
	dc.setDeviation(_AS_SYS_UNIT(g_nCirDeviation));
	
	//	以AsdkCustomWorldDraw调用实体的worldDraw函数并得到实体的外形(shell)数据
	((AcDbEntity *)pEnt)->worldDraw(&dc);
	DList<XAsdkShellData> &lstShell = dc.shellData();
	for (int i = 0; i<lstShell.Length(); i++)
	{
		lstShell[i]->ConvertTo3DFace(entSet);
	}
	
	
	int nInc = entSet.length()-nOldNum;
	if (nInc <= 0)
	{
		es = Acad::eNotApplicable;
	}
	return es;
}

double XExport::GetBulgeBy3Pt(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, const AcGePoint3d& ptSample)
{
	XPoint vecXDir, vecYDir;
	xg_getvar(_T("UCSXDIR"), vecXDir);
	xg_getvar(_T("UCSYDIR"), vecYDir);
	
	AcGeVector3d vecZDir = vecXDir.AsAcGeVector3d().crossProduct(vecYDir.AsAcGeVector3d());
	
	if (ptStart == ptEnd)
	{
		return 0.0;
	}
	
	if (ptStart == ptSample || ptEnd == ptSample)
	{
		return 1.0;
	}
	
	AcGeVector3d vec = ptEnd - ptStart;
	vec.normalize();
	vec.rotateBy(vec.angleTo(ptSample - ptStart), vecZDir);
	
	AcGeCircArc3d arc(ptStart, ptSample, ptEnd);
	AcGePlane plane(ptStart, (ptEnd - ptStart).rotateBy(PI/2.0, vecZDir));
	
	double dLen = ptStart.distanceTo(ptEnd);
	
	//  091118，在调用acos函数之前，首先保证参数值在[-1, 1]范围内
	double dCosValue = 1 - (dLen * dLen) / (2.0 * arc.radius() * arc.radius());
	if (fabs(dCosValue - 1.0) < g_globleSnap)
	{
		dCosValue = 1.0;
	}
	else if (fabs(dCosValue + 1.0) < g_globleSnap)
	{
		dCosValue = -1.0;
	}
	else if (dCosValue > 1.0 + g_globleSnap)
	{
		return 0.0;
	}
	else if (dCosValue < -1.0 - g_globleSnap)
	{
		return 0.0;
	}
	
	//  091118，在调用acos函数之前，首先保证参数值在[-1, 1]范围内
	// 使用了三角函数公式：cos(2α) = 1 - 2*sin(α)
	//	double dAngle = acos(1 - (dLen * dLen) / (2.0 * arc.radius() * arc.radius()));
	double dAngle = acos(dCosValue);
	
	if (IsPointAtSameSide(plane, arc.center(), ptSample))
	{
		dAngle = PI * 2.0 - dAngle;
	}
	
	double dBulge = tan(dAngle / 4.0);
	return ((ptStart + vec * ptSample.distanceTo(ptStart) == ptSample) ? -dBulge : dBulge);
}

// 求由一组曲线组成的边界，返回polyline线，用后需要删除
AcDbCurve* XExport::ConvertCurves2Loops(const AcDbVoidPtrArray& arpCurve, AcDbVoidPtrArray& arpResult)
{
	if (arpCurve.length() <= 0)
	{
		return NULL;
	}
	
	AcDbCurve* pRetCurve = NULL;
	
	AcDbVoidPtrArray arpEnt(arpCurve);
	AcDbCurve* pCurve = (AcDbCurve*)arpEnt.first();
	//  091111，遇到出错的情况，此类型的错误提示，也不能解决问题，推荐还是继续操作下去，减少崩溃
	//	assert(pCurve != NULL && pCurve->isKindOf(AcDbCurve::desc()));
	if (pCurve == NULL || !pCurve->isKindOf(AcDbCurve::desc()))
	{
		return NULL;
	}
	
	arpEnt.removeFirst();
	arpResult.append(pCurve);
	if (pCurve->isClosed())
	{
		pRetCurve = (AcDbCurve*)pCurve->isA()->create();
		CopyObject(*pCurve, *pRetCurve); // 复杂实体可能需要Deepclone
		return pRetCurve;
	}
	
	AcGePoint3d ptStart, ptEnd;
	pCurve->getStartPoint(ptStart);
	pCurve->getEndPoint(ptEnd);
	
	AcGePlane plane;
	AcGePoint3d pt3d;
	AcDbPolyline* pPline;
	double dParam1, dParam2;
	if (pCurve->isKindOf(AcDbLine::desc()))
	{
		plane.set(AcGePoint3d::kOrigin, ((AcDbLine*)pCurve)->normal());
		pPline = new AcDbPolyline;
		assert(pPline != NULL);
		pPline->setNormal(plane.normal());
		pPline->addVertexAt(0, ptStart.convert2d(plane));
		pPline->addVertexAt(1, ptEnd.convert2d(plane));
	}
	else if (pCurve->isKindOf(AcDbArc::desc()))
	{
		plane.set(AcGePoint3d::kOrigin, ((AcDbArc*)pCurve)->normal());
		pPline = new AcDbPolyline;
		assert(pPline != NULL);
		pPline->setNormal(plane.normal());
		pCurve->getStartParam(dParam1);
		pCurve->getEndParam(dParam2);
		pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
		pPline->addVertexAt(0, ptStart.convert2d(plane), XExport::GetBulgeBy3Pt(ptStart, ptEnd, pt3d));
		pPline->addVertexAt(1, ptEnd.convert2d(plane));
	}
	else if (pCurve->isKindOf(AcDbPolyline::desc()))
	{
		plane.set(AcGePoint3d::kOrigin, ((AcDbPolyline*)pCurve)->normal());
		pPline = new AcDbPolyline;
		assert(pPline != NULL);
		CopyObject((const AcDbPolyline&)*pCurve, *pPline);
	}
	else
	{
		pRetCurve = (AcDbCurve*)pCurve->isA()->create();
		CopyObject(*pCurve, *pRetCurve);
		return pRetCurve;
	}
	
	pRetCurve = pPline;
	
	int iLen;
	double dBulge;
	AcGePoint2d pt2d;
	AcGePoint3d pt1, pt2;
	int n, iNum, iIndex;
	while ((iLen = arpEnt.length()) >= 0)
	{
		int i = 0;
		for (i = 0; i < iLen; i++)
		{
			pCurve = (AcDbCurve*)arpEnt[i];
			assert(pCurve != NULL);
			pCurve->getStartPoint(pt1);
			pCurve->getEndPoint(pt2);
			if (pt1 == ptStart)
			{
				if (pCurve->isKindOf(AcDbLine::desc()))
				{
					pPline->addVertexAt(0, pt2.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbArc::desc()))
				{
					pCurve->getStartParam(dParam1);
					pCurve->getEndParam(dParam2);
					pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
					pPline->addVertexAt(0, pt2.convert2d(plane), XExport::GetBulgeBy3Pt(pt2, pt1, pt3d));
				}
				else if (pCurve->isKindOf(AcDbPolyline::desc()))
				{
					iNum = ((AcDbPolyline*)pCurve)->numVerts() - 1;
					for (n = 0; n < iNum; n++)
					{
						((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
						((AcDbPolyline*)pCurve)->getPointAt(n+1, pt2d);
						pPline->addVertexAt(0, pt2d, -dBulge);
					}
				}
				ptStart = pt2;
				arpEnt.removeAt(i);
				arpResult.append(pCurve);
				break;
			}
			else if (pt1 == ptEnd)
			{
				iIndex = pPline->numVerts();
				if (pCurve->isKindOf(AcDbLine::desc()))
				{
					pPline->addVertexAt(iIndex, pt2.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbArc::desc()))
				{
					pCurve->getStartParam(dParam1);
					pCurve->getEndParam(dParam2);
					pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
					//pPline->addVertexAt(iIndex, pt2.convert2d(plane), GetBulgeBy3Pt(pt1, pt2, pt3d));
					//  091111，此情况需要修改ptEnd点的bulge
					pPline->setBulgeAt(iIndex-1, XExport::GetBulgeBy3Pt(pt1, pt2, pt3d));
					pPline->addVertexAt(iIndex, pt2.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbPolyline::desc()))
				{
					iNum = ((AcDbPolyline*)pCurve)->numVerts();
					((AcDbPolyline*)pCurve)->getBulgeAt(0, dBulge);
					pPline->setBulgeAt(iIndex-1, dBulge);
					for (n = 1; n < iNum; n++, iIndex++)
					{
						((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
						((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
						pPline->addVertexAt(iIndex, pt2d, dBulge);
					}
				}
				ptEnd = pt2;
				arpEnt.removeAt(i);
				arpResult.append(pCurve);
				break;
			}
			else if (pt2 == ptStart)
			{
				if (pCurve->isKindOf(AcDbLine::desc()))
				{
					pPline->addVertexAt(0, pt1.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbArc::desc()))
				{
					pCurve->getStartParam(dParam1);
					pCurve->getEndParam(dParam2);
					pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
					pPline->addVertexAt(0, pt1.convert2d(plane), XExport::GetBulgeBy3Pt(pt1, pt2, pt3d));
				}
				else if (pCurve->isKindOf(AcDbPolyline::desc()))
				{
					iNum = ((AcDbPolyline*)pCurve)->numVerts() - 2;
					for (n = iNum; n  >=  0; n--)
					{
						((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
						((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
						pPline->addVertexAt(0, pt2d, dBulge);
					}
				}
				ptStart = pt1;
				arpEnt.removeAt(i);
				arpResult.append(pCurve);
				break;
			}
			else if (pt2 == ptEnd)
			{
				iIndex = pPline->numVerts();
				if (pCurve->isKindOf(AcDbLine::desc()))
				{
					pPline->addVertexAt(iIndex, pt1.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbArc::desc()))
				{
					pCurve->getStartParam(dParam1);
					pCurve->getEndParam(dParam2);
					pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
					pPline->setBulgeAt(iIndex-1, XExport::GetBulgeBy3Pt(pt2, pt1, pt3d));
					pPline->addVertexAt(iIndex, pt1.convert2d(plane));
				}
				else if (pCurve->isKindOf(AcDbPolyline::desc()))
				{
					iNum = ((AcDbPolyline*)pCurve)->numVerts() - 2;
					((AcDbPolyline*)pCurve)->getBulgeAt(iNum, dBulge);
					pPline->setBulgeAt(iIndex-1, -dBulge);
					for (n = iNum; n > 0; n--, iIndex++)
					{
						((AcDbPolyline*)pCurve)->getBulgeAt(n-1, dBulge);
						((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
						pPline->addVertexAt(iIndex, pt2d, -dBulge);
					}
					((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
					pPline->addVertexAt(iIndex, pt2d);
				}
				ptEnd = pt1;
				arpEnt.removeAt(i);
				arpResult.append(pCurve);
				break;
			}
		}

		if (i  >=  iLen)
		{
			break;
		}
	}

	//  091119，判断起点、终点是否相同的精确度改为g_globleSnap
	double dS2EDist = ptStart.distanceTo(ptEnd);
	BOOL bEqual = fabs(dS2EDist) < g_globleSnap;

	// 如果起点、终点相同，去掉终点，减少错误
	if (bEqual)
	{
		int nVertexNum = pPline->numVerts();
		pPline->removeVertexAt(nVertexNum-1);
	}

	//	pPline->setClosed(ptStart == ptEnd);
	pPline->setClosed(bEqual);

	return pRetCurve;
}

//判断应用程序是否被调入
//  AppName -- 应用程序名, 无路径和后缀
//  返回:  0--没有;  1--已调入
 int XExport::AT_loaded(const TCHAR * AppName)
{
	struct resbuf *rb, *apps;
	TCHAR file[_MAX_FNAME], dir[_MAX_DIR], ext[_MAX_EXT], drive[_MAX_DRIVE];
	int flag = 0;
	apps = ads_arxloaded();
	for (rb = apps; rb != NULL; rb = rb->rbnext) 
	{
		_tsplitpath(rb->resval.rstring, drive, dir, file, ext);
		if (_tcsicmp(AppName, file) == 0) 
		{
			flag = 1;
			break;
		}
	}
	ads_relrb(apps);
	
	return flag;
}

// 取得当前图形的文件名(不包括路径和后缀, 如: "DEMO", "TEST1")
// curDwg -- 存放结果
// 注: 结果内存大小不能小于 9 Byte
// Delete the suffix .DWG from ACAD R14
// 为支持长文件名, 取消8个字符的限制
 void XExport::AT_GetCurDwg(TCHAR *curDwg)
{
	TCHAR drive[_MAX_DRIVE],  dir[_MAX_DIR], filename[_MAX_FNAME], ext[_MAX_EXT];
	struct resbuf dwgname;
	int nRet;
	nRet = ads_getvar(_T("DWGNAME"), &dwgname);
	assert(nRet == RTNORM);   
	filename[0] = 0;
	_tsplitpath(dwgname.resval.rstring, drive, dir, filename, ext);
	_tcscpy(curDwg, filename);
	free(dwgname.resval.rstring);
}

//  Reverse the ads_matrix
//  a -- the source matrix
//  aa -- the result matrix
// Return:
//   RTNORM -- normal case
//   RTERROR -- error detected
 int XExport::AT_amatrix(const ads_matrix a, ads_matrix aa)
{
	memcpy(aa, a, sizeof(ads_matrix));
	if (XExport::CT_Inverse_mat(&aa[0][0], 4, 1.0E-9))
	{
		return RTNORM;
	}
	return RTERROR;
}

// Get current viewport Screen corner with WCS
// lowerpt -- lower corner
// upperpt -- upper corner
// Return:
//   RTNORM -- normal case
//   RTERROR -- error detected
 int XExport::AT_ScrCorner(ads_point lowerpt, ads_point upperpt)
{
	struct resbuf screensize, viewsize, viewctr;
	double h, w;
	
	ads_getvar(_T("SCREENSIZE"), &screensize);
	ads_getvar(_T("viewsize"), &viewsize);
	ads_getvar(_T("VIEWCTR"), &viewctr);
	
	XPoint ptUcs = viewctr.resval.rpoint;
	XPoint ptWcs = Ucs2Wcs(ptUcs);
	ptWcs > viewctr.resval.rpoint;
	
	h = viewsize.resval.rreal;
	w = screensize.resval.rpoint[X]/screensize.resval.rpoint[Y]*h;
	Spoint(lowerpt, viewctr.resval.rpoint[X]-w/2.0,
			viewctr.resval.rpoint[Y]-h/2.0,
			viewctr.resval.rpoint[Z]);

	Spoint(upperpt, viewctr.resval.rpoint[X]+w/2.0,
			viewctr.resval.rpoint[Y]+h/2.0,
			viewctr.resval.rpoint[Z]);
	
	return RTNORM;
}


// Get Screen current viewport Size
// width -- view port width
// height -- viewport height
// Return:
//   RTNORM -- normal case
//   RTERROR -- error detected
 int XExport::AT_ScrSize(double *width, double *height)
{
	struct resbuf screensize, viewsize;
	
	ads_getvar(_T("SCREENSIZE"), &screensize);
	ads_getvar(_T("viewsize"), &viewsize);
	
	*height = viewsize.resval.rreal;
	*width = screensize.resval.rpoint[X]/screensize.resval.rpoint[Y]*(*height);
	
	return RTNORM;
}

// Get a name that doesn't exist for a block
//  prefix -- the specific block prefix
//  blk_name -- the result name for the block
 int XExport::AT_get_blkname(const TCHAR *prefix, TCHAR *blk_name)
{
	int j;
	TCHAR name[40];
	TCHAR index[10];
	struct resbuf *ebuf;
	
	for (j = 0; j<1000; j++) 
	{
		_tcscpy(name, prefix);
		_itot(j, index, 10);
		_tcscat(name, index);
		ebuf = ads_tblsearch(_T("BLOCK"), name, 0);
		if (ebuf == NULL) 
		{
			_tcscpy(blk_name, name);
			return RTNORM;
		}
		ads_relrb(ebuf);
	}
	return RTERROR;
}

//  get a node of a resbuf list
//  p -- the head of resbuf list
//  code -- the specific resbuf node dxf code
//  Return:   the address of the resbuf node, if null no such node found.
 struct resbuf * XExport::AT_get_resbuf(struct resbuf *p,int code)
{
	struct resbuf *head2;
	
	for (head2 = p;(head2 != NULL)&&(head2->restype != code);head2 = head2->rbnext);
	
	return (head2);
}


 BOOL XExport::IsMaskBlock(AcDbBlockTableRecord &block, AcRxClass *pClass)
{
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = block.newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && pBlockIterator);
	AcDbEntity *pEnt = NULL;
	BOOL bTrue = FALSE;
	if (pBlockIterator->getEntity(pEnt, AcDb::kForRead) == Acad::eOk) 
	{
		if (pEnt->isA() == pClass) 
		{
			bTrue = TRUE;
		}
		pEnt->close();
	}
	delete pBlockIterator;
	return bTrue;
}

 int XExport::GetProtectCode()
{
	return XGeLib::g_nProtectCode;
}

 struct resbuf * XExport::AT_link_list(struct resbuf *list1, struct resbuf *list2)
{
	struct resbuf *p1, *p, *p2;
	
	p1 = list1;
	p2 = list2;
	
	if(p1 == NULL) 
	{
		return p2;
	}
	
	for(p = p1; p->rbnext != NULL; p = p->rbnext)
	{
		;
	}
	
	p->rbnext = p2;
	
	return p1;
}

int XExport::LimitCycle(int n, int nLen)
{
	if (n < 0) 
	{
		n += nLen;
	}
	else if (n >= nLen)
	{
		n -= nLen;
	}
	else
	{
		return n;
	}
	
	return XExport::LimitCycle(n, nLen);
}

int XExport::IsEqual(double prec, int n, double num1, double num2, ...)
{
	if (!CT_RealEqual(num1, num2, prec))
	{
		return 0;
	}
	
	va_list vlst;
	va_start(vlst, num2);
	int res = 1;
	
	for (int i = 0; i < n - 2; i++) 
	{
		double r = va_arg(vlst, double);
		if (!CT_RealEqual(num1, r, prec)) 
		{
			res = 0;
			break;
		}
	}
	
	va_end(vlst);
	
	return res;
}

int XExport::IsEqual(int n, int num1, int num2, ...)
{
	if (num1 != num2)
	{
		return 0;
	}
	
	va_list vlst;
	va_start(vlst, num2);
	int res = 1;
	for (int i = 0; i < n - 2; i++) 
	{
		int r = va_arg(vlst, int);
		if (num1 != r) 
		{
			res = 0;
			break;
		}
	}
	
	va_end(vlst);
	
	return res;
}

// 初始化平面旋转变换的矩阵
// rotAngle -- 转角(弧度)
// rotMat -- 要被初始化的矩阵
void XExport::AT_InitRotMatrix(double rotAngle, ads_matrix rotMat)
{
//    extern ads_matrix ads_identmat;
    memcpy(rotMat, ads_identmat, sizeof(ads_matrix));
    rotMat[0][0] = cos(rotAngle);
    rotMat[0][1] = -sin(rotAngle);
    rotMat[1][0] = sin(rotAngle);
    rotMat[1][1] = cos(rotAngle);
}

// 初始化单位矩阵
void XExport::AT_InitIdenMat(ads_matrix id)
{
	int i,j;
	
	for (i = 0; i <= 3; i++)
	{
		for (j = 0; j <= 3; j++)
		{
			id[i][j] = 0.0;
		}
	}
	
	for (i = 0; i <= 3; i++)
	{
		id[i][i] = 1.0;
	}
	
	return;
}

// 根据变换点初始化矩阵
//  Tx: X轴方向变换距离
//  Ty: Y轴方向变换距离
//  Tz: Z轴方向变换距离
void XExport::AT_InitTranMat(ads_matrix tran,double Tx,double Ty,double Tz)
{
	XExport::AT_InitIdenMat(tran);
	
	tran[X][T] = Tx;
	tran[Y][T] = Ty;
	tran[Z][T] = Tz;
}

int XExport::AT_multiply_matrix(ads_matrix mat1, ads_matrix mat2, ads_matrix result)
{
	int i,j,k;
	for (j = 0; j <= 3; j++) 
	{
		for (i = 0; i <= 3;i++) 
		{
			result[i][j] = 0.0;
		}
	}
	
	for (j = 0; j <= 3; j++) 
	{
		for (i = 0; i <= 3; i++) 
		{
			for (k = 0; k <= 3;k++) 
			{
				result[i][j] += mat1[i][k] * mat2[k][j];
			}
		}
	}
	
	return 1;
}

// Move this to ADSTOOL.LIB
// 把 pt绕 base旋转 ang 弧度后的结果放回 pt
void XExport::AT_PointRotation(ads_point pt, ads_point base, double ang)
{
	// 先执行平移, 使得base成为原点
	ads_point oldpt;
	ads_matrix moveMat, rotMat;
	Cpoint(oldpt, pt);
	XExport::AT_InitTranMat(moveMat, -base[X], -base[Y], -base[Z]);
	XExport::AT_InitRotMatrix(ang, rotMat);
	AT_xformpt(moveMat, oldpt, pt);  // pt--被平移厚的点
	
	AT_xformpt(rotMat, pt, oldpt);   // oldpt -- 被旋转后的点
	XExport::AT_InitTranMat(moveMat, base[X], base[Y], base[Z]);
	AT_xformpt(moveMat, oldpt, pt);  // pt -- 被恢复平移后的点
}

//  100115，增加了与编组有关的两个全句函数，后续应调整到GEO工程中
// 把一组实体添加成组，若为无名组，pGroupName为_T("*")
int XExport::MakeGroup(AcDbObjectIdArray &arObjId, AcDbObjectId &objId, const TCHAR *pGroupName, bool bClearOld, bool bSelectable)
{
	int nLength = arObjId.length();
	if (0 == nLength) // 当数组为空时，直接返回
	{
		return RTERROR;
	}

	AcDbDictionary *pGroupDict = NULL;
	Acad::ErrorStatus es = acdbCurDwg()->getGroupDictionary(pGroupDict, AcDb::kForWrite);
	if (Acad::eOk != es)
	{
		return RTERROR;
	}

	AcDbGroup *pGroup = NULL;
	es = pGroupDict->getAt(pGroupName, objId);
	if (Acad::eOk == es) // 存在同名组
	{
		// 取得pGroup并清空
		es = acdbOpenObject(pGroup, objId, AcDb::kForWrite);
		if (Acad::eOk != es)
		{
			pGroupDict->close();
			return RTERROR;
		}

		pGroup->setSelectable(bSelectable);
		if (bClearOld)
		{
			pGroup->clear();
		}
	}
	else // 不存在， 新建一组，并添入字典
	{
		pGroup = new AcDbGroup;
		pGroup->setSelectable(bSelectable);

		es = pGroupDict->setAt(pGroupName, pGroup, objId);
		if (Acad::eOk != es) // 创建不成功
		{
			pGroupDict->close();
			delete pGroup;

			return RTERROR;
		}
	}

	pGroupDict->close();

	// 往组中添加选择集中的实体
	for (short i = 0; i < nLength; i++)
	{
		pGroup->append(arObjId.at(i));
	}

	pGroup->close();
	return RTNORM;
}

// 把一组新创建的实体添加到模型空间中去
// bDelWhenfail：当某实体添加不成功时，是否删除已成功添加的对象；
// arEntitySet：当返回的状态不正确时，arEntitySet中遗留的对象，需要调用处，负责delete；
int XExport::AddArrayToModelSpace(AcDbVoidPtrArray& arEntitySet, AcDbObjectIdArray &arObjId, bool bDelWhenfail)
{
	AcDbBlockTable *pBlkTbl = NULL;
	// 打开块表
	Acad::ErrorStatus errorStatus = acdbHostApplicationServices()->workingDatabase()->getBlockTable(pBlkTbl, AcDb::kForRead);
	if (Acad::eOk != errorStatus)
	{
		return RTERROR;
	}

	AcDbBlockTableRecord *pBlkTblRcd = NULL;
	// 打开块表记录
	errorStatus = pBlkTbl->getAt(ACDB_MODEL_SPACE, pBlkTblRcd, AcDb::kForWrite);
	if (Acad::eOk != errorStatus)
	{
		pBlkTbl->close();
		return RTERROR;
	}
	pBlkTbl->close();

	int nCount = arEntitySet.length();
	for (short i = 0; i < nCount; i++)
	{
		AcDbObjectId objIdEnt;
		AcDbEntity *pEnt = (AcDbEntity *)arEntitySet[i];

		errorStatus = pBlkTblRcd->appendAcDbEntity(objIdEnt, pEnt);
		if (Acad::eOk != errorStatus) // 添加失败
		{
			if (bDelWhenfail) // 删除已成功添加的对象
			{
				AcDbEntity *pEnt = NULL;
				for (short j = 0; j < i; j++)
				{
					if (Acad::eOk == acdbOpenAcDbEntity(pEnt, arObjId.at(j), AcDb::kForWrite))
					{
						pEnt->erase(true);
						pEnt->close();
					}
				}
			}

			pBlkTblRcd->close();
			return RTERROR;
		}
		else // 添加成功的对象，从AcDbVoidPtrArray中，删除
		{
			arEntitySet.removeAt(i);
			i--;
			nCount--;
		}

		pEnt->close();
		arObjId.append(objIdEnt);
	}

	pBlkTblRcd->close();
	return RTNORM;
}

AcDbObjectId XExport::GetTempEntityId(AcRxClass *pClass, const TCHAR *szBlockName, BOOL *bFirstNew)
{
	AcDbEntity *pEnt;
	AcDbBlockTable *pBlockTable;
	AcDbBlockTableRecord *pBlockTableRecord;
	acdbCurDwg()->getBlockTable(pBlockTable,AcDb::kForRead);

	AcDbObjectId idResult;
	if (pBlockTable->has(szBlockName))			//图块已经存在!
	{
		pBlockTable->getAt(szBlockName,pBlockTableRecord,AcDb::kForRead);
		AcDbBlockTableRecordIterator* pBlockIterator;
		pBlockTableRecord->newIterator(pBlockIterator,Adesk::kTrue,Adesk::kFalse);

		int id = 0;
		for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) 
		{
			pBlockIterator->getEntity(pEnt,AcDb::kForRead, Adesk::kTrue);
			if (pEnt->isKindOf(pClass)) 
			{
				idResult = pEnt->objectId();
				id = 1;
			}

			pEnt->close();

			if (id)
			{
				break;
			}
		}

		pBlockTable->close();
		pBlockTableRecord->close();

		if (id == 0) 
		{
			acdbCurDwg()->getBlockTable(pBlockTable,AcDb::kForWrite);
			VERIFY(pBlockTable->getAt(szBlockName,pBlockTableRecord,AcDb::kForWrite) == Acad::eOk);

			//构造实体
			AcRxObject *pObj = pClass->create();
			if (bFirstNew)
			{
				*bFirstNew = TRUE;
			}

			pEnt =  AcDbEntity::cast(pObj);
			VERIFY(pBlockTableRecord->appendAcDbEntity(pEnt) == Acad::eOk);

			idResult = pEnt->objectId();
			pEnt->close();
			pBlockTable->close();
			pBlockTableRecord->close();
		}

		delete pBlockIterator;
	}
	else 
	{
		pBlockTable->close();

		acdbCurDwg()->getBlockTable(pBlockTable,AcDb::kForWrite);
		pBlockTableRecord = new AcDbBlockTableRecord;

		AcGePoint3d origin(0.0,0.0,0.0);
		pBlockTableRecord->setOrigin(origin);
		pBlockTableRecord->setName(szBlockName);

		//构造实体
		AcRxObject *pObj = pClass->create();
		if (bFirstNew)
		{
			*bFirstNew = TRUE;
		}

		pEnt = AcDbEntity::cast(pObj);
		pBlockTable->add(pBlockTableRecord);
		pBlockTable->close();

		pBlockTableRecord->appendAcDbEntity(idResult, pEnt);
		pBlockTableRecord->close();
		pEnt->close();
	}

	return idResult;
}

// 取得矩形的几何参数
int GetRectTangle(resbuf *ptList, Point &cen, ads_real *width, ads_real *height)
{
	if(!ptList)
	{
		return RTERROR;
	}
	Point pt[4];
	resbuf *rb = ptList;
	for(int i = 0; i < 4; i++) 
	{
		if(rb == NULL || rb->restype != RT3DPOINT)
		{
			return RTERROR;
		}
		pt[i] = rb->resval.rpoint;
		rb = rb->rbnext;
	}

	XLine line1(pt[0], pt[1]), line2(pt[1], pt[2]);
	XLine line3(pt[2], pt[3]), line4(pt[3], pt[0]);

	if (CT_IsOrthDrt(line1.Direction(), line2.Direction(), _angSnap) &&
		CT_IsOrthDrt(line3.Direction(), line4.Direction(), _angSnap) &&
		CT_IsSameDrt(line1.Direction(), line3.Direction(), _angSnap))
	{
		if (CT_RealEqual(line1.GetLength(),line3.GetLength(),_DIST_SNAP) &&
			CT_RealEqual(line2.GetLength(), line4.GetLength(),_DIST_SNAP)) 
		{
			if (CT_IsSameDrt(line1.Direction(), 0, _angSnap)) 
			{
				XLine ln(pt[0], pt[2]);
				cen = ln.MidPoint();
				*width = line1.GetLength();
				*height = line2.GetLength();
				return RTNORM;
			}
			else if (CT_IsSameDrt(line2.Direction(), 0, _angSnap)) 
			{
				XLine ln(pt[0], pt[2]);
				cen = ln.MidPoint();
				*width = line2.GetLength();
				*height = line1.GetLength();
				return RTNORM;
			}
		}
	}
	return RTERROR;
}
/*
#include "XEntityImp.h"
#include "XSectorImp.h"
#include "XCircleImp.h"
#include "XPoly2DImp.h"
#include "XCurveSegmentImp.h"

static void FreeBufferPool(CArray<XEntityImp*,XEntityImp*>& arBuffer)
{
	for (int i = 0;i < arBuffer.GetSize();i++)
	{
		delete arBuffer.GetAt(i);
	}
}

static void FreeBufferPool(CArray<XSectorImp*,XSectorImp*>& arBuffer)
{
	for (int i = 0;i < arBuffer.GetSize();i++)
	{
		delete arBuffer.GetAt(i);
	}
}
*/
void XExport::InitGeLib(bool bAttach)
{
	//加载时调用
	if (bAttach)
	{
		SqlQuiry InitTemp_2;
		SafeResource InitTemp_3;
		WValList InitTemp_4("","");//构造函数只认char*
		XUcsStream InitTemp_5;
		XWcsStream InitTemp_6;
		TextRange InitTemp_7;
		XPushMMUnit setTempMMUnit;
	}
	else
	{
		//卸载范围分区
		AcDbDatabase* pDb = NULL;
		XBlockTableRecordZone* pZone = NULL;
		for (POSITION ps = g_mapDbToModelRecZone.GetStartPosition();ps != NULL;)
		{
			g_mapDbToModelRecZone.GetNextAssoc(ps,(void*&)pDb,(void*&)pZone);
			if (pZone != NULL)
			{
				delete pZone;
			}
		}
/*
		//卸载内存池
		FreeBufferPool(XCurveSegmentImp::s_arBufferPool);
		FreeBufferPool(XCircleImp::s_arBufferPool);
		FreeBufferPool(XSectorImp::s_arBufferPool);
		FreeBufferPool(XPoly2DImp::s_arBufferPool);*/
	}
}

BOOL XExport::IsPaperSpace()
{
	int cvport = 0;
	xg_getvar(_T("CVPORT"), &cvport);
	
	return (cvport == 1);
}

// add by zjq on 101118 由对象的id获得对象ownerId
AcDbObjectId XExport::GetOwnerIdFromId(AcDbObjectId idObj)
{
	XDbObject pObj(idObj,AcDb::kForRead, Adesk::kTrue);
	if (!pObj)
	{
		return AcDbObjectId::kNull;
	}
	else
	{
		return pObj.m_pObject->ownerId();
	}

}

BOOL XExport::IsUpdateMVBlock()
{
	return g_bUpdateMViewBlock;
}

void XExport::UpdateMVBlockVal(BOOL bTrue)
{
	g_bUpdateMViewBlock = bTrue;
}

// 0--2D;  1--3D
int XExport::IsExplode3D()
{
	int nMode = 0;
	int nDraw = 3;
	
	XConfigBase* pBase = GetGlobalConfigBase();

	if (pBase != NULL)
	{
		nDraw = pBase->DocGetDrawMode();
		pBase->Close();
	}

	if (nDraw == 1) 
	{
		;
	} 
	else if (nDraw == 2)
	{
		nMode = 1;
	} 
	else if (nDraw == 3)
	{
		XPoint viewDir;
		xg_getvar(_T("VIEWDIR"), &viewDir);
		viewDir = Ucs2Wcs(viewDir, TRUE);
		if (fabs(viewDir.x) > 1.0E-6 || fabs(viewDir.y) > 1.0E-6) 
		{
			nMode = 1;
		}
	}
	return nMode;
}

void XExport::ColorToRGB(int nAcadColor, int *nR, int *nG, int *nB)
{
	r_g_b rgb;
	acadrgb(nAcadColor, &rgb);
	*nR = AS_INT(255*rgb.red);
	*nG = AS_INT(255*rgb.green);
	*nB = AS_INT(255*rgb.blue);
}