4482 lines
105 KiB
C++
4482 lines
105 KiB
C++
#include "StdAfx.h"
|
||
#include "TDbProtectEntity.h"
|
||
#include "TDbBlockInsert.h"
|
||
#include "TDbColumn.h"
|
||
#include "TDbWallPatch.h"
|
||
#include "TAecSpaceCell.h"
|
||
#include "TAecSpaceWall.h"
|
||
#include "TSearchSpaceFromWall.h"
|
||
#include "TArchAppDocGlobals.h"
|
||
#include "CFindShortWallDlg.h"
|
||
#include "CProtectSetDlg.h"
|
||
#include "TArchDocReactor.h"
|
||
|
||
#include "imgdef.h"
|
||
#include "imgent.h"
|
||
#include "dbobjptr.h"
|
||
#include "rxregsvc.h"
|
||
|
||
#if ADS > 15
|
||
#include "AcStatusBar.h"
|
||
#endif
|
||
|
||
using namespace TchGeLib;
|
||
extern HINSTANCE _hdllInstance;
|
||
static ads_real minLenWall = 200.0;
|
||
//extern TCHAR g_sAppPath[];
|
||
TARCH_IMPEXP const TCHAR *xgAppname = NULL;
|
||
TARCH_IMPEXP BOOL g_bAxisWall = TRUE;
|
||
extern double g_nDefaultScale;
|
||
extern int g_nRunMode;
|
||
extern TARCH_IMPEXP int g_nProductId;
|
||
|
||
namespace
|
||
{
|
||
#if ADS <= 18
|
||
double _ttof(LPCTSTR psz)
|
||
{
|
||
if (!psz) return .0;
|
||
USES_CONVERSION;
|
||
return atof(W2A(psz));
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void PolyCurveEnt()
|
||
{
|
||
TEntitySet ent;
|
||
if (SelectEntity(_T("\n选择多段线:"),ent,TRBList(RTDXF0,_T("LINE,ARC,CIRCLE,POLYLINE,LWPOLYLINE"),NULL)) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TDbPolyCurveEnt *pCurve = new TDbPolyCurveEnt;
|
||
TGGePoly3D poly3d(ent);
|
||
AcGeMatrix3d mat;
|
||
mat.setToWorldToPlane(Ucs2Wcs(TADSGePoint3d(0,0,1),TRUE).AsAcGeVector3d());
|
||
poly3d.TransformBy(mat);
|
||
pCurve->SetPathPoly(poly3d,Ucs2Wcs(TADSGePoint3d(0,0,1),TRUE).AsAcGeVector3d());
|
||
ent.Erase();
|
||
|
||
AddToModelSpace(pCurve,Adesk::kTrue);
|
||
}
|
||
|
||
|
||
BOOL IsInsideColumn(const TADSGePoint3d &pt)
|
||
{
|
||
TADSGePoint3d ptTemp = pt;
|
||
ptTemp.z = 0;
|
||
|
||
TDPtrList<TGGePoly2D> lstPoly;
|
||
GetAllColumnBoundry(lstPoly);
|
||
|
||
for (int i = 0; i<lstPoly.Length(); i++)
|
||
{
|
||
TGGePoly2D &poly = *lstPoly[i];
|
||
poly.SetElevation(0.0);
|
||
if ((ptTemp & poly) != PR_OUTSIDE)
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
//AcDbRasterImage不能交换Id
|
||
BOOL InitBlockWipeout(AcDbObjectId idBlock, int nMaskFlag)
|
||
{
|
||
#if (ADS<16)
|
||
if (!IsArxAppLoaded(_T("wipeout")))
|
||
{
|
||
int nRet = acrxLoadModule(_T("wipeout.arx"), Adesk::kFalse, true);
|
||
if (!nRet)
|
||
{
|
||
TchGeLib::adsout << _T("\n请事先安装AutoCAD快捷工具!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
//LH 2013-2-27 修改原因当ADS=19时不执行下面代码
|
||
//#else if (ADS<19)
|
||
#endif
|
||
#if (16<ADS && ADS<19)
|
||
if (!IsArxAppLoaded(_T("AcWipeout")))
|
||
{
|
||
int nRet = acrxLoadModule(_T("AcWipeout.arx"), Adesk::kFalse, true);
|
||
if (!nRet)
|
||
{
|
||
TchGeLib::adsout << _T("\n无法加载AcWipeout.arx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
//LH 2013-2-28 由于AutoCAD2013版本后去除了AcWipeout.arx文件，所以2013版本需要判断是否加载了acismobj19.dbx
|
||
#if (ADS==19)
|
||
if(!AT_loaded(_T("acismobj19")))
|
||
{
|
||
int nRet=acrxLoadModule(_T("acismobj19.dbx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n无法加载acismobj19.dbx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
#if (ADS==20)
|
||
if(!AT_loaded(_T("acismobj20")))
|
||
{
|
||
int nRet=acrxLoadModule(_T("acismobj20.dbx"), Adesk::kFalse, true);
|
||
if(!nRet) {
|
||
adsout << _T("\n无法加载acismobj20.dbx!");
|
||
return FALSE;
|
||
}
|
||
}
|
||
#endif
|
||
TCString szBlock = GetSymbolName(idBlock);
|
||
TADSGePoint3d ptLow, ptUp;
|
||
if (GetBlockExtents(idBlock, ptLow, ptUp) != RTNORM)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
AcRxClass* pClass = AcRxClass::cast(acrxClassDictionary->at(_T("AcDbWipeout")));
|
||
if (pClass == NULL)
|
||
{
|
||
return FALSE;
|
||
}
|
||
AcDbObjectId idFirst;
|
||
BOOL bFirstWipeOut = FALSE;
|
||
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForWrite, AcDbBlockTableRecord, pBlock);
|
||
ASSERT(pBlock);
|
||
AcDbBlockTableRecordIterator* pBlockIterator = NULL;
|
||
Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator);
|
||
ASSERT(es == Acad::eOk && pBlockIterator);
|
||
AcDbEntity *pEnt = NULL;
|
||
if (pBlockIterator->getEntity(pEnt, AcDb::kForRead) == Acad::eOk)
|
||
{
|
||
idFirst = pEnt->objectId();
|
||
AcRxClass *pMyClass = pEnt->isA();
|
||
if (pMyClass == pClass)
|
||
{
|
||
bFirstWipeOut = TRUE;
|
||
if (!nMaskFlag)
|
||
{
|
||
if (pEnt->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pEnt->erase();
|
||
pEnt->downgradeOpen();
|
||
}
|
||
}
|
||
|
||
pEnt->close();
|
||
}
|
||
else
|
||
{
|
||
BOOL bCanSwapId = TRUE;
|
||
if (pMyClass == AcDb2dPolyline::desc()
|
||
|| pMyClass == AcDb3dPolyline::desc()
|
||
|| pMyClass == AcDbPolygonMesh::desc()
|
||
|| pMyClass == AcDbPolyFaceMesh::desc()
|
||
|| pMyClass == AcDbMInsertBlock::desc()
|
||
|| pMyClass == AcDbBlockReference::desc())
|
||
{
|
||
bCanSwapId = FALSE;
|
||
}
|
||
|
||
pEnt->close();
|
||
if (nMaskFlag && bCanSwapId)
|
||
{
|
||
AcDbPoint *pPoint = new AcDbPoint(AcGePoint3d(0,0,0));
|
||
pBlock->appendAcDbEntity(pPoint);
|
||
pPoint->swapIdWith(idFirst);
|
||
|
||
AcDbEntity *pWipeOut = (AcDbEntity *)pClass->create();
|
||
Acad::ErrorStatus es = pPoint->handOverTo(pWipeOut);
|
||
if (es == Acad::eObjectToBeDeleted)
|
||
{
|
||
pWipeOut->close();
|
||
delete pPoint;
|
||
bFirstWipeOut = TRUE;
|
||
}
|
||
else
|
||
{
|
||
pPoint->close();
|
||
delete pWipeOut;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
delete pBlockIterator;
|
||
OPENOBJ_END();
|
||
|
||
if (!nMaskFlag)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
if (!bFirstWipeOut)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
TGGePoly2D polyBound(1);
|
||
BOOL bOutline = (GetBlockBoundary(idBlock, polyBound) == RTNORM);
|
||
|
||
OPENOBJ_BEGIN(idFirst, AcDb::kForWrite, AcDbRasterImage, pAcDbRasterImage);
|
||
if (pAcDbRasterImage)
|
||
{
|
||
TADSGePoint3d origin = ptLow;
|
||
double xDir = 0.0;
|
||
double yDir = xDir + PI / 2.0;
|
||
AcGeVector3d u(cos(xDir), sin(xDir), 0),
|
||
v(cos(yDir), sin(yDir), 0);
|
||
u *= (ptUp.x - ptLow.x);
|
||
v *= (ptUp.y - ptLow.y);
|
||
|
||
pAcDbRasterImage->setOrientation(origin, u, v);
|
||
if (!nMaskFlag)
|
||
{
|
||
pAcDbRasterImage->erase();
|
||
}
|
||
else if (nMaskFlag & BIF_POLYMASK)
|
||
{
|
||
if (bOutline)
|
||
{
|
||
AcGeMatrix3d mat3d;
|
||
pAcDbRasterImage->getPixelToModelTransform(mat3d);
|
||
mat3d.invert();
|
||
|
||
AcDbRasterImage::ClipBoundaryType ClipBoundaryType;
|
||
AcGePoint2dArray ClipBoundary;
|
||
TGGePoly2D polyDest(1);
|
||
polyBound.Disperse1(polyDest, _AS_SYS_UNIT(g_nCirDeviation));
|
||
int nCount = polyDest.Length();
|
||
|
||
for (int i = 0; i <= nCount; i++)
|
||
{
|
||
TADSGePoint3d ptVert = *polyDest[i == nCount ? 0 : i];
|
||
((AcGePoint3d &)ptVert).transformBy(mat3d);
|
||
ClipBoundary.append(ptVert);
|
||
}
|
||
|
||
ClipBoundaryType = AcDbRasterImage::kPoly;
|
||
pAcDbRasterImage->setClipBoundary(ClipBoundaryType, ClipBoundary);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pAcDbRasterImage->setClipBoundaryToWholeImage();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return TRUE;
|
||
}
|
||
AcDbObjectId GetBlock2dFromBlock3d(AcDbObjectId idBlock)
|
||
{
|
||
AcDbObjectId idBlock2d;
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
||
if (pBlock)
|
||
{
|
||
resbuf *pxData = pBlock->xData(TCHXD); // 读扩展数据
|
||
if (pxData)
|
||
{
|
||
resbuf *pNext = pxData->rbnext;
|
||
if (pNext && pNext->restype == 1005)
|
||
{
|
||
AcDbHandle handle(pNext->resval.rstring);
|
||
pBlock->database()->getAcDbObjectId(idBlock2d, false, handle);
|
||
}
|
||
|
||
ads_relrb(pxData);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return idBlock2d;
|
||
}
|
||
|
||
void InitAppDocGlobals(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
ASSERT(TArchDocReactor::g_pTArchAppDocGlobals == NULL);
|
||
TArchDocReactor::g_pTArchAppDocGlobals = new TArchAppDocGlobals();
|
||
TArchDocReactor::g_pTArchAppDocGlobals->InitDocGlobals(curDoc());
|
||
}
|
||
else
|
||
{
|
||
ASSERT(TArchDocReactor::g_pTArchAppDocGlobals != NULL);
|
||
TArchDocReactor::g_pTArchAppDocGlobals->OnUnloadApp();
|
||
|
||
delete TArchDocReactor::g_pTArchAppDocGlobals;
|
||
TArchDocReactor::g_pTArchAppDocGlobals = NULL;
|
||
}
|
||
}
|
||
|
||
void ModifyWallAtCorner(TADSGePointList &lstCorners0, TDPtrList<TColumnData> &lstColumns,AcDbObjectId idBlock,LPVOID pReserve)
|
||
{
|
||
CFindShortWallDlg::g_bAskAgain = TRUE;
|
||
CFindShortWallDlg::m_nHowToDo = 0;
|
||
|
||
// 如果没有变化的墙角和柱子, 则返回
|
||
if (!lstCorners0 && !lstColumns)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 复制一份, 以避免Reactor修改墙角表
|
||
TADSGePointList lstCorners;
|
||
for (int idx = 0; idx < lstCorners0.Length(); idx++)
|
||
{
|
||
lstCorners.Append(new TADSGePoint3d(*lstCorners0[idx]));
|
||
}
|
||
|
||
//缩小求解范围
|
||
// 过滤出需要局部考虑的墙体
|
||
TADSGePoint3d ptMin, ptMax;
|
||
BOOL bInitExt = FALSE;
|
||
if (!!lstCorners)
|
||
{
|
||
lstCorners.GetExtend(ptMin,ptMax);
|
||
bInitExt = TRUE;
|
||
}
|
||
|
||
TGGePoly2D poly(1);
|
||
TADSGePoint3d pt1, pt2;
|
||
|
||
for (idx = 0; idx < lstColumns.Length(); idx++)
|
||
{
|
||
poly.Reset();
|
||
lstColumns[idx]->GetOutline(poly);
|
||
|
||
poly.GetExtend(pt1, pt2);
|
||
if (!bInitExt)
|
||
{
|
||
ptMin = pt1;
|
||
ptMax = pt2;
|
||
bInitExt = TRUE;
|
||
}
|
||
else
|
||
{
|
||
ptMin = Min(ptMin, pt1);
|
||
ptMax = Max(ptMax, pt2);
|
||
}
|
||
}
|
||
|
||
// 取得需要更新的墙体集合A, 这些墙体的墙角需要重新计算, 当然连接的墙体需要重新搜索
|
||
double nDistPrec = 800;
|
||
ptMin.x -= nDistPrec;
|
||
ptMin.y -= nDistPrec;
|
||
ptMax.x += nDistPrec;
|
||
ptMax.y += nDistPrec;
|
||
|
||
TADSGePoint3d ptMinUpd = ptMin, ptMaxUpd = ptMax; //范围A: ptMinUpd-ptAxUpd
|
||
TPickEntSet ssMin(SS_FREE), ss(SS_FREE);
|
||
|
||
if (GetSafeSelectionEx2(ssMin, 1, ptMin, ptMax, TDbWall::desc(),idBlock) != Acad::eOk)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 取得有关的墙体集合C, 要更新的墙体需要参考它们的参数.
|
||
// 集合C-集合A = 集合B, 集合B的墙体的墙角不需要重新计算.
|
||
// 但是计算集合A的墙角需要用到集合B, 因此B也在整个拓扑网路中.
|
||
// V2.0 版直接记录拓扑, 由于集合A的实体发生合并或分解, 这样
|
||
// 集合B中的实体可能记录了对集合A的拓扑连接关系, 这一关系也需要更新
|
||
// 因此: 1. 集合A更新范围A内的端点的拓扑; 2.集合B更新范围B内的端点的拓扑
|
||
TADSGePoint3d ptExtMin, ptExtMax;
|
||
ssMin.GetExtend(ptExtMin, ptExtMax);
|
||
ptMin = Min(ptMin, ptExtMin);
|
||
ptMax = Max(ptMax, ptExtMax); // Modify on 2003/9/12，缺保范围C大于等于范围A
|
||
|
||
ptMin.x -= nDistPrec;
|
||
ptMin.y -= nDistPrec;
|
||
ptMax.x += nDistPrec;
|
||
ptMax.y += nDistPrec;
|
||
|
||
//add by xlc on 100531 提速优化
|
||
if (pReserve != NULL)
|
||
{
|
||
typedef CMap<TLong_ptr,TLong_ptr,AcDbExtents,AcDbExtents> CMapLongToExtents;
|
||
CMapLongToExtents* pMap = (CMapLongToExtents*)pReserve;
|
||
AcDbExtents ext(ptMin,ptMax);
|
||
pMap->SetAt(idBlock.asOldId(),ext);
|
||
if (pMap->Lookup(100,ext))
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (GetSafeSelectionEx2(ss, 1, ptMin, ptMax, TDbWall::desc(),idBlock) != Acad::eOk)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TPickEntSet ssB(SS_FREE);
|
||
ssB += ss;
|
||
|
||
//add by xlc on 101125 解决图块在位编辑后墙角更新不全的问题
|
||
if(_tcsicmp(GetCurCommand(), _T("REFCLOSE"))!=0)
|
||
|
||
{
|
||
ssB -= ssMin;
|
||
}
|
||
|
||
//取得所有的柱子裁剪区域
|
||
TDPtrList<AcDbObjectId> lstClipBoundry;
|
||
TPickEntSet ssColu(SS_FREE);
|
||
|
||
if (GetSafeSelection2(ssColu, 1, ptMin, ptMax, TDbColumn::desc(),idBlock) == Acad::eOk)
|
||
{
|
||
// 过滤出需要局部考虑的柱子
|
||
TEntitySet eColu;
|
||
AcDbObjectId *idColu = NULL;
|
||
long nColuCount = ssColu.Length();
|
||
for (long n = 0; n < nColuCount; n++)
|
||
{
|
||
eColu = ssColu[n];
|
||
|
||
OPENOBJ_BEGIN(eColu, AcDb::kForRead, TDbColumn, pColu);
|
||
if (pColu && !pColu->IsFortifyColumn())
|
||
{
|
||
idColu = new AcDbObjectId;
|
||
VERIFY(acdbGetObjectId(*idColu, eColu) == Acad::eOk);
|
||
lstClipBoundry.Append(idColu);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
LAB_BEGIN:
|
||
TSearchSpaceFromWall aSearch;
|
||
try
|
||
{
|
||
aSearch.InitStart(ss, lstClipBoundry); //实际并不搜索房间,
|
||
}
|
||
catch(TSearchException e)
|
||
{
|
||
if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_STOP_DELETE)
|
||
{
|
||
OPENOBJ_BEGIN(e.m_idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
|
||
if (pDbEnt)
|
||
{
|
||
pDbEnt->erase();
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE)
|
||
{
|
||
ss -= e.m_idObj;
|
||
goto LAB_BEGIN;
|
||
}
|
||
|
||
return;
|
||
}
|
||
catch(TDupWallException e)
|
||
{
|
||
if (e.m_nHowToDo == HF_DELETEA || e.m_nHowToDo == HF_DELETEB)
|
||
{
|
||
AcDbObjectId idObj = (e.m_nHowToDo == HF_DELETEA ? e.m_idObjA : e.m_idObjB);
|
||
OPENOBJ_BEGIN(idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
|
||
if (pDbEnt)
|
||
{
|
||
pDbEnt->erase();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ss -= idObj;
|
||
goto LAB_BEGIN;
|
||
}
|
||
|
||
return;
|
||
}
|
||
catch(...)
|
||
{
|
||
TchGeLib::adsout << _T("\n出现了例外情况!");
|
||
acedPostCommandPrompt();
|
||
|
||
return;
|
||
}
|
||
|
||
// 加入柱子所包含的墙角
|
||
TADSGePointList lstAllCorners;
|
||
aSearch.GetAllCorners(lstAllCorners); //取得所有的墙角
|
||
|
||
if (lstAllCorners.Length() > 0) //add by xlc on 100517没有墙角时不对柱子进行运算
|
||
{
|
||
TADSGePoint3d ptCorner;
|
||
for (int m = 0; m < lstColumns.Length(); m++)
|
||
{
|
||
if (lstAllCorners.Length() == 0)
|
||
{
|
||
break;
|
||
}
|
||
const TGGePoly2D &poly = lstColumns[m]->GetOutlinePoly();
|
||
if (!poly)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
for (int n = 0; n < lstAllCorners.Length(); n++)
|
||
{
|
||
ptCorner = *lstAllCorners[n];
|
||
ptCorner.z = poly.Head()->z; // Z add this line on 2003/3/18
|
||
|
||
if ((ptCorner & ((TGGePoly2D &)poly)) == PR_INSIDE)
|
||
{
|
||
lstCorners.NewAppend(ptCorner);
|
||
lstAllCorners.Remove(n);
|
||
n -= 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
TPickEntSet ssDel(SS_FREE); //被合并的墙
|
||
try
|
||
{
|
||
if (lstCorners.Length() > 0) //add by xlc on 100517没有墙角时不对柱子进行运算
|
||
{
|
||
aSearch.MergeWalls(lstCorners, ssDel); //先尽量合并墙段, 只处理发生变化的墙角
|
||
ss -= ssDel; // Z add this line on 2003/11/14
|
||
aSearch.BreakWalls(lstCorners, ss); //在断点处,或裁剪区域中心打断墙体
|
||
}
|
||
}
|
||
catch(TDupWallException e)
|
||
{
|
||
if (e.m_nHowToDo == HF_DELETEA || e.m_nHowToDo == HF_DELETEB)
|
||
{
|
||
AcDbObjectId idObj = (e.m_nHowToDo == HF_DELETEA ? e.m_idObjA : e.m_idObjB);
|
||
OPENOBJ_BEGIN(idObj, AcDb::kForWrite, AcDbEntity, pDbEnt);
|
||
ssDel += idObj; //Add on 2002/2/27
|
||
|
||
if (pDbEnt)
|
||
{
|
||
pDbEnt->erase();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ss -= idObj;
|
||
|
||
goto LAB_BEGIN;
|
||
}
|
||
|
||
return;
|
||
}
|
||
catch(...)
|
||
{
|
||
TchGeLib::adsout << _T("\n出现了例外情况!");
|
||
acedPostCommandPrompt();
|
||
|
||
return;
|
||
}
|
||
|
||
// 更新墙体
|
||
TPickEntSet ssUpdateWalls(SS_FREE);
|
||
|
||
//Note: 应当在aSearch范围内搜索更快
|
||
if (GetSafeSelectionEx2(ssUpdateWalls, 1, ptMinUpd, ptMaxUpd, TDbWall::desc(),idBlock) == Acad::eOk)
|
||
{
|
||
// 更新集合A在范围A内的端点拓扑
|
||
TGGeRectAngle boxA(ptMinUpd, ptMaxUpd);
|
||
TEntitySet ent;
|
||
long len = ssUpdateWalls.Length();
|
||
for (long i = 0; i < len; i++)
|
||
{
|
||
ent = ssUpdateWalls[i];
|
||
TAcDbObjectPtr obj(ent.name, AcDb::kForWrite);
|
||
if (!obj)
|
||
{
|
||
//Extend一墙体时, 指针还没有关闭
|
||
}
|
||
else
|
||
{
|
||
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
||
if (pWall)
|
||
{
|
||
pWall->assertWriteEnabled();
|
||
pWall->CalSideParameters(ent, TSearchSpaceFromWall::g_lstAllSortWalls, &boxA);
|
||
}
|
||
}
|
||
}
|
||
|
||
for (i = 0; i<len; i++)
|
||
{
|
||
ent = ssUpdateWalls[i];
|
||
TAcDbObjectPtr obj(ent.name, AcDb::kForWrite);
|
||
if (!obj)
|
||
{
|
||
//Extend一墙体时, 指针还没有关闭
|
||
}
|
||
else
|
||
{
|
||
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
||
if (pWall)
|
||
{
|
||
pWall->assertWriteEnabled();
|
||
pWall->CalSideParameters1(&boxA);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 更新集合B在范围B内的端点拓扑
|
||
TGGeRectAngle boxB(ptMin, ptMax);
|
||
|
||
// Modify on 2003/9/8, boxA change to boxB
|
||
// 更新集合C在范围B内的柱子的拓扑
|
||
aSearch.UpdateColuLinkage(&boxB);
|
||
|
||
len = ssB.Length();
|
||
for (i = 0L; i < len; i++)
|
||
{
|
||
TEntitySet entB = ssB[i];
|
||
OPENOBJ_BEGIN(entB, AcDb::kForWrite, TDbWall, pWall);
|
||
if (pWall)
|
||
{
|
||
pWall->assertWriteEnabled();
|
||
pWall->CalSideParameters(entB,TSearchSpaceFromWall::g_lstAllSortWalls, &boxB);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
for (i = 0L; i < len; i++)
|
||
{
|
||
TEntitySet entB = ssB[i];
|
||
OPENOBJ_BEGIN(entB, AcDb::kForWrite, TDbWall, pWall);
|
||
if (pWall)
|
||
{
|
||
pWall->assertWriteEnabled();
|
||
pWall->CalSideParameters1(&boxB);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
if (!!ssDel)
|
||
{ //清除预先选中的物体
|
||
TPickEntSet gSet(SS_FREE), pSet(SS_FREE);
|
||
if (GetPickFirst(gSet, pSet) == RTNORM)
|
||
{
|
||
if (gSet.Length() || pSet.Length())
|
||
{
|
||
acedPostCommand(_T("\33"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void GetDwgStamp()
|
||
{
|
||
TDbConfig *p = GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
|
||
int nRet = (p ? p->GetControlFlag() : 0);
|
||
if (p)
|
||
{
|
||
p->close();
|
||
}
|
||
|
||
int bInvalidEver = ((nRet & CONF_INVALID_EVER));
|
||
int bInvalidLast = ((nRet & CONF_INVALID_LAST));
|
||
|
||
if (bInvalidEver && bInvalidLast)
|
||
{
|
||
TchGeLib::adsout << _T("\n非法使用产生的图形!");
|
||
}
|
||
else if (bInvalidEver)
|
||
{
|
||
TchGeLib::adsout << _T("\n图形曾经用非法软件保存过!");
|
||
}
|
||
else if (bInvalidLast)
|
||
{
|
||
TchGeLib::adsout << _T("\n图形最近用非法软件保存过!");
|
||
}
|
||
else
|
||
{
|
||
TchGeLib::adsout << _T("\n合法软件创建的图形!");
|
||
}
|
||
}
|
||
|
||
BOOL IsAcadIdle()
|
||
{
|
||
TArchPerDocData * pDocDat = GetCurDocData();
|
||
return (pDocDat && pDocDat->m_bAcadIdle);
|
||
}
|
||
|
||
BOOL IsCommandLineEmpty()
|
||
{
|
||
TArchPerDocData * pDocDat = GetCurDocData();
|
||
return (!pDocDat || pDocDat->m_nPos == 0);
|
||
}
|
||
|
||
int InsertBlock()
|
||
{
|
||
AsureWCS();
|
||
|
||
TADSGePoint3d ptCen;
|
||
VERIFY(TGGetVar(_T("VIEWCTR"), &ptCen) == RTNORM);
|
||
|
||
resbuf *rb = ads_getargs();
|
||
if (!rb || rb->restype != RTSTR)
|
||
{
|
||
return RTNORM;
|
||
}
|
||
|
||
TRBList rbList = rb;
|
||
TCHAR *pszBlock = rb->resval.rstring;
|
||
rb = rb->rbnext;
|
||
|
||
double sx = 1.0, sy = 1.0, sz = 1.0;
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTSHORT)
|
||
{
|
||
sx = rb->resval.rint;
|
||
}
|
||
else if (rb->restype == RTREAL)
|
||
{
|
||
sx = rb->resval.rreal;
|
||
}
|
||
else
|
||
{
|
||
return RTNORM;
|
||
}
|
||
|
||
rb = rb->rbnext;
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTSHORT)
|
||
{
|
||
sy = rb->resval.rint;
|
||
}
|
||
else if (rb->restype == RTREAL)
|
||
{
|
||
sy = rb->resval.rreal;
|
||
}
|
||
else
|
||
{
|
||
return RTNORM;
|
||
}
|
||
|
||
rb = rb->rbnext;
|
||
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTSHORT)
|
||
{
|
||
sz = rb->resval.rint;
|
||
}
|
||
else if (rb->restype == RTREAL)
|
||
{
|
||
sz = rb->resval.rreal;
|
||
}
|
||
else
|
||
{
|
||
return RTNORM;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int nRet = RTNORM;
|
||
|
||
if (!InitBlock(pszBlock))
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
MakeTBlockInsert(pszBlock, ptCen, sx, sy, sz, 0.0, 0);
|
||
|
||
if (nRet == RTNORM)
|
||
{
|
||
TEntitySet ent;
|
||
ent.GetLast();
|
||
|
||
IDragInsertBlock(ptCen, ent, IBF_ROT90 | IBF_MIRLR | IBF_MIRUD | IBF_FRAME | IBF_ROTATE | IBF_BASEPT);
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
|
||
// 通过一点确定一房间的轮廓
|
||
int GenSpaceOutline(const TADSGePoint3d &ptPick, TGGePoly2D &poly, int bCenter)
|
||
{
|
||
g_bFindExtSpace = FALSE;
|
||
|
||
// 找到所有墙,refreshed by W on 050826
|
||
TDPtrList<AcDbObjectId> ssWalls;
|
||
if (GetEntFromBlockByDxf(ssWalls,_T("ATS_WALL,ATS_CURTAIN_WALL"),1) != Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
TDPtrList<AcDbObjectId> lstColu;
|
||
GetEntFromBlockByDxf(lstColu, _T("ATS_COLUMN"));
|
||
|
||
int nRet = RTERROR;
|
||
// add by lgy 20120222，9.0房间轮廓命令无法正常执行，添加一goto语句的标记
|
||
SEARCHSPACE_LAB_BEGIN:
|
||
TSearchSpaceFromWall aSearch;
|
||
try
|
||
{
|
||
aSearch.InitStart(ssWalls, lstColu);
|
||
}
|
||
// add by lgy 20120222 当图中存在完全包含在柱内的短墙时，房间轮廓命令无法正常执行
|
||
catch (TSearchException e)
|
||
{
|
||
if (e.m_nHowToDo == HF_DELETE || e.m_nHowToDo == HF_MARK || e.m_nHowToDo == HF_NONE)
|
||
{
|
||
for (int i = 0; i < ssWalls.Length(); i++)
|
||
{
|
||
if (*ssWalls[i] == e.m_idObj)
|
||
{
|
||
ssWalls.Remove(i); // 从选择集中过滤掉“小短墙”
|
||
}
|
||
}
|
||
goto SEARCHSPACE_LAB_BEGIN;
|
||
}
|
||
|
||
return RTERROR;
|
||
}
|
||
catch (...)
|
||
{
|
||
TchGeLib::adsout << _T("\n发生例外情况!");
|
||
return RTERROR;
|
||
}
|
||
|
||
int nWallNumber = aSearch.walls.Length();
|
||
|
||
TAecSpaceWall *pNearestWall = NULL;
|
||
ads_real nMinDist = 0.0;
|
||
for (int i = 0; i < nWallNumber; i++)
|
||
{
|
||
TADSGePoint3d ptProject;
|
||
TAecSpaceWall *pWall = aSearch.walls[i];
|
||
|
||
if (pWall->ProjectToMe(ptPick, ptProject) != RTNORM || (ptProject & (*pWall)) != PR_INSIDE)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
ptProject.z = ptPick.z; //忽略Z坐标
|
||
ads_real nDist = ads_distance(ptPick, ptProject);
|
||
if (!pNearestWall)
|
||
{
|
||
nMinDist = nDist;
|
||
pNearestWall = pWall;
|
||
}
|
||
else if (nDist < nMinDist)
|
||
{
|
||
nMinDist = nDist;
|
||
pNearestWall = pWall;
|
||
}
|
||
}
|
||
|
||
int nWho = 0; //1:left; 2:right
|
||
BOOL bSubtract = TRUE; //用相减的方法,适合于室内; 否则为室外
|
||
TAecSpaceCell lSpace, rSpace;
|
||
if (pNearestWall && aSearch.SearchTwoSpace(*pNearestWall, lSpace, rSpace) == RTNORM)
|
||
{
|
||
TGGePoly2D lPoly, rPoly;
|
||
if (bCenter)
|
||
{
|
||
lSpace.CenterPoly2D(lPoly);
|
||
rSpace.CenterPoly2D(rPoly);
|
||
}
|
||
else
|
||
{
|
||
lSpace.InternalPoly2D(lPoly, 1);
|
||
rSpace.InternalPoly2D(rPoly, 1);
|
||
}
|
||
|
||
int nPrFlag1 = ptPick & lPoly;
|
||
int nPrFlag2 = ptPick & rPoly;
|
||
if (nPrFlag1 == PR_INSIDE && nPrFlag2 == PR_INSIDE)
|
||
{
|
||
ads_real nArea1 = lPoly.Area();
|
||
ads_real nArea2 = rPoly.Area();
|
||
|
||
if (nArea1 < nArea2)
|
||
{
|
||
poly = lPoly;
|
||
nWho = 1;
|
||
}
|
||
else
|
||
{
|
||
poly = rPoly;
|
||
nWho = 2;
|
||
}
|
||
|
||
nRet = RTNORM;
|
||
}
|
||
else if (nPrFlag1 == PR_INSIDE)
|
||
{
|
||
poly = lPoly;
|
||
nWho = 1;
|
||
nRet = RTNORM;
|
||
}
|
||
else if (nPrFlag2 == PR_INSIDE)
|
||
{
|
||
poly = rPoly;
|
||
nWho = 2;
|
||
nRet = RTNORM;
|
||
}
|
||
else
|
||
{
|
||
ads_real nArea1 = lPoly.Area();
|
||
ads_real nArea2 = rPoly.Area();
|
||
|
||
if (nArea1 > nArea2)
|
||
{
|
||
poly = lPoly;
|
||
nWho = 1;
|
||
}
|
||
else
|
||
{
|
||
poly = rPoly;
|
||
nWho = 2;
|
||
}
|
||
|
||
nRet = RTNORM;
|
||
bSubtract = FALSE;
|
||
}
|
||
}
|
||
else if (pNearestWall)
|
||
{
|
||
lSpace.Reset();
|
||
rSpace.Reset();
|
||
|
||
if (aSearch.SearchOneSpace(*pNearestWall, 0, lSpace) == RTNORM)
|
||
{
|
||
if (bCenter)
|
||
{
|
||
lSpace.CenterPoly2D(poly);
|
||
}
|
||
else
|
||
{
|
||
lSpace.InternalPoly2D(poly, 1);
|
||
}
|
||
|
||
if ((ptPick & poly) == PR_INSIDE)
|
||
{
|
||
nWho = 1;
|
||
nRet = RTNORM;
|
||
}
|
||
}
|
||
else if (aSearch.SearchOneSpace(*pNearestWall, 1, rSpace) == RTNORM)
|
||
{
|
||
if (bCenter)
|
||
{
|
||
rSpace.CenterPoly2D(poly);
|
||
}
|
||
else
|
||
{
|
||
rSpace.InternalPoly2D(poly, 1);
|
||
}
|
||
|
||
if ((ptPick & poly) == PR_INSIDE)
|
||
{
|
||
nWho = 2;
|
||
nRet = RTNORM;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!bCenter && nWho)
|
||
{
|
||
//扣除柱子部分
|
||
TAecSpaceCell *pSpace = nWho == 1 ? &lSpace : &rSpace;
|
||
if (bSubtract == FALSE)
|
||
{
|
||
poly.Reset();
|
||
pSpace->InternalPoly2D(poly, 2);
|
||
g_bFindExtSpace = TRUE;
|
||
}
|
||
}
|
||
|
||
poly.Compress();
|
||
if (nRet == RTNORM && poly.PathArea() > 0.0)
|
||
{
|
||
poly.Reverse(); //确保为逆时针
|
||
}
|
||
|
||
return nRet;
|
||
}
|
||
void PrePlot()
|
||
{
|
||
g_bPrinting = TRUE;
|
||
TGSetVar(_T("SORTENTS"), 127);
|
||
TPickEntSet ssMaskObj(SS_FREE);
|
||
|
||
// TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT"), NULL);
|
||
// 房间对象无法使用wipeout方式屏蔽 -- wyg20090804
|
||
// sg modify 091105，暂时恢复房间对象屏蔽CAD填充的功能，等待房间对象屏蔽自身填充功能修改后，再去掉
|
||
// TRBList mask(RTDXF0, _T("ATS_TEXT"), NULL);
|
||
|
||
//modify by xlc on 110519 阳台不增加wipeout
|
||
//modify by xlc on 110314 阳台增加wipeout
|
||
TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT"), NULL);
|
||
//TRBList mask(RTDXF0, _T("ATS_SPACE,ATS_TEXT,ATS_BALCONY"), NULL);
|
||
if (ssMaskObj.Get(_T("X"), NULL, NULL, mask) == RTNORM)
|
||
{
|
||
long lCount = ssMaskObj.Length();
|
||
for (long idx = 0L; idx < lCount; idx++)
|
||
{
|
||
TEntitySet ent = ssMaskObj[idx];
|
||
AcDbVoidPtrArray ssWipeouts;
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
|
||
if (pEnt != NULL)
|
||
{
|
||
if (pEnt->isKindOf(TDbText::desc()))
|
||
{
|
||
AcDbEntity *pWipeOut = ((TDbText *)pEnt)->CreateWipeOut();
|
||
if (pWipeOut)
|
||
{
|
||
ssWipeouts.append(pWipeOut);
|
||
}
|
||
}
|
||
else if (pEnt->isKindOf(TDbSpace::desc()))
|
||
{
|
||
// add by xlc on 101201 解决带填充的房间对象打印预览后顺序变化的问题
|
||
if(((TDbSpace *)pEnt)->HasHatch() && !!((TDbSpace *)pEnt)->GetHatchStyle())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
((TDbSpace *)pEnt)->CreateWipeOut(ssWipeouts);
|
||
}
|
||
|
||
//else if (pEnt->isKindOf(TDbBalcony::desc()))
|
||
//{
|
||
// AcDbEntity *pWipeOut = ((TDbBalcony *)pEnt)->CreateWipeOut();
|
||
// if (pWipeOut)
|
||
// {
|
||
// ssWipeouts.append(pWipeOut);
|
||
// }
|
||
//}
|
||
|
||
int num = ssWipeouts.length();
|
||
for (int n = 0; n < num; n++)
|
||
{
|
||
AcDbEntity *pWipeOut = (AcDbEntity *)ssWipeouts[n];
|
||
pWipeOut->setLayer(InitLayer(_T("_TCH_WIPEOUT"), FALSE));
|
||
|
||
AcDbObjectId idInsert = pEnt->objectId();
|
||
AcDbObjectId idWipeOut = AddToModelSpace(pWipeOut, TRUE);
|
||
pEnt->swapIdWith(idWipeOut);
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
AcDbObjectId idLayMask = InitLayer(LAY_MASK, FALSE);
|
||
TPickEntSet ssOld(SS_FREE);
|
||
|
||
if (ssOld.Get(_T("X"),NULL,NULL,TRBList(RTDXF0, _T("AEC_BLOCK_INSERT,ATS_MVINSERT"), 8, LAY_MASK, NULL)) == RTNORM)
|
||
{
|
||
ssOld.Erase();
|
||
}
|
||
|
||
TPickEntSet ssMask(SS_FREE);
|
||
if (ssMask.Get(_T("X"), NULL, NULL, TRBList(RTDXF0, _T("AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL)) == RTNORM)
|
||
{
|
||
AcDbObjectIdArray idArray;
|
||
AcRxClass* pClass = AcRxClass::cast(acrxClassDictionary->at(_T("AcDbWipeout")));
|
||
|
||
long lCount = ssMask.Length();
|
||
for (long idx = 0L; idx < lCount; idx++)
|
||
{
|
||
TEntitySet ent = ssMask[idx];
|
||
|
||
AcDbEntity *pEnt;
|
||
AcDbObjectId idEnt;
|
||
acdbGetObjectId(idEnt, ent.name);
|
||
|
||
BOOL bMaskWipeOut = FALSE;
|
||
if (acdbOpenObject(pEnt, idEnt, AcDb::kForRead) == Acad::eOk && pEnt != NULL)
|
||
{
|
||
AcDbObjectId idBlock;
|
||
if (pEnt->isKindOf(TDbMultiViewInsert::desc()))
|
||
{
|
||
TDbMultiViewInsert *pIns = TDbMultiViewInsert::cast(pEnt);
|
||
idBlock = pIns->GetBlockId(FALSE);
|
||
}
|
||
else if (pEnt->isKindOf(TDbBlockInsert::desc()))
|
||
{
|
||
TDbBlockInsert *pIns = TDbBlockInsert::cast(pEnt);
|
||
idBlock = pIns->blockTableRecord();
|
||
}
|
||
|
||
if (idArray.contains(idBlock))
|
||
{
|
||
bMaskWipeOut = TRUE;
|
||
}
|
||
else
|
||
{
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
||
if (pBlock && IsMaskBlock(*pBlock, pClass))
|
||
{
|
||
bMaskWipeOut = TRUE;
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
if (bMaskWipeOut)
|
||
{
|
||
idArray.append(idBlock);
|
||
}
|
||
}
|
||
|
||
pEnt->close();
|
||
}
|
||
|
||
if (bMaskWipeOut)
|
||
{
|
||
if (acdbOpenObject(pEnt, idEnt, AcDb::kForWrite) == Acad::eOk )
|
||
{
|
||
AcDbBlockReference *pNewBlock = NULL;
|
||
TCString sBlock3d;
|
||
if (pEnt->isKindOf(TDbMultiViewInsert::desc()))
|
||
{
|
||
TDbMultiViewInsert *pIns = TDbMultiViewInsert::cast(pEnt);
|
||
pNewBlock = pIns->NewBlock(FALSE);
|
||
sBlock3d = GetSymbolName(pIns->GetBlockId(TRUE));
|
||
}
|
||
else if (pEnt->isKindOf(TDbBlockInsert::desc()))
|
||
{
|
||
TDbBlockInsert *pIns = TDbBlockInsert::cast(pEnt);
|
||
pNewBlock = pIns->NewBlockInsert();
|
||
}
|
||
|
||
ASSERT(pNewBlock);
|
||
|
||
resbuf *rb = NULL;
|
||
if (!sBlock3d)
|
||
{
|
||
rb = ads_buildlist(1001, _T("_TCH_MASK"), 1070, 1, NULL);
|
||
}
|
||
else
|
||
{
|
||
rb = ads_buildlist(1001, _T("_TCH_MASK"), 1070, 2, 1000, (const TCHAR *)sBlock3d, NULL);
|
||
}
|
||
|
||
Acad::ErrorStatus es = pEnt->handOverTo(pNewBlock);
|
||
if (es == Acad::eObjectToBeDeleted)
|
||
{
|
||
if (!XSymbolTable(_T("APPID"), _T("_TCH_MASK")))
|
||
{
|
||
ads_regapp(_T("_TCH_MASK"));
|
||
}
|
||
|
||
pNewBlock->setXData(rb);
|
||
pNewBlock->close();
|
||
delete pEnt;
|
||
}
|
||
else
|
||
{
|
||
pEnt->close();
|
||
delete pNewBlock;
|
||
}
|
||
ads_relrb(rb);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void PostPlot()
|
||
{
|
||
TPickEntSet ssMaskObj(SS_FREE);
|
||
TRBList mask(RTDXF0, _T("WIPEOUT"), 8, _T("_TCH_WIPEOUT"), NULL);
|
||
if (ssMaskObj.Get(_T("X"), NULL, NULL, mask) == RTNORM) //文字屏蔽产生的临时物体
|
||
{
|
||
ssMaskObj.Erase();
|
||
}
|
||
|
||
TPickEntSet ssMask(SS_FREE);
|
||
if (ssMask.Get(_T("X"), NULL, NULL, TRBList(RTDXF0, _T("INSERT"), 1001, _T("_TCH_MASK"), NULL)) == RTNORM)
|
||
{
|
||
long lCount = ssMask.Length();
|
||
for (long idx = 0L; idx < lCount; idx++)
|
||
{
|
||
TEntitySet ent = ssMask[idx];
|
||
AcDbBlockReference *pInsert1 = NULL;
|
||
AcDbObjectId idEnt;
|
||
acdbGetObjectId(idEnt, ent.name);
|
||
|
||
if (acdbOpenObject(pInsert1, idEnt, AcDb::kForWrite) == Acad::eOk && pInsert1 != NULL)
|
||
{
|
||
resbuf *rbXData = pInsert1->xData(_T("_TCH_MASK"));
|
||
AcDbObjectId idBlock3d;
|
||
|
||
if (rbXData)
|
||
{
|
||
resbuf *rbNext = rbXData->rbnext;
|
||
if (rbNext && rbNext->restype == 1070 && rbNext->resval.rint == 2)
|
||
{
|
||
rbNext = rbNext->rbnext;
|
||
if (rbNext && rbNext->restype == 1000)
|
||
{
|
||
idBlock3d = GetBlockIdFromString(rbNext->resval.rstring);
|
||
}
|
||
}
|
||
|
||
ads_relrb(rbXData);
|
||
}
|
||
|
||
AcDbEntity *pNewEnt = NULL;
|
||
if (idBlock3d.isValid())
|
||
{
|
||
TDbMultiViewInsert *pInsert2 = new TDbMultiViewInsert;
|
||
pInsert2->setPropertiesFrom(pInsert1);
|
||
pInsert2->SetBlockId(FALSE, pInsert1->blockTableRecord());
|
||
pInsert2->SetBlockId(TRUE, idBlock3d);
|
||
|
||
TADSGePoint3d ptLoc = pInsert1->position();
|
||
pInsert2->SetLocation(ptLoc);
|
||
pInsert2->SetScaleFactors(pInsert1->scaleFactors());
|
||
pInsert2->SetRotation(pInsert1->rotation());
|
||
pNewEnt = pInsert2;
|
||
}
|
||
else
|
||
{
|
||
TDbBlockInsert *pInsert2 = new TDbBlockInsert;
|
||
pInsert2->setPropertiesFrom(pInsert1);
|
||
pInsert2->setBlockTableRecord(pInsert1->blockTableRecord());
|
||
pInsert2->setNormal(pInsert1->normal());
|
||
pInsert2->setPosition(pInsert1->position());
|
||
pInsert2->setScaleFactors(pInsert1->scaleFactors());
|
||
pInsert2->setRotation(pInsert1->rotation());
|
||
pNewEnt = pInsert2;
|
||
}
|
||
|
||
Acad::ErrorStatus es = pInsert1->handOverTo(pNewEnt);
|
||
if (es == Acad::eObjectToBeDeleted)
|
||
{
|
||
resbuf *xd = ads_buildlist(1001, _T("_TCH_MASK"), NULL);
|
||
if (!XSymbolTable(_T("APPID"), _T("_TCH_MASK")))
|
||
{
|
||
ads_regapp(_T("_TCH_MASK"));
|
||
}
|
||
|
||
pNewEnt->setXData(xd);
|
||
pNewEnt->close();
|
||
delete pInsert1;
|
||
ads_relrb(xd);
|
||
}
|
||
else
|
||
{
|
||
pInsert1->close();
|
||
delete pNewEnt;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
g_bPrinting = FALSE;
|
||
}
|
||
|
||
void InitDbWallPatch(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbWallPatch::rxInit();
|
||
TDbWallPatch::SetEditMethod(EditWallPathc0);
|
||
TDbWallPatch::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
TDbWallPatch::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbWallPatch::desc());
|
||
}
|
||
}
|
||
|
||
void InitDbWall(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbWall::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbWall::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
TDbWall::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbWall::desc());
|
||
}
|
||
}
|
||
|
||
void InitDbColumn(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbColumn::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbColumn::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
TDbColumn::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbColumn::desc());
|
||
}
|
||
}
|
||
|
||
void InitDbPolyCurveEnt(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbPolyCurveEnt::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbPolyCurveEnt::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
TDbPolyCurveEnt::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbPolyCurveEnt::desc());
|
||
}
|
||
}
|
||
|
||
void InitDbBlockInsert(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbBlockInsert::rxInit();
|
||
TDbMultiViewInsert::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbMultiViewInsert::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
deleteAcRxClass(TDbBlockInsert::desc());
|
||
deleteAcRxClass(TDbMultiViewInsert::desc());
|
||
}
|
||
}
|
||
|
||
void InitDbProtectEntity(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
TDbProtectEntity::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbProtectEntity::SetEditMethod(EditProtectEntity);
|
||
TDbProtectEntity::InitMatchProtocol(TRUE);
|
||
}
|
||
else
|
||
{
|
||
TDbProtectEntity::InitMatchProtocol(FALSE);
|
||
deleteAcRxClass(TDbProtectEntity::desc());
|
||
}
|
||
}
|
||
|
||
//COMMAND:TProtect
|
||
void ProtectEntity()
|
||
{
|
||
TchGeLib::adsout<<_T("\n执行本命令前，请先备份图形！");
|
||
TPickEntSet ss(SS_FREE);
|
||
TRBList mask1 = ads_buildlist(-4, _T("<NOT"), RTDXF0,_T("ATS_PROTECT_ENTITY"), -4, _T("NOT>"), NULL);
|
||
if (SelectEntities(_T("\n选择需要保护的图元<退出>:"),ss,mask1) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TRBList mask(RTDXF0, _T("VIEWPORT"), NULL);
|
||
ss.BaseExclude(mask);
|
||
|
||
if (ss.Length() < 1)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TDbProtectEntity *pNewEntity = new TDbProtectEntity;
|
||
AcDbObjectId idEnt = pNewEntity->AddToCSpace(Adesk::kFalse);
|
||
pNewEntity->createExtensionDictionary();
|
||
|
||
AcDbObjectId idDict = pNewEntity->extensionDictionary();
|
||
pNewEntity->close();
|
||
|
||
AcDbDictionary *pDict = NULL;
|
||
acdbOpenObject(pDict,idDict,AcDb::kForWrite);
|
||
if (pDict == NULL)
|
||
{
|
||
TchGeLib::adsout<<_T("建立只读对象失败!");
|
||
delete pNewEntity;
|
||
return;
|
||
}
|
||
|
||
AcDbBlockTableRecord *pRecord = new AcDbBlockTableRecord;
|
||
pRecord->setName(_T("TCH_PR"));
|
||
|
||
AcDbObjectId idRecord;
|
||
Acad::ErrorStatus es = pDict->setAt(DICT_ENTRY_NAME,pRecord,idRecord);
|
||
pRecord->close();
|
||
pDict->close();
|
||
|
||
AcDbObjectIdArray idArray;
|
||
ss.AsIdArray(idArray);
|
||
|
||
long count = idArray.length();
|
||
AcDbIdMapping idMap;
|
||
es = acdbHostApplicationServices()->workingDatabase()->deepCloneObjects(idArray,idRecord,idMap);
|
||
if (es != Acad::eOk)
|
||
{
|
||
TchGeLib::adsout<<_T("建立只读对象失败!");
|
||
}
|
||
else
|
||
{
|
||
ss.Erase();
|
||
}
|
||
|
||
EditProtectEntity(idEnt);
|
||
}
|
||
|
||
// 修改图块, 屏蔽或取消屏蔽
|
||
int ModifyInsert(Entity ent, int nMaskFlag)
|
||
{
|
||
AcDbObjectId idBlock;
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
||
if(!pEnt)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
if(pEnt->isKindOf(TDbMultiViewInsert::desc()))
|
||
{
|
||
TDbMultiViewInsert *pIns=TDbMultiViewInsert::cast(pEnt);
|
||
idBlock=pIns->GetBlockId(FALSE);
|
||
}
|
||
else if(pEnt->isKindOf(AcDbBlockReference::desc()))
|
||
{
|
||
AcDbBlockReference *pIns=AcDbBlockReference::cast(pEnt);
|
||
idBlock=pIns->blockTableRecord();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
if(!idBlock)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if((nMaskFlag&BIF_POLYMASK))
|
||
{
|
||
XPoly2D x(1);
|
||
if(GetBlockBoundary(idBlock, x, TRUE)!=RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n无法确定图块的精确边界!");
|
||
return RTERROR;
|
||
}
|
||
}
|
||
if(InitBlockWipeout(idBlock, nMaskFlag))
|
||
{
|
||
PickSet ss(SS_FREE);
|
||
if(ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL))==RTNORM)
|
||
{
|
||
UpdateGraphic(ss);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return RTERROR;
|
||
}
|
||
return RTNORM;
|
||
}
|
||
|
||
//COMMAND:TUnProtect
|
||
void UnProtect()
|
||
{
|
||
TEntitySet ent;
|
||
if (SelectEntity(_T("\n选择保护图元:"),ent,TRBList(RTDXF0,_T("ATS_PROTECT_ENTITY"),NULL)) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
OPENOBJ_BEGIN(ent,AcDb::kForWrite,TDbProtectEntity,pEnt);
|
||
if (pEnt != NULL)
|
||
{
|
||
if (UnProtect(pEnt))
|
||
{
|
||
pEnt->erase();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
// Command: 取消屏蔽
|
||
//支持删除wipeout,modified by W on 081217
|
||
void BlockUnMask()
|
||
{
|
||
TPushAcadVar<int> cmdecho(_T("CMDECHO"), 0);
|
||
SHads_command(RTSTR,_T("WIPEOUT"),RTSTR,_T("F"),RTSTR,_T("On"),RTNONE);
|
||
|
||
TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT,WIPEOUT"), NULL);
|
||
TPickEntSet ss(SS_FREE);
|
||
if (SelectEntities(_T("\n选择图块或屏蔽对象:"), ss, mask) == RTNORM)
|
||
{
|
||
long lCount = ss.Length();
|
||
for (long i = 0L; i < lCount; i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
if (ent.Is(_T("WIPEOUT")))
|
||
{
|
||
ent.Delete();
|
||
}
|
||
else
|
||
{
|
||
if (ModifyInsert(ent, 0) != RTNORM)
|
||
{
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
SHads_command(RTSTR,_T("WIPEOUT"),RTSTR,_T("F"),RTSTR,_T("Off"),RTNONE); //还无法判断wipeout框状态，所以就关了,(保存在AcDbDictionary系统词典)
|
||
}
|
||
|
||
// Command: 矩形屏蔽
|
||
void BringFront1()
|
||
{
|
||
TEntitySet ent;
|
||
TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL);
|
||
if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM)
|
||
{
|
||
if (ModifyInsert(ent, BIF_RECTMASK) != RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n无法完成矩形屏蔽!");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Command: 精确屏蔽
|
||
void BringFront2()
|
||
{
|
||
TEntitySet ent;
|
||
TRBList mask(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL);
|
||
if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM)
|
||
{
|
||
if (ModifyInsert(ent, BIF_POLYMASK) != RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n无法完成精确屏蔽!");
|
||
}
|
||
}
|
||
}
|
||
|
||
// Command: 转化图块
|
||
void ConvertInsert()
|
||
{
|
||
TEntitySet ent;
|
||
TRBList mask(RTDXF0, _T("INSERT"), NULL);
|
||
if (SelectEntity(_T("\n选择图块:"), ent, mask) == RTNORM)
|
||
{
|
||
int nAttribFlag;
|
||
int nRet = RTERROR;
|
||
if (ent.GetData(66, &nAttribFlag) == RTNORM && nAttribFlag != 0)
|
||
{
|
||
TchGeLib::adsout << _T("\n存在属性，不能转化!");
|
||
return;
|
||
}
|
||
|
||
AcDbBlockReference *pInsert1 = NULL;
|
||
AcDbObjectId idEnt;
|
||
acdbGetObjectId(idEnt, ent.name);
|
||
if (acdbOpenObject(pInsert1, idEnt, AcDb::kForWrite) == Acad::eOk &&
|
||
pInsert1 != NULL)
|
||
{
|
||
if (pInsert1->isKindOf(AcDbMInsertBlock::desc()))
|
||
{
|
||
TchGeLib::adsout << _T("\n多重引用块，不能转化!");
|
||
pInsert1->close();
|
||
return;
|
||
}
|
||
|
||
AcDbObjectId idBlock = pInsert1->blockTableRecord();
|
||
TDbBlockInsert *pInsert2 = new TDbBlockInsert;
|
||
pInsert2->setPropertiesFrom(pInsert1);
|
||
pInsert2->setNormal(pInsert1->normal());
|
||
pInsert2->setBlockTableRecord(idBlock);
|
||
pInsert2->setPosition(pInsert1->position());
|
||
pInsert2->setScaleFactors(pInsert1->scaleFactors());
|
||
pInsert2->setRotation(pInsert1->rotation());
|
||
|
||
Acad::ErrorStatus es = pInsert1->handOverTo(pInsert2);
|
||
if (es == Acad::eObjectToBeDeleted)
|
||
{
|
||
pInsert2->close();
|
||
delete pInsert1;
|
||
}
|
||
else
|
||
{
|
||
delete pInsert2;
|
||
pInsert1->close();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 用在设置宽度的命令
|
||
static int _GetWallWidth()
|
||
{
|
||
resbuf *rb, *ebuf = ads_getargs();
|
||
if (ebuf)
|
||
{
|
||
rb = ebuf;
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTREAL)
|
||
{
|
||
g_nIntWallWidth = _AS_MM(rb->resval.rreal);
|
||
}
|
||
else if (rb->restype == RTSHORT)
|
||
{
|
||
g_nIntWallWidth = _AS_MM(rb->resval.rint);
|
||
}
|
||
rb = rb->rbnext;
|
||
}
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTREAL)
|
||
{
|
||
g_nIntWidth = _AS_MM(rb->resval.rreal);
|
||
}
|
||
else if (rb->restype==RTSHORT)
|
||
{
|
||
g_nIntWidth = _AS_MM(rb->resval.rint);
|
||
}
|
||
rb = rb->rbnext;
|
||
}
|
||
if (rb)
|
||
{
|
||
if (rb->restype == RTREAL)
|
||
{
|
||
g_nExtWidth = _AS_MM(rb->resval.rreal);
|
||
}
|
||
else if (rb->restype == RTSHORT)
|
||
{
|
||
g_nExtWidth = _AS_MM(rb->resval.rint);
|
||
}
|
||
rb = rb->rbnext;
|
||
}
|
||
|
||
if (rb)
|
||
{
|
||
ads_real nOldLen = minLenWall;
|
||
if (rb->restype == RTREAL)
|
||
{
|
||
minLenWall = _AS_MM(rb->resval.rreal);
|
||
}
|
||
else if (rb->restype == RTSHORT)
|
||
{
|
||
minLenWall = _AS_MM(rb->resval.rint);
|
||
}
|
||
rb = rb->rbnext;
|
||
if (minLenWall < 0)
|
||
{
|
||
minLenWall = nOldLen;
|
||
}
|
||
}
|
||
ads_relrb(ebuf);
|
||
return RTNORM;
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
// Command:
|
||
// 设置缺省的墙宽
|
||
int SetWallWidth()
|
||
{
|
||
if(_GetWallWidth()==RTNORM)
|
||
{
|
||
return RTNORM;
|
||
}
|
||
|
||
TCString iw(_T("\n内墙宽<%g>: "), _AS_SYS_UNIT(g_nIntWallWidth));
|
||
TCString intw(_T("\n外墙内侧宽<%g>: "), _AS_SYS_UNIT(g_nIntWidth));
|
||
TCString extw(_T("\n外墙外侧宽<%g>: "), _AS_SYS_UNIT(g_nExtWidth));
|
||
|
||
ads_real r1, r2, r3;
|
||
int rc = -1;
|
||
ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
|
||
rc = ads_getreal(iw, &r1);
|
||
if (rc == RTERROR || rc==RTCAN)
|
||
{
|
||
return rc;
|
||
}
|
||
else if (rc == RTNORM)
|
||
{
|
||
g_nIntWallWidth=_AS_MM(r1);
|
||
}
|
||
|
||
rc = ads_getreal(intw, &r2);
|
||
if (rc == RTERROR || rc == RTCAN)
|
||
{
|
||
return rc;
|
||
}
|
||
else if (rc == RTNORM)
|
||
{
|
||
g_nIntWidth=_AS_MM(r2);
|
||
}
|
||
|
||
rc = ads_getreal(extw, &r3);
|
||
if (rc == RTERROR || rc == RTCAN)
|
||
{
|
||
return rc;
|
||
}
|
||
else if (rc == RTNORM)
|
||
{
|
||
g_nExtWidth = _AS_MM(r3);
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
//对象编辑
|
||
int EditProtectEntity(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbProtectEntity, pEnt);
|
||
if (pEnt != NULL)
|
||
{
|
||
if (pEnt->CanExplode()) //可分解时，设置新密码
|
||
{
|
||
if (pEnt->upgradeOpen() == Acad::eOk)
|
||
{
|
||
CTemporaryResourceOverride vTemp;
|
||
CProtectSetDlg dlg(pEnt);
|
||
dlg.DoModal();
|
||
pEnt->downgradeOpen();
|
||
}
|
||
}
|
||
else //不能分解时，输入旧密码
|
||
{
|
||
TCHAR sCode1[256] = _T("");
|
||
if (acedGetString(NULL,_T("\n输入密码<退出>:"),sCode1) == RTNORM)
|
||
{
|
||
if (pEnt->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pEnt->SetCode1(sCode1);
|
||
pEnt->downgradeOpen();
|
||
|
||
if (!pEnt->CanExplode())
|
||
{
|
||
TchGeLib::adsout<<_T("\n密码错误!");
|
||
}
|
||
else
|
||
{
|
||
TchGeLib::adsout<<_T("\n密码正确,此只读对象进入可分解、可通过对象编辑修改保护权限的临时状态!");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
bool UnProtect(TDbProtectEntity*pEnt)
|
||
{
|
||
AcDbBlockTableRecord *pRecord = NULL;
|
||
acdbOpenObject(pRecord,pEnt->GetBlockRecordId(),AcDb::kForWrite);
|
||
if (pRecord != NULL)
|
||
{
|
||
AcDbBlockTableRecordIterator *pIter = NULL;
|
||
pRecord->newIterator(pIter);
|
||
if (pIter != NULL)
|
||
{
|
||
AcDbObjectIdArray idArray;
|
||
for (pIter->start(); !pIter->done(); pIter->step())
|
||
{
|
||
AcDbObjectId id;
|
||
AcDbEntity *pSubEnt;
|
||
pIter->getEntity(pSubEnt,AcDb::kForWrite);
|
||
|
||
if (pSubEnt != NULL)
|
||
{
|
||
TDbProtectEntity* pProtect = TDbProtectEntity::cast(pSubEnt);
|
||
if (pProtect != NULL)
|
||
{
|
||
UnProtect(pProtect);
|
||
}
|
||
else
|
||
{
|
||
pIter->getEntityId(id);
|
||
idArray.append(id);
|
||
}
|
||
|
||
pSubEnt->close();
|
||
}
|
||
}
|
||
|
||
if (idArray.length() > 0)
|
||
{
|
||
AcDbObjectId idMSpace;
|
||
{
|
||
TAcDbBlockTableRecPtr mspace(ACDB_MODEL_SPACE, AcDb::kForWrite);
|
||
idMSpace = mspace.m_pBlockTableRec->objectId();
|
||
}
|
||
|
||
AcDbIdMapping idMap;
|
||
Acad::ErrorStatus es = acdbHostApplicationServices()->workingDatabase()->deepCloneObjects(idArray,idMSpace,idMap);
|
||
int pos;
|
||
idArray.find(NULL,pos);
|
||
}
|
||
|
||
delete pIter;
|
||
}
|
||
|
||
pRecord->erase();
|
||
pRecord->close();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
int DragInsertBlock1(const TCHAR *szBlock, int nFlag, const AcGeScale3d &scales)
|
||
{
|
||
TADSGePoint3d ptInsert;
|
||
VERIFY(TGGetVar(_T("VIEWCTR"), &ptInsert) == RTNORM);
|
||
|
||
AcDbObjectId idInsert = (nFlag&IBF_TINSERT) ?
|
||
MakeTBlockInsert(szBlock,ptInsert, scales[0], scales[1], scales[2],Ucs2Wcs(0),0) :
|
||
MakeBlockInsert(szBlock,ptInsert, scales[0], scales[1], scales[2], Ucs2Wcs(0));
|
||
if (!idInsert)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
TEntitySet ent;
|
||
VERIFY(acdbGetAdsName(ent.name, idInsert) == Acad::eOk);
|
||
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
||
ASSERT(pEnt);
|
||
pEnt->draw();
|
||
OPENOBJ_END();
|
||
|
||
int rc = RTNORM;
|
||
ptInsert = Wcs2Ucs(ptInsert);
|
||
while(rc == RTNORM)
|
||
{
|
||
rc = IDragInsertBlock(ptInsert, ent, nFlag);
|
||
if (rc == RTNORM && (nFlag&IBF_MINSERT))
|
||
{
|
||
TPushAcadVar<int> osmode(_T("OSMODE"), 0);
|
||
SHads_command(RTSTR, _T(".COPY"), RTENAME, (TLong_ptr *)ent, RTSTR, _T(""),
|
||
RT3DPOINT, &ptInsert,RT3DPOINT, &ptInsert, RTNONE);
|
||
ent.FreeGroups();
|
||
ent.GetLast();
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
int IDragInsertBlock(TADSGePoint3d &ptBase, TEntitySet &ent, int nFlag)
|
||
{
|
||
double nScale = 1.0;
|
||
ent.GetData(41, &nScale);
|
||
TPickEntSet ss(SS_FREE);
|
||
ss += ent;
|
||
|
||
int nOptFlag = IBF_ROT90|IBF_MIRLR|IBF_MIRUD|IBF_ALIGN|IBF_FRAME|IBF_ROTATE|IBF_BASEPT|IBF_RESEL|IBF_SCALE;
|
||
TCString szPrompt(256);
|
||
szPrompt << _T("\n点取插入点或 ");
|
||
if (nFlag & nOptFlag)
|
||
{
|
||
szPrompt << _T("[");
|
||
}
|
||
BOOL bInitOption = FALSE;
|
||
int nOptionArray[9] = {IBF_ROT90,IBF_MIRLR,IBF_MIRUD,IBF_ALIGN,IBF_FRAME,IBF_ROTATE,IBF_BASEPT,IBF_RESEL,IBF_SCALE};
|
||
const TCHAR * szOptionPrompt[9] = {_T("转90(A)"), _T("左右(S)"), _T("上下(D)"), _T("对齐(F)"), _T("外框(E)"),
|
||
_T("转角(R)"), _T("基点(T)"), _T("更换(C)"), _T("比例(X)"),};
|
||
TCHAR szKeywordArray[10] = _T("ASDFERTCX");
|
||
TCString sKeywords;
|
||
for (int n = 0; n < 9; n++)
|
||
{
|
||
if (nFlag&nOptionArray[n])
|
||
{
|
||
if (bInitOption)
|
||
{
|
||
szPrompt << _T("/");
|
||
sKeywords << _T(" ");
|
||
}
|
||
bInitOption = TRUE;
|
||
szPrompt << szOptionPrompt[n];
|
||
TCHAR szTemp[2] = _T("");
|
||
szTemp[0] = szKeywordArray[n];
|
||
szTemp[1] = EOS;
|
||
sKeywords << szTemp;
|
||
}
|
||
}
|
||
if (nFlag & nOptFlag)
|
||
{
|
||
szPrompt << _T("]");
|
||
}
|
||
szPrompt << _T("<退出>:");
|
||
|
||
int rc = 0;
|
||
TCHAR draggenprompt[512] = _T("");
|
||
int cur = 0;
|
||
TADSGePoint3d ptFinal;
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//g_ptBase = ptBase;
|
||
TAdvanceSampler::g_ptBase = ptBase;
|
||
|
||
TchGeLib::adsout << szPrompt;
|
||
|
||
LAB_DRAG:
|
||
ss.RedrawAll(2);
|
||
sKeywords<<_T(" ~");
|
||
|
||
INITGET_BEG(0, !sKeywords? NULL : (const TCHAR *)sKeywords);
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//rc = ads_draggen(ss, draggenprompt, cur, MoveSamplerStatic, ptFinal);
|
||
rc = ads_draggen(ss, draggenprompt, cur, TAdvanceSampler::MoveSampler, ptFinal);
|
||
|
||
INITGET_END();
|
||
|
||
if (rc == RTKWORD)
|
||
{
|
||
TADSGePoint3d g_ptNewBase = GetCursorWcs();
|
||
TCString sKeyChar;
|
||
VERIFY(ads_getinput(sKeyChar) == RTNORM);
|
||
ads_matrix mat;
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//Ucs2Wcs( g_ptBase).GetMoveMatrix(g_ptNewBase, mat);
|
||
Ucs2Wcs( TAdvanceSampler::g_ptBase).GetMoveMatrix(g_ptNewBase, mat);
|
||
|
||
VERIFY(ads_xformss(ss, mat) == RTNORM);
|
||
|
||
ads_printf(_T("%c%c %c"), 8,8,8);
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//g_ptBase = Wcs2Ucs(g_ptNewBase);
|
||
TAdvanceSampler::g_ptBase = Wcs2Ucs(g_ptNewBase);
|
||
|
||
if (sKeyChar[0] == _T('A') || sKeyChar[0] == _T('S') || sKeyChar[0] == _T('D'))
|
||
{
|
||
TPushAcadVar<int> nMode(_T("OSMODE"), 0);
|
||
TADSGePoint3d ptOther;
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//if (sKeyChar[0] == _T('S'))
|
||
//{
|
||
// ptOther = g_ptBase+TADSGePoint3d(0,100,0);
|
||
// SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (long *)ss, RTSTR, _T(""),
|
||
// RT3DPOINT, & g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
|
||
//}
|
||
//else if (sKeyChar[0] == _T('D'))
|
||
//{
|
||
// ptOther = g_ptBase+TADSGePoint3d(100,0,0);
|
||
// SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (long *)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 *)ss, RTSTR, _T(""),
|
||
// RT3DPOINT, & g_ptBase, RTREAL, 90.0, RTNONE);
|
||
//}
|
||
if (sKeyChar[0] == _T('S'))
|
||
{
|
||
ptOther = TAdvanceSampler::g_ptBase+TADSGePoint3d(0,100,0);
|
||
SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, & TAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
|
||
}
|
||
else if (sKeyChar[0] == _T('D'))
|
||
{
|
||
ptOther = TAdvanceSampler::g_ptBase+TADSGePoint3d(100,0,0);
|
||
SHads_command(RTSTR, _T(".MIRROR"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, & TAdvanceSampler::g_ptBase, RT3DPOINT, &ptOther, RTSTR, _T("Y"), RTNONE);
|
||
}
|
||
else if (sKeyChar[0] == _T('A'))
|
||
{
|
||
SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, & TAdvanceSampler::g_ptBase, RTREAL, 90.0, RTNONE);
|
||
}
|
||
|
||
rc = RTNORM;
|
||
}
|
||
else if (sKeyChar[0] == _T('C'))
|
||
{
|
||
rc = IBF_RESEL;
|
||
}
|
||
else if (sKeyChar[0] == _T('X'))
|
||
{
|
||
CString csPrompt;
|
||
double nNewScale(nScale);
|
||
csPrompt.Format(_T("\n请输入比例:<%.1f> "), nScale);
|
||
ads_getreal(csPrompt, &nNewScale);
|
||
nScale = nNewScale / nScale;
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//SHads_command(RTSTR, _T(".SCALE"), RTPICKS, (long *)ss, RTSTR, _T(""),
|
||
// RT3DPOINT, & g_ptBase, RTREAL, nScale, RTNONE);
|
||
rc = SHads_command(RTSTR, _T(".SCALE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, & TAdvanceSampler::g_ptBase, RTREAL, nScale, RTNONE);
|
||
|
||
nScale = nNewScale;
|
||
if (rc == RTNORM)
|
||
{
|
||
TchGeLib::adsout << szPrompt;
|
||
}
|
||
}
|
||
else if (sKeyChar[0] == _T('R'))
|
||
{
|
||
double nRot = 0.0;
|
||
TchGeLib::adsout << _T("\n旋转角度: ");
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ss,
|
||
// RTSTR, _T(""), RT3DPOINT, & g_ptBase, RTSTR, _T("\\"), RTNONE);
|
||
rc = SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss,
|
||
RTSTR, _T(""), RT3DPOINT, & TAdvanceSampler::g_ptBase, RTSTR, _T("\\"), RTNONE);
|
||
|
||
if (rc == RTNORM)
|
||
{
|
||
TchGeLib::adsout << szPrompt;
|
||
}
|
||
}
|
||
else if (sKeyChar[0] == _T('T'))
|
||
{
|
||
int nOsMode = 0;
|
||
TGGetVar(_T("OSMODE"), &nOsMode);
|
||
nOsMode &= ~0x4000;
|
||
nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
|
||
TPushAcadVar<int> vOsMode(_T("OSMODE"), nOsMode);
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//rc = GetPickPoint(NULL, _T("\n输入插入点"), g_ptBase);
|
||
rc = GetPickPoint(NULL, _T("\n输入插入点"), TAdvanceSampler::g_ptBase);
|
||
|
||
if (rc == RTNORM)
|
||
{
|
||
TchGeLib::adsout << szPrompt;
|
||
}
|
||
}
|
||
else if (sKeyChar[0] == _T('E'))
|
||
{
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
||
ASSERT(pEnt);
|
||
pEnt->draw();
|
||
OPENOBJ_END();
|
||
ss.RedrawAll(2);
|
||
TADSGePoint3d ptCorn1, ptCorn2;
|
||
rc = GetPickPoint(NULL, _T("\n第一个角点"), ptCorn1);
|
||
if (rc == RTNORM)
|
||
{
|
||
double m_nRot = 0.0;
|
||
TADSGePoint3d ptIns;
|
||
ent.FreeGroups();
|
||
ent.GetData(50, &m_nRot);
|
||
TVector3D vtRot(cos(m_nRot), sin(m_nRot));
|
||
vtRot = Wcs2Ucs(vtRot, TRUE);
|
||
TchGeLib::adsout << _T("\n另一个角点: ");
|
||
rc = GetRectAngleStatic(ptCorn1, ads_angle(TADSGePoint3d(), vtRot), ptCorn2);
|
||
if (rc == RTNORM)
|
||
{
|
||
ptCorn1 = Ucs2Wcs(ptCorn1);
|
||
ptCorn2 = Ucs2Wcs(ptCorn2);
|
||
|
||
double nAngle1 = AngleRangeTo2PI(ads_angle(ptCorn1, ptCorn2)-m_nRot);
|
||
double nDist = ptCorn1.Distance2d(ptCorn2);
|
||
TADSGePoint3d m_ptCen;
|
||
Midpoint(ptCorn1, ptCorn2, m_ptCen);
|
||
double m_nSizeX = nDist*fabs(cos(nAngle1));
|
||
double m_nSizeY = nDist*fabs(sin(nAngle1));
|
||
|
||
ads_matrix matRotOld, matMove, matScale, matRotNew, matTransform;
|
||
double nSizeX, nSizeY, nSizeZ, nRot;
|
||
TADSGePoint3d ptCen, ptNewCen;
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbBlockReference, pBlkSrc);
|
||
ASSERT(pBlkSrc);
|
||
VERIFY(GetBlockRefSizeInfo(pBlkSrc, ptIns, &nRot, ptCen, &nSizeX, &nSizeY, &nSizeZ) == RTNORM);
|
||
|
||
ptNewCen = m_ptCen;
|
||
ptNewCen.z += nSizeZ/2.0;
|
||
|
||
// 绕旧中心旋转-nRotOld -> 绕旧中心Scale -> 平移到新中心 -> 旋转 RotNew
|
||
// or
|
||
// 绕旧中心旋转-nRotOld -> 绕旧中心Scale -> 旋转 RotNew -> 平移到新中心 (Current Method)
|
||
AcGeScale3d bScale = pBlkSrc->scaleFactors();
|
||
double sx = 1, sy = 1, sz = 1;
|
||
if (fabs(nSizeX) > 1.0E-6)
|
||
{
|
||
bScale[0] *= sx = m_nSizeX/nSizeX;
|
||
}
|
||
if (fabs(nSizeY) > 1.0E-6)
|
||
{
|
||
bScale[1] *= sy = m_nSizeY/nSizeY;
|
||
}
|
||
|
||
ptCen.GetRotationMatrix(-nRot, matRotOld);
|
||
ptCen.GetScaleMatrix(sx, sy, sz, matScale);
|
||
ptCen.GetRotationMatrix(m_nRot, matRotNew);
|
||
ptCen.GetMoveMatrix(ptNewCen, matMove);
|
||
|
||
MatrixMultiply(matTransform, matMove, matRotNew, matScale, matRotOld, NULL);
|
||
ptIns.TransformBy(matTransform); //换算新的基点位置
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//TADSGePoint3d ptBaseWcs = Ucs2Wcs( g_ptBase);
|
||
//ptBaseWcs.TransformBy(matTransform);
|
||
//g_ptBase = Wcs2Ucs(ptBaseWcs);
|
||
TADSGePoint3d ptBaseWcs = Ucs2Wcs( TAdvanceSampler::g_ptBase);
|
||
ptBaseWcs.TransformBy(matTransform);
|
||
TAdvanceSampler::g_ptBase = Wcs2Ucs(ptBaseWcs);
|
||
|
||
pBlkSrc->setPosition(ptIns);
|
||
pBlkSrc->setScaleFactors(bScale);
|
||
OPENOBJ_END();
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//ptBase = g_ptBase;
|
||
ptBase = TAdvanceSampler::g_ptBase;
|
||
return RTNORM;
|
||
}
|
||
}
|
||
}
|
||
else if (sKeyChar[0] == _T('F'))
|
||
{
|
||
int nOsMode = 0;
|
||
TGGetVar(_T("OSMODE"), &nOsMode);
|
||
nOsMode &= ~0x4000;
|
||
nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_MID|OS_CEN;
|
||
TPushAcadVar<int> vOsMode(_T("OSMODE"), nOsMode);
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//TADSGePoint3d pt1 = g_ptBase, pt2, qt1, qt2;
|
||
TADSGePoint3d pt1 = TAdvanceSampler::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)
|
||
{
|
||
TPushAcadVar<int> osmode(_T("OSMODE"), 0);
|
||
double nRot = AngleRangeTo2PI(ads_angle(qt1, qt2)-ads_angle(pt1, pt2));
|
||
SHads_command(RTSTR, _T(".MOVE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, &pt1, RT3DPOINT, &qt1, RTNONE);
|
||
SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
|
||
RT3DPOINT, &qt1, RTREAL, nRot*180/PI, RTNONE);
|
||
rc = RTNORM;
|
||
ptBase = qt1;
|
||
return rc;
|
||
}
|
||
}
|
||
else if (sKeyChar[0] == _T('~'))
|
||
{
|
||
return RTNIL;
|
||
}
|
||
|
||
if (rc == RTNORM)
|
||
{
|
||
goto LAB_DRAG;
|
||
}
|
||
}
|
||
|
||
switch (rc)
|
||
{
|
||
case RTNORM:
|
||
{
|
||
ads_matrix mat;
|
||
|
||
//modify by xlc on 081019 水专业插图库时预览位置不正确
|
||
//Ucs2Wcs( g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);
|
||
Ucs2Wcs( TAdvanceSampler::g_ptBase).GetMoveMatrix(Ucs2Wcs(ptFinal), mat);
|
||
|
||
VERIFY(ads_xformss(ss, mat) == RTNORM);
|
||
ptBase = ptFinal;
|
||
break;
|
||
}
|
||
case RTCAN:
|
||
case RTNONE:
|
||
case RTERROR:
|
||
default:
|
||
ent.Delete();
|
||
break;
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
|
||
// 从二维图块中提取外轮廓线
|
||
int GetBoundaryFromInsert2D(TEntitySet &ent, TGGePoly2D &polyOutline)
|
||
{
|
||
if (GetExistOutlineFromInsert(ent, polyOutline) == RTNORM)
|
||
{
|
||
return RTNORM;
|
||
}
|
||
|
||
TDPtrList<TGGeCurveSegment> lstSegs;
|
||
if (GetCurveFromInsert2D(ent, lstSegs) != RTNORM || !lstSegs)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
return GetExternalBoundaryFromCurves(lstSegs, polyOutline);
|
||
}
|
||
|
||
void SearchSpace(TPickEntSet &ssWalls,const TDPtrList<AcDbObjectId> &lstColu,TDPtrList<TDbSpace> &res)
|
||
{
|
||
TSearchSpaceFromWall aSearch;
|
||
try
|
||
{
|
||
aSearch.InitStart(ssWalls, lstColu);
|
||
}
|
||
catch (...)
|
||
{
|
||
TchGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
|
||
return;
|
||
}
|
||
|
||
TAecSpaceCell * extCell = aSearch.SearchSpaces();
|
||
TDbSpace *pDbExtSpace = NULL;
|
||
for (int n = 0; n<aSearch.spaces.Length(); n++)
|
||
{
|
||
TAecSpaceCell *pSpace = aSearch.spaces[n];
|
||
|
||
TGGePoly2D polySpace(1);
|
||
pSpace->CenterPoly2D(polySpace);
|
||
polySpace.SetElevation(0.0); //投影到z = 0的平面上
|
||
|
||
TADSGePoint3d ptLoc;
|
||
polySpace.Center(ptLoc);
|
||
ptLoc.z = 0.0;
|
||
|
||
if ((ptLoc&polySpace) != PR_INSIDE)
|
||
{
|
||
TGGePoly polyTemp;
|
||
polySpace.MapToPolygon(polyTemp, 20);
|
||
if (!!polyTemp)
|
||
{
|
||
TGGePolygonEx polyTri(polyTemp);
|
||
TDPtrList<TGGeTriangle> lstTri;
|
||
if (polyTri.Trianglize(lstTri, TRUE) == RTNORM && !!lstTri)
|
||
{
|
||
TGGeTriangle *pTri = lstTri[0];
|
||
ptLoc.x = (pTri->vertex1.x+pTri->vertex2.x+pTri->vertex3.x)/3.0;
|
||
ptLoc.y = (pTri->vertex1.y+pTri->vertex2.y+pTri->vertex3.y)/3.0;
|
||
}
|
||
}
|
||
}
|
||
|
||
TDbSpace *pDbSpace = new TDbSpace;
|
||
pDbSpace->m_sName = _T("房间");
|
||
pDbSpace->m_ptLocation = ptLoc;
|
||
pDbSpace->SetTextStyleId(InitTextStyle(TS_SPACE));
|
||
pDbSpace->UpdateFrom(*pSpace, pSpace == extCell);
|
||
if (pSpace == extCell)
|
||
{
|
||
pDbExtSpace = pDbSpace;
|
||
pDbExtSpace->m_sName = _T("建筑面积");
|
||
pDbExtSpace->m_sCode = _T("0");
|
||
}
|
||
else
|
||
{
|
||
res.Append(pDbSpace);
|
||
}
|
||
}
|
||
if (pDbExtSpace != NULL)
|
||
{
|
||
res.Append(pDbExtSpace);
|
||
}
|
||
}
|
||
TCString GetCurCommand()
|
||
{
|
||
TCString sCmd;
|
||
TArchPerDocData *pData = GetCurDocData();
|
||
if (pData)
|
||
{
|
||
sCmd = pData->m_sCurCommand;
|
||
}
|
||
return sCmd;
|
||
}
|
||
|
||
AcDbObjectId MakeBlockInsert(const TCHAR *pszBlock, TADSGePoint3d ptInsert,double sx, double sy, double sz, double rot)
|
||
{
|
||
AcDbObjectId idBlock = InitBlock(pszBlock);
|
||
if (!idBlock)
|
||
{
|
||
return idBlock;
|
||
}
|
||
|
||
AcDbBlockReference *pInsert = new AcDbBlockReference(ptInsert, idBlock);
|
||
pInsert->setScaleFactors(AcGeScale3d(sx, sy, sz));
|
||
pInsert->setRotation(rot);
|
||
|
||
AcDbObjectId idInsert = AddToCurrentSpace(pInsert, Adesk::kTrue);
|
||
if (!idInsert)
|
||
{
|
||
delete pInsert;
|
||
}
|
||
|
||
return idInsert;
|
||
}
|
||
|
||
void GetAllColumnBoundry(TDPtrList<TGGePoly2D> &lstClipBoundry)
|
||
{
|
||
TDPtrList<AcDbObjectId> ssColumns;
|
||
GetEntFromBlockByDxf(ssColumns, _T("ATS_COLUMN"));
|
||
int ssLen = ssColumns.Length();
|
||
for (long i = 0; i<ssLen; i++)
|
||
{
|
||
TAcDbObjectPtr obj(*ssColumns[i], AcDb::kForRead);
|
||
if (!obj)
|
||
{
|
||
continue;
|
||
}
|
||
TDbColumn *pColumn = TDbColumn::cast(obj.m_pObject);
|
||
if (pColumn && !pColumn->IsFortifyColumn())
|
||
{
|
||
const TGGePoly2D &polyOut = pColumn->GetOutlinePoly();
|
||
if (!!polyOut)
|
||
{
|
||
TGGePoly2D *pPoly = new TGGePoly2D(polyOut);
|
||
lstClipBoundry.Append(pPoly);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void UpdateTDbEntity()
|
||
{
|
||
BOOL bSaveGlobal = DocGetIsDwgBegin();
|
||
DocSetIsDwgBegin(FALSE);
|
||
TPickEntSet ss(SS_FREE);
|
||
TRBList mask(RTDXF0, _T("TCH_*"), NULL);
|
||
if (ss.Get(_T("X"), NULL, NULL, mask) == RTNORM)
|
||
{
|
||
long lCount = ss.Length();
|
||
for (long i = 0L; i < lCount; i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
|
||
if (pEnt)
|
||
{
|
||
pEnt->assertWriteEnabled();
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
DocSetIsDwgBegin(bSaveGlobal);
|
||
}
|
||
|
||
void UpdateGraphic(TPickEntSet &ss)
|
||
{
|
||
BOOL bOld = g_bDwgBegin;
|
||
DocSetIsDwgBegin(FALSE);
|
||
|
||
AcAxDocLock docLock;
|
||
VERIFY(docLock.lockStatus() == Acad::eOk);
|
||
long lCount = ss.Length();
|
||
for (long i = 0L; i<lCount; i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
AcDbObjectId objId;
|
||
VERIFY(acdbGetObjectId(objId, ent.name) == Acad::eOk);
|
||
AcDbObjectPointer<AcDbEntity> pSq(objId, AcDb::kForWrite);
|
||
if (pSq.openStatus() == Acad::eOk)
|
||
{
|
||
pSq->recordGraphicsModified();
|
||
pSq->downgradeOpen();
|
||
pSq->draw();
|
||
}
|
||
|
||
}
|
||
DocSetIsDwgBegin(bOld);
|
||
}
|
||
|
||
void UpdateGraphic(const TDPtrList<AcDbObjectId> &ss)
|
||
{
|
||
|
||
BOOL bOld = g_bDwgBegin;
|
||
DocSetIsDwgBegin(FALSE);
|
||
|
||
AcAxDocLock docLock;
|
||
VERIFY(docLock.lockStatus() == Acad::eOk);
|
||
int lCount = ss.Length();
|
||
for (int i = 0; i<lCount; i++)
|
||
{
|
||
AcDbObjectId ent = ss[i];
|
||
TAcDbObjectPtr obj(ent, AcDb::kForWrite);
|
||
if (!!obj)
|
||
{
|
||
AcDbEntity &dbEnt = obj;
|
||
dbEnt.recordGraphicsModified();
|
||
dbEnt.downgradeOpen();
|
||
dbEnt.draw();
|
||
}
|
||
}
|
||
DocSetIsDwgBegin(bOld);
|
||
}
|
||
|
||
|
||
int GetColumnOutline(const AcDbObjectId &idColu, TGGePoly2D &poly)
|
||
{
|
||
int nRetCode = RTNORM;
|
||
poly.Reset();
|
||
OPENOBJ_BEGIN(idColu, AcDb::kForRead, TDbColumn, pColu);
|
||
if (pColu)
|
||
{
|
||
// sg modify 101206，根据8.5需求，搜索房间要考虑柱子保温
|
||
// pColu->GetOutline(poly);
|
||
pColu->GetColSurFacePoly2D(poly);
|
||
}
|
||
else
|
||
{
|
||
nRetCode = RTERROR;
|
||
}
|
||
OPENOBJ_END();
|
||
return nRetCode;
|
||
}
|
||
|
||
TARCH_IMPEXP int GetApplicationPath(TCHAR *vPath)
|
||
{
|
||
return GetApplicationPath(vPath,_hdllInstance);
|
||
}
|
||
|
||
// 初始化Aol库的连接
|
||
void InitAol(const TCHAR *szAppName)
|
||
{
|
||
if (szAppName)
|
||
{
|
||
TEntitySet::ApplicationName = xgAppname = szAppName;
|
||
}
|
||
|
||
GetApplicationPath(g_sAppPath,_hdllInstance);
|
||
|
||
//确保类型之间的等价转换
|
||
assert(sizeof(TADSGePoint3d) == sizeof(AcGePoint3d));
|
||
assert(sizeof(ads_matrix) == sizeof(AcGeMatrix3d));
|
||
|
||
TCString sAcadVer;
|
||
TGGetVar(_T("ACADVER"), sAcadVer);
|
||
g_nAcadVer = _tstof(sAcadVer);
|
||
|
||
//提醒tch_kernal导出
|
||
{
|
||
TImageDrawDC dc;
|
||
TImageDrawDCEx dc1;
|
||
TDbWall wall;
|
||
BOOL a = g_bAxisWall;
|
||
TEntityBase *pBase = &wall;
|
||
}
|
||
}
|
||
|
||
TDPtrList<TSortWallOnPt>& GetAllSortWalls()
|
||
{
|
||
return TSearchSpaceFromWall::g_lstAllSortWalls;
|
||
}
|
||
|
||
|
||
AcDbObjectId MakeTBlockInsert(const TCHAR *pszBlock, TADSGePoint3d ptInsert, double sx, double sy, double sz, double rot, int nMask)
|
||
{
|
||
AcDbObjectId idBlock = InitBlock(pszBlock);
|
||
if (!idBlock)
|
||
{
|
||
return idBlock;
|
||
}
|
||
|
||
TDbBlockInsert *pInsert = new TDbBlockInsert;
|
||
pInsert->setBlockTableRecord(idBlock);
|
||
pInsert->setPosition(ptInsert);
|
||
pInsert->setScaleFactors(AcGeScale3d(sx, sy, sz));
|
||
pInsert->setRotation(rot);
|
||
pInsert->SetMaskFlag(nMask);
|
||
|
||
AcDbObjectId idInsert = AddToCurrentSpace(pInsert, Adesk::kTrue);
|
||
if (!idInsert)
|
||
{
|
||
delete pInsert;
|
||
}
|
||
return idInsert;
|
||
}
|
||
|
||
void MdiOpenDwgFile(const TCHAR *pszFile, const TCHAR *pszCmdStr)
|
||
{
|
||
extern TCHAR g_szFileNameToOpen[];
|
||
extern TCHAR g_szInitCmdStr[];
|
||
extern CWnd *g_pContextMenu;
|
||
if (g_pContextMenu)
|
||
{
|
||
_tcscpy(g_szFileNameToOpen, pszFile);
|
||
if (pszCmdStr)
|
||
{
|
||
_tcscpy(g_szInitCmdStr, pszCmdStr);
|
||
}
|
||
else
|
||
{
|
||
g_szInitCmdStr[0] = EOS;
|
||
}
|
||
g_pContextMenu->PostMessage(WM_TCH_OPEN_FILE);
|
||
}
|
||
}
|
||
|
||
void OpenDwgWithCurNls(CString &csFileName)
|
||
{
|
||
TSplitpathOperator parser(csFileName);
|
||
BOOL bDxf = (_tcsicmp(parser.m_sExt, _T(".DXF")) == 0);
|
||
TchExport::ConvertDwgCodePage(csFileName);
|
||
|
||
if (bDxf)
|
||
{
|
||
if (SHads_command(RTSTR, _T(".dxfin"), RTSTR, (const TCHAR *)csFileName, RTNONE) != RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n必须为干净的空图才可以输入DXF文件!");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
MdiOpenDwgFile(csFileName, NULL);
|
||
}
|
||
}
|
||
|
||
int GetViewDrawMode()
|
||
{
|
||
if ((CFG_DrawMode & DRAW_2D) && !(CFG_DrawMode & DRAW_3D))
|
||
{
|
||
return DRAW_2D;
|
||
}
|
||
else if ((CFG_DrawMode & DRAW_3D) && !(CFG_DrawMode & DRAW_2D))
|
||
{
|
||
return DRAW_3D;
|
||
}
|
||
else if (CFG_DrawMode & (DRAW_3D | DRAW_2D))
|
||
{
|
||
TADSGePoint3d viewDir;
|
||
TGGetVar(_T("VIEWDIR"), &viewDir);
|
||
viewDir = Ucs2Wcs(viewDir, TRUE);
|
||
if (fabs(viewDir.x) > 1.0E-6 || fabs(viewDir.y) > 1.0E-6)
|
||
{
|
||
return DRAW_3D;
|
||
}
|
||
else
|
||
{
|
||
return DRAW_2D;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 从图块中寻找_HOLE图层上的PLINE
|
||
int GetExistOutlineFromInsert(const TEntitySet &e, TGGePoly2D &polyOutline)
|
||
{
|
||
AcDbObjectId idBlock;
|
||
TEntitySet ent = e;
|
||
int nCode = (ent.Is(_T("ATS_MVINSERT")) ? 1 : 2);
|
||
TCString sBlock;
|
||
ent.GetData(nCode, (TCHAR *)sBlock);
|
||
idBlock = GetBlockIdFromString(sBlock);
|
||
if (!idBlock)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
ads_matrix mat;
|
||
GetInsertMatrix(ent, mat);
|
||
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
||
AcDbBlockTableRecordIterator* pBlockIterator = NULL;
|
||
VERIFY(pBlock->newIterator(pBlockIterator) == Acad::eOk && pBlockIterator);
|
||
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
||
{
|
||
AcDbEntity *pEntity = NULL;
|
||
VERIFY(pBlockIterator->getEntity(pEntity, AcDb::kForRead) == Acad::eOk && pEntity);
|
||
TAcDbObjectPtr obj(pEntity);
|
||
TCHAR *pszLayer = pEntity->layer();
|
||
if (_tcsicmp(pszLayer, LAY_BOUNDARY) != 0)
|
||
{
|
||
delete[] pszLayer;
|
||
continue;
|
||
}
|
||
delete[] pszLayer;
|
||
|
||
TEntitySet ent0;
|
||
acdbGetAdsName(ent0.name, pEntity->objectId());
|
||
obj.Close();
|
||
|
||
if (!(!ent0))
|
||
{
|
||
TGGePoly2D poly(ent0);
|
||
if (!poly)
|
||
{
|
||
;
|
||
}
|
||
else
|
||
{
|
||
polyOutline = poly;
|
||
polyOutline.TransUCS(mat);
|
||
return RTNORM;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
return RTERROR;
|
||
}
|
||
|
||
|
||
|
||
// poly2d--UCS
|
||
int GetClipBoundary1(TGGePoly2D &poly2d)
|
||
{
|
||
TADSGePoint3d ptStart;
|
||
TchGeLib::adsout << _T("\n矩形的第一个角点或 [多边形裁剪(P)/多段线定边界(L)/图块定边界(B)]<退出>:");
|
||
int nCode;
|
||
INITGET_BEG(0, _T("P L B"));
|
||
nCode = ads_getpoint(NULL, _T(""), ptStart);
|
||
INITGET_END();
|
||
if (nCode != RTKWORD && nCode != RTNORM)
|
||
{
|
||
return nCode;
|
||
}
|
||
|
||
TGGiScreenDrawStream dc;
|
||
dc.m_nDrawMode = 1;
|
||
|
||
if (nCode == RTNORM)
|
||
{
|
||
TADSGePoint3d ptOther;
|
||
int nCode = GetCornerPoint(ptStart, _T("\n另一个角点<退出>:"), ptOther);
|
||
if (nCode != RTNORM)
|
||
{
|
||
return nCode;
|
||
}
|
||
TGGeRectAngle rect(ptStart, ptOther);
|
||
rect.AsPoly2D(poly2d);
|
||
dc << poly2d;
|
||
}
|
||
else
|
||
{
|
||
nCode = RTNORM;
|
||
TCString sKey;
|
||
ads_getinput(sKey);
|
||
if (sKey[0] == _T('P'))
|
||
{
|
||
if (ads_getpoint(NULL, _T("\n多边形起点<退出>:"), ptStart) != RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
TADSGePoint3d pt2;
|
||
TDPtrStack<TADSGePoint3d> aStack;
|
||
aStack.Push(new TADSGePoint3d(ptStart));
|
||
while(1)
|
||
{
|
||
TADSGePoint3d &ptFrom = *aStack.Top();
|
||
if (aStack.Length() >= 3)
|
||
{
|
||
TchGeLib::adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
|
||
}
|
||
else
|
||
{
|
||
TchGeLib::adsout << _T("\n下一点或 [回退(U)]<退出>: ");
|
||
}
|
||
int rc;
|
||
INITGET_BEG(0, _T("U"));
|
||
rc = ads_getpoint(ptFrom, _T(""), pt2);
|
||
INITGET_END();
|
||
if (rc == RTCAN)
|
||
{
|
||
aStack.Reset();
|
||
return rc;
|
||
}
|
||
else if (rc == RTKWORD)
|
||
{
|
||
if (*aStack.Top() != ptStart)
|
||
{// Not on first state
|
||
TADSGePoint3d *pPt2 = aStack.Pop();
|
||
TADSGePoint3d *pPt1 = aStack.Top();
|
||
dc.SetColor(-1);
|
||
dc << TGGeLine(*pPt1, *pPt2);
|
||
delete pPt2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (rc == RTNONE)
|
||
{
|
||
if (aStack.Length() < 3)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
else
|
||
{
|
||
pt2 = ptStart;
|
||
}
|
||
}
|
||
TGGeLine ln(*aStack.Top(), pt2);
|
||
if (ln.GetLength()>_DIST_SNAP)
|
||
{
|
||
dc.SetColor(7);
|
||
dc << ln;
|
||
if (!(rc == RTNONE))
|
||
{
|
||
aStack.Push(new TADSGePoint3d(pt2));
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
poly2d.Reset();
|
||
TADSGePoint3d *ptCur = NULL;
|
||
while((ptCur = aStack.Pop()) != NULL)
|
||
{
|
||
poly2d.AppendNode(*ptCur);
|
||
delete ptCur;
|
||
}
|
||
}
|
||
else if (sKey[0] == _T('L'))
|
||
{
|
||
TEntitySet entFront;
|
||
if (SelectEntity(_T("\n请选择封闭的多段线作为裁减边界<退出>: "), entFront, TRBList(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL)) != RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
poly2d = TGGePoly2D(entFront);
|
||
poly2d.TransUCS(TGroups(0), TGroups(1));
|
||
dc << poly2d;
|
||
}
|
||
else if (sKey[0] == _T('B'))
|
||
{
|
||
TEntitySet entFront;
|
||
if (SelectEntity(_T("\n请选择图块作为裁减边界<退出>: "), entFront,
|
||
TRBList(RTDXF0, _T("INSERT,AEC_BLOCK_INSERT,ATS_MVINSERT"), NULL)) != RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
if (GetBoundaryFromInsert2D(entFront, poly2d) != RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n无法搜到图块的边界!");
|
||
{
|
||
return RTERROR;
|
||
}
|
||
}
|
||
poly2d.TransUCS(TGroups(0), TGroups(1));
|
||
dc << poly2d;
|
||
int nAnser = YesNoQuestion(_T("\n系统确定的图块轮廓线是否正确"));
|
||
if (nAnser != Q_YES)
|
||
{
|
||
TchGeLib::adsout << _T("\n请用其他方法确定裁减边界!");
|
||
return RTERROR;
|
||
}
|
||
}
|
||
}
|
||
poly2d.Compress();
|
||
if (!poly2d || poly2d.Length() < 3)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
template <class T>
|
||
void DELETE_ARR_(T *&arr)
|
||
{
|
||
if (arr != NULL)
|
||
{
|
||
delete[] arr;
|
||
arr = NULL;
|
||
}
|
||
}
|
||
|
||
bool getSections(LPCTSTR szPath, std::vector<CString> §ions)
|
||
{
|
||
if (_taccess(szPath, 0x0) != 0x0) return false;
|
||
DWORD dw(0), len(MAX_PATH);
|
||
TCHAR *buf = new TCHAR[len];
|
||
::memset(buf, 0, sizeof(TCHAR) * len);
|
||
dw = ::GetPrivateProfileSectionNames(buf, len, szPath);
|
||
while (dw == len - 2)
|
||
{
|
||
DELETE_ARR_(buf);
|
||
len += MAX_PATH;
|
||
buf = new TCHAR[len];
|
||
::memset(buf, 0, sizeof(TCHAR) * len);
|
||
dw = ::GetPrivateProfileSectionNames(buf, len, szPath);
|
||
}
|
||
TCHAR *psz(buf);
|
||
|
||
while ((len = (DWORD)_tcslen(psz)))
|
||
{
|
||
sections.push_back(psz);
|
||
psz += len + 1;
|
||
}
|
||
DELETE_ARR_(buf);
|
||
return !sections.empty();
|
||
}
|
||
|
||
bool getSectionContent(LPCTSTR szPath, LPCTSTR szSection, std::vector<std::pair<CString, CString>> &mapV)
|
||
{
|
||
if (_taccess(szPath, 0x0) != 0x0) return false;
|
||
|
||
DWORD dw(0), len(MAX_PATH);
|
||
TCHAR *buf = new TCHAR[len];
|
||
::memset(buf, 0, sizeof(TCHAR) * len);
|
||
dw = ::GetPrivateProfileSection(szSection, buf, len, szPath);
|
||
while (dw == len - 2)
|
||
{
|
||
DELETE_ARR_(buf);
|
||
len += MAX_PATH;
|
||
buf = new TCHAR[len];
|
||
::memset(buf, 0, sizeof(TCHAR) * len);
|
||
dw = ::GetPrivateProfileSection(szSection, buf, len, szPath);
|
||
}
|
||
|
||
TCHAR *psz(buf);
|
||
|
||
mapV.clear();
|
||
|
||
std::map<CString, CString>::const_iterator it;
|
||
int idx(-1);
|
||
CString str(_T("")), pre(_T("")), back(_T(""));
|
||
while ((len = (DWORD)_tcslen(psz)))
|
||
{
|
||
str = psz;
|
||
idx = str.Find(_T('='));
|
||
if (idx != -1)
|
||
{
|
||
pre = str.Left(idx);
|
||
back = str.Right(str.GetLength() - idx - 1);
|
||
mapV.push_back(std::make_pair(pre, back));
|
||
}
|
||
psz += len + 1;
|
||
}
|
||
DELETE_ARR_(buf);
|
||
|
||
return !mapV.empty();
|
||
}
|
||
|
||
bool getSectionContent(LPCTSTR szPath, LPCTSTR szSection, std::map<CString, CString> &mapV)
|
||
{
|
||
std::vector<std::pair<CString, CString>> bims;
|
||
getSectionContent(szPath, szSection, bims);
|
||
for (size_t i = 0; i < bims.size(); ++i)
|
||
{
|
||
mapV.insert(bims[i]);
|
||
}
|
||
return !mapV.empty();
|
||
}
|
||
|
||
|
||
bool setSectionContent(LPCTSTR szPath, LPCTSTR szSection, const std::map<CString, CString> &mapV)
|
||
{
|
||
if (!szSection) return false;
|
||
//if (_taccess(szPath, 0x0) != 0x0) return false;
|
||
|
||
// 拼字符串
|
||
std::map<CString, CString>::const_iterator it = mapV.begin();
|
||
std::wstring ss;
|
||
for (; it != mapV.end(); ++it)
|
||
{
|
||
ss += it->first;
|
||
ss += _T("=");
|
||
ss += it->second;
|
||
ss.push_back(_T('\0'));
|
||
}
|
||
ss.push_back(_T('\0'));
|
||
|
||
return ::WritePrivateProfileSection(szSection, ss.c_str(), szPath) == FALSE ? false : true;
|
||
}
|
||
|
||
namespace
|
||
{
|
||
CString GetArxDir()
|
||
{
|
||
TCHAR szPath[MAX_PATH];
|
||
::GetModuleFileName(_hdllInstance, szPath, MAX_PATH);
|
||
CString sPath(szPath);
|
||
sPath = sPath.Left(sPath.ReverseFind(_T('\\')));
|
||
return sPath;
|
||
}
|
||
|
||
bool getMeterUnitDraw()
|
||
{
|
||
#ifndef ZWCAD
|
||
CString dllPath(GetArxDir() + _T("\\Dimension.arx"));
|
||
#else
|
||
CString dllPath(GetArxDir() + _T("\\Dimension.zrx"));
|
||
#endif
|
||
typedef int(_cdecl *getUnitOfDraw)();
|
||
|
||
HMODULE hmod = ::LoadLibrary(dllPath);
|
||
if (!hmod) return false;
|
||
|
||
getUnitOfDraw func_getUnitOfDraw = (getUnitOfDraw)::GetProcAddress(hmod, "getUnitOfDraw");
|
||
|
||
if (!func_getUnitOfDraw)
|
||
{
|
||
::FreeLibrary(hmod);
|
||
return false;
|
||
}
|
||
|
||
int nRet = func_getUnitOfDraw();
|
||
return nRet == 1 ? true : false;
|
||
}
|
||
|
||
bool setMeterUnitDraw(const BOOL &bMeter)
|
||
{
|
||
#ifndef ZWCAD
|
||
CString dllPath(GetArxDir() + _T("\\Dimension.arx"));
|
||
#else
|
||
CString dllPath(GetArxDir() + _T("\\Dimension.zrx"));
|
||
#endif
|
||
typedef void(_cdecl *setUnitOfDraw)(const bool &);
|
||
|
||
HMODULE hmod = ::LoadLibrary(dllPath);
|
||
if (!hmod) return false;
|
||
|
||
setUnitOfDraw func_setUnitOfDraw = (setUnitOfDraw)::GetProcAddress(hmod, "setUnitOfDraw");
|
||
|
||
if (!func_setUnitOfDraw)
|
||
{
|
||
::FreeLibrary(hmod);
|
||
return false;
|
||
}
|
||
|
||
func_setUnitOfDraw(bMeter);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
bool _docGetPScale(double &dRet)
|
||
{
|
||
dRet = (g_nDefaultScale*_UNIT_SCALE);
|
||
int nTileMode = 0, cvport = 0;
|
||
if (TGGetVar(_T("TILEMODE"), &nTileMode) == RTNORM && nTileMode == 0
|
||
&& TGGetVar(_T("CVPORT"), &cvport) == RTNORM && cvport == 1)
|
||
{
|
||
dRet = 1.;
|
||
return true; //PAPERSPACE
|
||
}
|
||
|
||
XString sIni;
|
||
if (FindFile(_T("ZT_config.ini"), sIni))
|
||
{
|
||
std::map<CString, CString> data;
|
||
getSectionContent(sIni, _T("zt_setting"), data);
|
||
std::map<CString, CString>::const_iterator it(data.find(_T("PScale")));
|
||
if (it != data.end())
|
||
{
|
||
dRet = _ttof(it->second);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool _docSetPScale(const double &d)
|
||
{
|
||
XString sIni;
|
||
double dRet(g_nDefaultScale*_UNIT_SCALE);
|
||
if (FindFile(_T("ZT_config.ini"), sIni))
|
||
{
|
||
std::map<CString, CString> data;
|
||
getSectionContent(sIni, _T("zt_setting"), data);
|
||
std::map<CString, CString>::iterator it(data.find(_T("PScale")));
|
||
if (it != data.end())
|
||
{
|
||
it->second.Format(_T("%g"), d);
|
||
setSectionContent(sIni, _T("zt_setting"), data);
|
||
g_nDefaultScale = d;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool _docGetMeterUnitDraw(BOOL &bMeter)
|
||
{
|
||
bMeter = getMeterUnitDraw();
|
||
return true;
|
||
|
||
XString sIni;
|
||
if (FindFile(_T("ZT_config.ini"), sIni))
|
||
{
|
||
std::map<CString, CString> data;
|
||
getSectionContent(sIni, _T("zt_setting"), data);
|
||
std::map<CString, CString>::const_iterator it(data.find(_T("MeterUnitDraw")));
|
||
if (it != data.end())
|
||
{
|
||
bMeter = _ttoi(it->second) == 0 ? FALSE : TRUE;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool _docSetMeterUnitDraw(const BOOL &bMeter)
|
||
{
|
||
return setMeterUnitDraw(bMeter);
|
||
|
||
XString sIni;
|
||
if (FindFile(_T("ZT_config.ini"), sIni))
|
||
{
|
||
std::map<CString, CString> data;
|
||
getSectionContent(sIni, _T("zt_setting"), data);
|
||
std::map<CString, CString>::iterator it(data.find(_T("MeterUnitDraw")));
|
||
if (it != data.end())
|
||
{
|
||
it->second.Format(_T("%d"), bMeter == FALSE ? 0 : 1);
|
||
setSectionContent(sIni, _T("zt_setting"), data);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
double DocGetPScale()
|
||
{
|
||
|
||
double dRet(g_nDefaultScale*_UNIT_SCALE);
|
||
if (_docGetPScale(dRet))
|
||
{
|
||
return dRet;
|
||
}
|
||
|
||
int nTileMode = 0, cvport = 0;
|
||
if (TGGetVar(_T("TILEMODE"), &nTileMode) == RTNORM && nTileMode == 0
|
||
&& TGGetVar(_T("CVPORT"), &cvport) == RTNORM && cvport == 1)
|
||
{
|
||
return 1.0; //PAPERSPACE
|
||
}
|
||
|
||
TDbConfig *p = GetDwgGlobal(AcDb::kForRead, g_pCurrentDb);
|
||
|
||
dRet = (p ? p->GetPScale() : g_nDefaultScale*_UNIT_SCALE);
|
||
|
||
if (p)
|
||
{
|
||
p->close();
|
||
}
|
||
}
|
||
|
||
TPickEntSet & DocGetPickFirst()
|
||
{
|
||
TArchPerDocData *p = GetCurDocData();
|
||
ASSERT(p);
|
||
if (p != NULL)
|
||
{
|
||
return p->m_ssPickFirst;
|
||
}
|
||
else
|
||
{
|
||
static TPickEntSet ssInvalid;
|
||
return ssInvalid;
|
||
}
|
||
}
|
||
|
||
TEntitySet& DocGetEntMouseOn()
|
||
{
|
||
TArchPerDocData *p = GetCurDocData();
|
||
ASSERT(p);
|
||
if (p != NULL)
|
||
{
|
||
return p->m_entMouseOn;
|
||
}
|
||
else
|
||
{
|
||
static TEntitySet entInvalid;
|
||
return entInvalid;
|
||
}
|
||
}
|
||
|
||
TPickEntSet & DocGetPickGrip()
|
||
{
|
||
TArchPerDocData *p = GetCurDocData();
|
||
ASSERT(p);
|
||
if (p != NULL)
|
||
{
|
||
return p->m_ssPickGrip;
|
||
}
|
||
else
|
||
{
|
||
static TPickEntSet ssInvalid;
|
||
return ssInvalid;
|
||
}
|
||
}
|
||
|
||
void ClearKeyboardBuffer()
|
||
{
|
||
TArchPerDocData * pDocDat = GetCurDocData();
|
||
if (pDocDat != NULL)
|
||
{
|
||
pDocDat->m_szCommandStr[0] = EOS;
|
||
pDocDat->m_nPos = 0;
|
||
}
|
||
}
|
||
|
||
bool IsLispExpress()
|
||
{
|
||
TArchPerDocData * pDocDat = GetCurDocData();
|
||
if (pDocDat != NULL)
|
||
{
|
||
return pDocDat->m_szCommandStr[0] == _T('(');
|
||
}
|
||
return false;
|
||
}
|
||
|
||
TArchPerDocData * GetCurDocData()
|
||
{
|
||
if (!TArchDocReactor::g_pTArchAppDocGlobals)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
TArchPerDocData *pData = TArchDocReactor::g_pTArchAppDocGlobals->FindNode(curDoc(), TArchPerDocData::CompareForFind);
|
||
return pData;
|
||
}
|
||
|
||
|
||
int SelectUpFace(AcGePlane &plane)
|
||
{
|
||
TEntitySet ent;
|
||
TADSGePoint3d pt;
|
||
if (ent.FilterSelect1(GetApertureWcs(), _T("\n请选择三维坡屋顶坡面<退出>:"), TRBList(), pt) != RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
BOOL bUp = TRUE;
|
||
if (ent.Is(_T("3DFACE")) || ent.Is(_T("POLYLINE")))
|
||
{
|
||
bUp = FALSE;
|
||
}
|
||
pt = Ucs2Wcs(pt);
|
||
AcDbVoidPtrArray entSet;
|
||
int nDrawMode = DocGetDrawMode();
|
||
DocSetDrawMode(DRAW_3D);
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
||
InitModel(TMasterProperties(), pEnt, NULL, entSet);
|
||
OPENOBJ_END();
|
||
DocSetDrawMode(nDrawMode);
|
||
|
||
int num = entSet.length();
|
||
for (int i = 0; i<num; i++)
|
||
{
|
||
AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
|
||
ASSERT(pEnt);
|
||
if (pEnt->isA() == AcDbFace::desc())
|
||
{
|
||
AcDbFace *pFace = AcDbFace::cast(pEnt);
|
||
int nHitFlag = HitTestOnEdge(pFace, pt, TRUE);
|
||
if (nHitFlag >= 0)
|
||
{
|
||
TGGe3DFace faceUcs, faceWcs;
|
||
for (int n = 0; n<4; n++)
|
||
{
|
||
pFace->getVertexAt(n, faceWcs.GetVertex(n));
|
||
}
|
||
TVector3D vtNorm = faceWcs.GetNormal();
|
||
if (vtNorm.z < 1.0E-9 && bUp)
|
||
{
|
||
continue; //法向不正确
|
||
}
|
||
for (n = 0; n<4; n++)
|
||
{
|
||
faceUcs.SetVertex(n, Wcs2Ucs(faceWcs.GetVertex(n)));
|
||
}
|
||
|
||
if (faceUcs.IsLinear() || faceUcs.IsPoint())
|
||
{
|
||
continue;
|
||
}
|
||
TGGiScreenDrawStream dc(7, 1);
|
||
dc << faceUcs;
|
||
int nCode = YesNoQuestion(_T("\n是否为加亮的坡面"));
|
||
ads_redraw(NULL,0);
|
||
if (nCode == RTCAN)
|
||
{
|
||
return nCode;
|
||
}
|
||
else if (nCode == Q_YES)
|
||
{
|
||
if (vtNorm.z<1.0E-9)
|
||
{
|
||
plane.set((AcGePoint3d &)faceWcs.GetVertex(2),
|
||
(AcGePoint3d &)faceWcs.GetVertex(1),
|
||
(AcGePoint3d &)faceWcs.GetVertex(0));
|
||
}
|
||
else
|
||
{
|
||
plane.set((AcGePoint3d &)faceWcs.GetVertex(0),
|
||
(AcGePoint3d &)faceWcs.GetVertex(1),
|
||
(AcGePoint3d &)faceWcs.GetVertex(2));
|
||
}
|
||
return RTNORM;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ReleaseEntSet(entSet);
|
||
ads_retnil();
|
||
return RTNONE;
|
||
}
|
||
|
||
void InitDLRegistry(HMODULE modHandle, const TCHAR *szAppName0) //应用程序名(可为任意字符))
|
||
{
|
||
// 检查HKEY_LOCAL_MACHINE是否有写操作权限
|
||
HKEY hKey = NULL;
|
||
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
|
||
{
|
||
return;
|
||
}
|
||
RegCloseKey(hKey);
|
||
|
||
if (g_nProductId == kTSUN)
|
||
{
|
||
return;
|
||
}
|
||
TCString sAppName;
|
||
sAppName << _T("T8") << g_nProductId << szAppName0;
|
||
TCHAR szAppName[256] = _T("");
|
||
_tcscpy(szAppName, sAppName);
|
||
#if (ADS<16)
|
||
CString strAppInfoLoc,strAppLoc;
|
||
strAppInfoLoc = GetRegLocation();
|
||
strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");
|
||
|
||
acrxRegisterApp((AcadApp::LoadReasons)(AcadApp::kOnCommandInvocation| AcadApp::kOnLoadRequest), szAppName, strAppInfoLoc, 2);
|
||
CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
|
||
//Name...................................................
|
||
{
|
||
TRegProperty regProp(strThisAppInfoLoc,_T("Name"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
regProp.SetValue(szAppName,szAppName);
|
||
}
|
||
//Loader.................................................
|
||
{
|
||
TCHAR modulePath[512];
|
||
DWORD pathLength = GetModuleFileName(modHandle, modulePath, 512);
|
||
if (pathLength == 0)
|
||
{
|
||
assert(FALSE);
|
||
return ;
|
||
}
|
||
TRegProperty regProp(strThisAppInfoLoc, _T("Loader"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
regProp.SetValue(_T("MODULE"),modulePath);
|
||
}
|
||
#else
|
||
// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
|
||
//const TCHAR *pszRegAcad=acrxProductKey();
|
||
const TCHAR *pszRegAcad=NULL;
|
||
#if (ADS > 18)
|
||
pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
|
||
#else
|
||
pszRegAcad = acrxProductKey();
|
||
#endif
|
||
|
||
acrxRegisterApp((AcadApp::LoadReasons)(AcadApp::kOnCommandInvocation| AcadApp::kOnLoadRequest), szAppName);
|
||
TCString strThisAppInfoLoc;
|
||
strThisAppInfoLoc << pszRegAcad << _T("\\Applications");
|
||
//Loader.................................................
|
||
{
|
||
TCHAR modulePath[512];
|
||
DWORD pathLength = GetModuleFileName(modHandle, modulePath, 512);
|
||
if (pathLength == 0)
|
||
{
|
||
assert(FALSE);
|
||
return ;
|
||
}
|
||
TRegProperty regProp(strThisAppInfoLoc, szAppName);
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
regProp.SetValue(_T("Description"), szAppName0);
|
||
regProp.SetValue(_T("Loader"), modulePath);
|
||
}
|
||
|
||
#endif
|
||
{ // Commands
|
||
HKEY hKey;
|
||
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, strThisAppInfoLoc, 0L,KEY_ALL_ACCESS,&hKey) == ERROR_SUCCESS)
|
||
{
|
||
if (RegDeleteKey(hKey, _T("Commands")) != ERROR_SUCCESS)
|
||
{
|
||
;
|
||
}
|
||
|
||
#if (ADS>15)
|
||
if (RegDeleteKey(hKey, _T("TGroups")) != ERROR_SUCCESS)
|
||
{
|
||
;
|
||
}
|
||
#endif
|
||
RegCloseKey(hKey);
|
||
}
|
||
}
|
||
}
|
||
|
||
//const TCHAR *pszCustObjInfo) //自定义实体的应用程序名列表(如果不需要监测到自定义实体时加载,可为NULL)
|
||
void UpdateDLRegistry(const TCHAR *szAppName0, const STArxCommandTable cmdTable[], const UINT eleNum)
|
||
{
|
||
// 检查HKEY_LOCAL_MACHINE是否有写操作权限
|
||
HKEY hKey = NULL;
|
||
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
|
||
{
|
||
return;
|
||
}
|
||
RegCloseKey(hKey);
|
||
|
||
if (g_nProductId == kTSUN)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TCString sAppName;
|
||
sAppName << _T("T8") << g_nProductId << szAppName0;
|
||
TCHAR szAppName[256] = _T("");
|
||
_tcscpy(szAppName, sAppName);
|
||
|
||
CString strAppInfoLoc;
|
||
#if (ADS>15)
|
||
// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
|
||
//const TCHAR *pszRegAcad=acrxProductKey();
|
||
const TCHAR *pszRegAcad=NULL;
|
||
#if (ADS > 18)
|
||
pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
|
||
#else
|
||
pszRegAcad = acrxProductKey();
|
||
#endif
|
||
strAppInfoLoc += pszRegAcad;
|
||
strAppInfoLoc += _T("\\Applications\\");
|
||
strAppInfoLoc += szAppName;
|
||
CString strThisAppInfoLoc = strAppInfoLoc;
|
||
#else
|
||
strAppInfoLoc = GetRegLocation();
|
||
strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");
|
||
CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
|
||
#endif
|
||
|
||
//Command................................................
|
||
{
|
||
TRegProperty regProp(strThisAppInfoLoc, _T("Commands"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
for (UINT i = 0; i<eleNum; i++)
|
||
{
|
||
TCString sCmd = GetFullCmdName(cmdTable[i].szCmdGlobal);
|
||
regProp.SetValue((const TCHAR *)sCmd,(const TCHAR *)sCmd);
|
||
}
|
||
}
|
||
|
||
#if (ADS>15)
|
||
// Group
|
||
{
|
||
TRegProperty regProp(strThisAppInfoLoc, _T("TGroups"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
regProp.SetValue(szAppName0, szAppName0);
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
void UpdateDLRegistry(const TCHAR *szAppName0, const STExtern_fun cmdTable[], const UINT eleNum)
|
||
{
|
||
// 检查HKEY_LOCAL_MACHINE是否有写操作权限
|
||
HKEY hKey = NULL;
|
||
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("Software\\Autodesk\\AutoCAD"), 0, KEY_WRITE, &hKey))
|
||
{
|
||
return;
|
||
}
|
||
RegCloseKey(hKey);
|
||
|
||
if (g_nProductId == kTSUN)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TCString sAppName;
|
||
sAppName << _T("T8") << g_nProductId << szAppName0;
|
||
TCHAR szAppName[256] = _T("");
|
||
_tcscpy(szAppName, sAppName);
|
||
|
||
CString strAppInfoLoc;
|
||
#if (ADS>15)
|
||
// sg modify 120228，自R19平台起，API进行了调整，下面的函数作废了
|
||
//const TCHAR *pszRegAcad=acrxProductKey();
|
||
const TCHAR *pszRegAcad=NULL;
|
||
#if (ADS > 18)
|
||
pszRegAcad = acdbHostApplicationServices()->getMachineRegistryProductRootKey();
|
||
#else
|
||
pszRegAcad = acrxProductKey();
|
||
#endif
|
||
strAppInfoLoc += pszRegAcad;
|
||
strAppInfoLoc += _T("\\Applications\\");
|
||
strAppInfoLoc += szAppName;
|
||
CString strThisAppInfoLoc = strAppInfoLoc;
|
||
#else
|
||
strAppInfoLoc = GetRegLocation();
|
||
strAppInfoLoc = strAppInfoLoc+_T("\\TchApps");
|
||
CString strThisAppInfoLoc = strAppInfoLoc+_T("\\")+szAppName;
|
||
#endif
|
||
//Command................................................
|
||
{
|
||
TRegProperty regProp(strThisAppInfoLoc, _T("Commands"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
for (UINT i = 0; i<eleNum; i++)
|
||
{
|
||
TCString sCommand;
|
||
sCommand = cmdTable[i].cmdname;
|
||
if (sCommand[1] == _T(':'))
|
||
{
|
||
TCString sCmd = GetFullCmdName(&sCommand[2]);
|
||
regProp.SetValue(sCmd, (const TCHAR *)sCmd);
|
||
}
|
||
}
|
||
}
|
||
#if (ADS>15)
|
||
// Group
|
||
{
|
||
TRegProperty regProp(strThisAppInfoLoc, _T("TGroups"));
|
||
regProp.SetTopRootKey(HKEY_LOCAL_MACHINE);
|
||
regProp.SetValue(szAppName0, szAppName0);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void DocStatus()
|
||
{
|
||
Refresh_DIST_SNAP();
|
||
|
||
int nFlag = GetCustomFlag();
|
||
if (!(nFlag&CUSTOM_NO_STATUS))
|
||
{
|
||
if (!g_nRunMode)
|
||
{
|
||
TCString sStatus;
|
||
sStatus << _T("比例 1:") << DocGetPScale();
|
||
|
||
TPickEntSet ss(SS_FREE); //本次加亮的全部对象
|
||
if (ss.Get(_T("I"),NULL,NULL,TRBList(RTDXF0,_T("TCH_*"),NULL)) == RTNORM)
|
||
{
|
||
double nScale = -1;
|
||
long len = ss.Length();
|
||
for (long i = 0;i<len;i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
OPENOBJ_BEGIN(ent,AcDb::kForRead,AcDbEntity,pEnt)
|
||
if (pEnt != NULL)
|
||
{
|
||
TEntityBase *pEntBase = TEntityBase::Cast(pEnt);
|
||
if (pEntBase != NULL)
|
||
{
|
||
double nScale1 = pEntBase->GetPScale();
|
||
if (nScale<0)
|
||
{
|
||
nScale = nScale1;
|
||
}
|
||
else if (fabs(nScale-nScale1)>0.001)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END()
|
||
}
|
||
TCString sTemp;
|
||
if (i == len&&nScale>0)
|
||
{
|
||
sTemp << _T("比例 1:") << nScale;
|
||
sStatus = sTemp;
|
||
}
|
||
else if (i<len)
|
||
{
|
||
sTemp << _T("比例 1:***");
|
||
sStatus = sTemp;
|
||
}
|
||
}
|
||
|
||
#if ADS<16
|
||
TGSetVar(_T("MODEMACRO"), sStatus);
|
||
#else
|
||
AcApStatusBar *pBar = acedGetApplicationStatusBar();
|
||
if (pBar)
|
||
{
|
||
AcPane *pPane = pBar->GetPane(0);
|
||
if (pPane != NULL)
|
||
{
|
||
pPane->SetVisible(TRUE);
|
||
pPane->SetText((const TCHAR*)sStatus);
|
||
pBar->Update();
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
#if ADS<16
|
||
TGSetVar(_T("MODEMACRO"), _T(""));
|
||
#else
|
||
AcApStatusBar *pBar = acedGetApplicationStatusBar();
|
||
if (pBar)
|
||
{
|
||
AcPane *pPane = pBar->GetPane(0);
|
||
if (pPane != NULL)
|
||
{
|
||
pPane->SetVisible(FALSE);
|
||
pPane->SetText(_T(""));
|
||
pBar->Update();
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
int GetBlockBoundary(AcDbObjectId idBlock, TGGePoly2D &poly, BOOL bAddIfNone)
|
||
{
|
||
int nRet = RTNONE;
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
||
if (!pBlock)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
AcDbBlockTableRecordIterator* pBlockIterator = NULL;
|
||
Acad::ErrorStatus es = pBlock->newIterator(pBlockIterator);
|
||
ASSERT(es == Acad::eOk && !!pBlockIterator);
|
||
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
||
{
|
||
AcDbEntity *pEntity;
|
||
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
|
||
ASSERT(es == Acad::eOk);
|
||
TAcDbObjectPtr obj(pEntity);
|
||
|
||
if (!pEntity->isKindOf(AcDbPolyline::desc()))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
AcDbPolyline *pline = AcDbPolyline::cast(pEntity);
|
||
ASSERT(pline);
|
||
TCHAR *pszLayer = pEntity->layer();
|
||
ASSERT(pszLayer);
|
||
TCString szPattern(256);
|
||
szPattern << LAY_BOUNDARY << _T(",*|") << LAY_BOUNDARY;
|
||
if (pline->isClosed() && ads_wcmatch(pszLayer, szPattern) == RTNORM)
|
||
{
|
||
PolyConvert(*pline, poly);
|
||
delete [] pszLayer;
|
||
delete pBlockIterator;
|
||
return RTNORM;
|
||
}
|
||
delete [] pszLayer;
|
||
}
|
||
delete pBlockIterator;
|
||
|
||
if (bAddIfNone)
|
||
{
|
||
TDPtrList<TGGeCurveSegment> lstSegs;
|
||
ads_matrix matIdent;
|
||
TGGePoly2D polyOutline(1);
|
||
AsAdsMatrix(AcGeMatrix3d::kIdentity, matIdent);
|
||
Get2DCurveFromBlock(*pBlock, matIdent, lstSegs);
|
||
if (GetExternalBoundaryFromCurves(lstSegs, polyOutline) == RTNORM)
|
||
{
|
||
if (pBlock->upgradeOpen() == Acad::eOk)
|
||
{
|
||
AcDbPolyline *pBound = new AcDbPolyline;
|
||
PolyConvert(polyOutline, *pBound);
|
||
AcDbObjectId idLay = InitLayer(LAY_BOUNDARY, FALSE);
|
||
arxAssureLayer(LAY_BOUNDARY, LAYSTAT_FREEZE);
|
||
pBound->setLayer(idLay);
|
||
VERIFY(pBlock->appendAcDbEntity(pBound) == Acad::eOk);
|
||
pBound->close();
|
||
pBlock->downgradeOpen();
|
||
poly = polyOutline;
|
||
nRet = RTNORM;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return nRet;
|
||
}
|
||
|
||
// 取得点ptCen附近并在ptLow,ptUp内部的轴线交点
|
||
BOOL GetAxisInter(const TADSGePoint3d& ptLow, const TADSGePoint3d& ptUp, TADSGePointDir2d& ptRes)
|
||
{
|
||
TADSGePoint3d ptCen;
|
||
Midpoint(ptLow, ptUp, ptCen);
|
||
TPickEntSet ssAxis(SS_FREE), ss1(SS_FREE), ss2(SS_FREE);
|
||
BOOL bNearAxis1 = (GetSafeSelection(ss1, FALSE, ptLow, ptUp, AcDbLine::desc()) == Acad::eOk);
|
||
BOOL bNearAxis2 = (GetSafeSelection(ss2, FALSE, ptLow, ptUp, AcDbArc::desc()) == Acad::eOk);
|
||
BOOL bNearAxis = (bNearAxis1 || bNearAxis2);
|
||
ssAxis += ss1;
|
||
ssAxis += ss2;
|
||
if (bNearAxis)
|
||
{
|
||
ssAxis.BaseFilter(TRBList(8, LAY_AXIS, NULL));
|
||
bNearAxis = (ssAxis.Length() == 2);
|
||
}
|
||
if (!bNearAxis)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL bRes = FALSE;
|
||
TEntitySet eAxis1 = ssAxis[0L];
|
||
TEntitySet eAxis2 = ssAxis[1L];
|
||
TGGeCurveSegment cv1(eAxis1, LS_FINITE), cv2(eAxis2, LS_FINITE);
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = cv1.Intersection(cv2, ptInt[0], ptInt[1]);
|
||
if (!nIntNum)
|
||
{
|
||
return FALSE;
|
||
}
|
||
if (nIntNum == 1)
|
||
{
|
||
(TADSGePoint3d &)ptRes = ptInt[0];
|
||
}
|
||
else
|
||
{
|
||
(TADSGePoint3d &)ptRes = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ptCen);
|
||
}
|
||
|
||
ptRes.nDirection = GetXDirection(cv1, cv2,ptRes);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
// 选择墙的一侧
|
||
// loc(OUT) -- 墙面上的位置
|
||
// drt(OUT) -- 墙面的切向(法向+PI/2.0)
|
||
int SelectWallSide(TEntitySet &entWall, TADSGePoint3d & loc, double *drt)
|
||
{
|
||
int nOldOsnap = g_nOsnapType;
|
||
DocSetWallOsnapType(1);
|
||
TEntitySet ent;
|
||
TRBList mask(RTDXF0, _T("ATS_WALL,ATS_CURTAIN_WALL"), NULL);
|
||
TADSGePoint3d ptPick;
|
||
int nRetCode = RTNORM;
|
||
if ((nRetCode = SelectEntity1(_T("\n请点取墙体一侧<退出>: "), ent, ptPick, mask)) != RTNORM)
|
||
{
|
||
DocSetWallOsnapType(nOldOsnap);
|
||
return nRetCode;
|
||
}
|
||
DocSetWallOsnapType(nOldOsnap);
|
||
ptPick = Ucs2Wcs(ptPick);
|
||
|
||
TAcDbObjectPtr obj(ent, AcDb::kForWrite);
|
||
if (!obj)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
||
if (!pWall)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
TDbWall &wall = *pWall;
|
||
|
||
TGGeCurveSegment lCurve, rCurve, selCurve;
|
||
wall.GetSideCurve(lCurve, rCurve);
|
||
TADSGePoint3d ptLeft, ptRight; //在左右两侧的投影
|
||
if (lCurve.ProjectToMe(ptPick, ptLeft) != RTNORM ||
|
||
rCurve.ProjectToMe(ptPick, ptRight) != RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
if (ptPick.Distance(ptLeft) < ptPick.Distance(ptRight))
|
||
|
||
{
|
||
selCurve = lCurve;
|
||
}
|
||
else
|
||
{
|
||
selCurve = rCurve;
|
||
}
|
||
|
||
TGGeCurveSegment segCen = wall.OffsetGeomCenter();
|
||
TADSGePoint3d ptOnCen, ptOnSide;
|
||
if (segCen.ProjectToMe(ptPick, ptOnCen) != RTNORM ||
|
||
selCurve.ProjectToMe(ptPick, ptOnSide) != RTNORM)
|
||
{
|
||
TchGeLib::adsout << _T("\n请正确点取!");
|
||
return RTERROR;
|
||
}
|
||
double nOrthDrt = ads_angle(ptOnCen, ptOnSide);
|
||
*drt = AngleRangeTo2PI(nOrthDrt+PI/2.0);
|
||
loc = ptOnSide;
|
||
entWall = ent;
|
||
return RTNORM;
|
||
}
|
||
|
||
int EditWallPathc0(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbWallPatch, pPatch);
|
||
if (!pPatch)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
double nElev = pPatch->GetElevation();
|
||
double nHeight = pPatch->GetHeight();
|
||
TchGeLib::adsout << _T("\n请输入墙体造型的高度或 [底标高(E)]<") << Dist2Str(nHeight) << _T(">:");
|
||
int nRet;
|
||
INITGET_BEG(RSG_NONEG, _T("E"));
|
||
nRet = ads_getreal(_T(""), &nHeight);
|
||
INITGET_END();
|
||
if (nRet == RTNORM)
|
||
{
|
||
if (pPatch->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pPatch->SetHeight(nHeight);
|
||
pPatch->downgradeOpen();
|
||
}
|
||
}
|
||
else if (nRet == RTKWORD)
|
||
{
|
||
if (GetReal(_T("\n墙体造型底标高"), nElev) == RTNORM)
|
||
{
|
||
if (pPatch->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pPatch->SetElevation(nElev);
|
||
pPatch->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
return RTNORM;
|
||
}
|
||
|
||
// 产生内轮廓线
|
||
int GenSpacePoly(const TADSGePoint3d &ptPick, TGGePoly2D &poly)
|
||
{
|
||
return GenSpaceOutline(ptPick, poly, 0);
|
||
}
|
||
|
||
|
||
//选单个实体,优先从全局选择集中筛选
|
||
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, const TRBList &rbBaseMask)
|
||
{
|
||
if (!g_ssPickFirst || g_ssPickFirst.Length() != 1L)
|
||
{
|
||
TEntitySet ent;
|
||
int nRet = RTERROR;
|
||
nRet = ent.FilterSelect(szPrompt, rbBaseMask);
|
||
if (nRet == RTNORM)
|
||
{
|
||
entResult = ent;
|
||
}
|
||
return nRet;
|
||
}
|
||
else
|
||
{
|
||
ads_sssetfirst(NULL, NULL);
|
||
|
||
TEntitySet ent = g_ssPickFirst[0L];
|
||
ent.GetGroups(0);
|
||
if (ent.MatchBase(rbBaseMask))
|
||
{
|
||
entResult = ent;
|
||
g_ssPickFirst.Free();
|
||
return RTNORM;
|
||
}
|
||
else
|
||
{
|
||
int nRet = ent.FilterSelect(szPrompt, rbBaseMask);
|
||
if (nRet == RTNORM)
|
||
{
|
||
entResult = ent;
|
||
}
|
||
return nRet;
|
||
}
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
// 选单个实体,优先从全局选择集中筛选, ptPick--UCS
|
||
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
|
||
{
|
||
g_ssPickFirst.Free();
|
||
TEntitySet ent;
|
||
int nRet = RTERROR;
|
||
nRet = ent.FilterSelect(szPrompt, rbBaseMask, ptPick);
|
||
if (nRet == RTNORM)
|
||
{
|
||
entResult = ent;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
// 选单个实体,优先从全局选择集中筛选
|
||
int SelectEntity1(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
|
||
{
|
||
g_ssPickFirst.Free();
|
||
TEntitySet ent;
|
||
int nRet = RTERROR;
|
||
nRet = ent.FilterSelect1(GetPickBoxWcs()/2, szPrompt, rbBaseMask, ptPick);
|
||
if (nRet == RTNORM)
|
||
{
|
||
entResult = ent;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
// 选单个实体,优先从全局选择集中筛选
|
||
int SelectEntity1(double nPrec, const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask)
|
||
{
|
||
g_ssPickFirst.Free();
|
||
TEntitySet ent;
|
||
int nRet = RTERROR;
|
||
nRet = ent.FilterSelect1(nPrec, szPrompt, rbBaseMask, ptPick);
|
||
if (nRet == RTNORM)
|
||
{
|
||
entResult = ent;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
//选多个实体，优先从全局选择集中筛选
|
||
int SelectEntities(const TCHAR *szPrompt, TPickEntSet &ssResult, const TRBList &rbBaseMask)
|
||
{
|
||
TPickEntSet ssPickFirst(SS_FREE|SS_CREATE);
|
||
if (!!g_ssPickFirst)
|
||
{
|
||
ssPickFirst += g_ssPickFirst;
|
||
}
|
||
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);
|
||
g_ssPickFirst.Free();
|
||
ssResult += ssPickFirst;
|
||
}
|
||
return nRetCode;
|
||
}
|
||
|
||
|
||
int SelectEntities(const TCHAR *szPrompt, TPickEntSet &ssResult, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
|
||
{
|
||
int nRet;
|
||
INITGET_BEG(-2,szKeyword)
|
||
nRet = SelectEntities(szPrompt, ssResult, rbBaseMask);
|
||
INITGET_END();
|
||
if (g_cKeyword != 0)
|
||
{
|
||
cRet = g_cKeyword;
|
||
ssResult.Free();
|
||
return RTKWORD;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, TADSGePoint3d &ptPick, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
|
||
{
|
||
int nRet;
|
||
INITGET_BEG(-2,szKeyword)
|
||
nRet = SelectEntity(szPrompt, entResult,ptPick, rbBaseMask);
|
||
INITGET_END();
|
||
if (g_cKeyword != 0)
|
||
{
|
||
cRet = g_cKeyword;
|
||
return RTKWORD;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
int SelectEntity(const TCHAR *szPrompt, TEntitySet &entResult, const TRBList &rbBaseMask,const TCHAR* szKeyword,TCHAR& cRet)
|
||
{
|
||
int nRet;
|
||
INITGET_BEG(-2,szKeyword)
|
||
nRet = SelectEntity(szPrompt, entResult,rbBaseMask);
|
||
INITGET_END();
|
||
if (g_cKeyword != 0)
|
||
{
|
||
cRet = g_cKeyword;
|
||
return RTKWORD;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
int GetPrepickEntity(TEntitySet &entResult, const TRBList &rbBaseMask)
|
||
{
|
||
if (!!g_ssPickFirst)
|
||
{
|
||
TPickEntSet ss(SS_FREE|SS_CREATE);
|
||
ss += g_ssPickFirst;
|
||
ss.BaseFilter(rbBaseMask);
|
||
if (ss.Length() == 1)
|
||
{
|
||
entResult = g_ssPickFirst[0L];
|
||
return RTNORM;
|
||
}
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
AcDbObjectId GetPrepickEntity(const TRBList &rbBaseMask)
|
||
{
|
||
AcDbObjectId idRet;
|
||
TEntitySet ent;
|
||
if (GetPrepickEntity(ent, rbBaseMask) == RTNORM)
|
||
{
|
||
acdbGetObjectId(idRet, ent);
|
||
}
|
||
return idRet;
|
||
}
|
||
|
||
|
||
TCString GetFullCmdName(const TCHAR *szName)
|
||
{
|
||
TCString szCmd;
|
||
//2012-12-12 LH 根据上华公司沈睿副总经理要求去除上华命令前缀功能 即TXX_Name 去除前缀TXX_
|
||
//if (TRUE)
|
||
if(FALSE)
|
||
{
|
||
szCmd << _T("T9") << g_nProductId << _T("_") << szName;
|
||
}
|
||
else
|
||
{
|
||
szCmd = szName;
|
||
}
|
||
return szCmd;
|
||
}
|
||
|
||
void TchAddCommand(const TCHAR *szAppName0,const STArxCommandTable cmdTable[], const UINT eleNum, BOOL bLispCmd)
|
||
{
|
||
if (TchGeLib::g_nProtectCode == 0)//表面加密：不加载命令
|
||
{
|
||
return;
|
||
}
|
||
int num = (int)eleNum;
|
||
for (int i = 0; i<num; i++)
|
||
{
|
||
TCString szCmd = GetFullCmdName(cmdTable[i].szCmdGlobal);
|
||
Acad::ErrorStatus es = acedRegCmds->addCommand(szAppName0, szCmd, szCmd, cmdTable[i].nCmdFlag,
|
||
cmdTable[i].pFun, NULL, (bLispCmd ? i :-1));
|
||
ASSERT(es == Acad::eOk);
|
||
}
|
||
}
|
||
|
||
// 得一个面的参数
|
||
int GetFace()
|
||
{
|
||
TEntitySet ent;
|
||
TADSGePoint3d pt;
|
||
if(ent.FilterSelect1(GetApertureWcs(), _T("\n请选择三维坡屋顶坡面<退出>:"),
|
||
TRBList(), pt)!=RTNORM)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
pt = Ucs2Wcs(pt);
|
||
|
||
AcDbVoidPtrArray entSet;
|
||
int nDrawMode = DocGetDrawMode();
|
||
DocSetDrawMode(DRAW_3D);
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
||
InitModel(TMasterProperties(), pEnt, NULL, entSet);
|
||
OPENOBJ_END();
|
||
DocSetDrawMode(nDrawMode);
|
||
|
||
int num = entSet.length();
|
||
for (int i = 0; i < num; i++)
|
||
{
|
||
AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
|
||
ASSERT(pEnt);
|
||
if (pEnt->isA() == AcDbFace::desc())
|
||
{
|
||
AcDbFace *pFace = AcDbFace::cast(pEnt);
|
||
int nHitFlag = HitTestOnEdge(pFace, pt, TRUE);
|
||
if (nHitFlag >= 0)
|
||
{
|
||
TGGe3DFace faceUcs, faceWcs;
|
||
AcGePoint3d ptVert;
|
||
for (int n = 0; n < 4; n++)
|
||
{
|
||
pFace->getVertexAt(n, ptVert);
|
||
faceUcs.SetVertex(n, Wcs2Ucs(ptVert));
|
||
}
|
||
|
||
TVector3D vtNorm = faceWcs.GetNormal();
|
||
if (vtNorm.z < 1.0E-9)
|
||
{
|
||
continue; //法向不正确
|
||
}
|
||
|
||
if (faceUcs.IsLinear() || faceUcs.IsPoint())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TGGiScreenDrawStream dc(7, 1);
|
||
dc << faceUcs;
|
||
|
||
int nCode = YesNoQuestion(_T("\n是否为加亮的坡面"));
|
||
ads_redraw(NULL,0);
|
||
|
||
if (nCode == RTCAN)
|
||
{
|
||
ReleaseEntSet(entSet);
|
||
return nCode;
|
||
}
|
||
else if (nCode == Q_YES)
|
||
{
|
||
TADSGePoint3d ptIns;
|
||
if (GetPickPoint(NULL, _T("\n位置点"), ptIns) != RTNORM)
|
||
{
|
||
ReleaseEntSet(entSet);
|
||
return RTCAN;
|
||
}
|
||
|
||
for (int n = 0; n < 4; n++)
|
||
{
|
||
faceUcs.SetVertex(n, Ucs2Wcs(faceUcs.GetVertex(n)));
|
||
}
|
||
|
||
for (n = 0; n < 4; n++)
|
||
{
|
||
int nNext = DePeriod(4, n+1);
|
||
TGGeLine aLine(faceUcs.GetVertex(n), faceUcs.GetVertex(nNext));
|
||
if (aLine.GetLength() < _DIST_SNAP)
|
||
{
|
||
switch(nNext)
|
||
{
|
||
case 0:
|
||
break; // Just ignore vertex[3]
|
||
case 1:
|
||
faceUcs.SetVertex(1, faceUcs.GetVertex(2));
|
||
faceUcs.SetVertex(2, faceUcs.GetVertex(3));
|
||
break;
|
||
case 2:
|
||
faceUcs.SetVertex(2, faceUcs.GetVertex(3));
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
TADSGePoint3d ptInsert = ptIns;
|
||
TADSGePoint3d ptUp = ptInsert + TADSGePoint3d(0,0,100);
|
||
AcGeLine3d ln((AcGePoint3d &)ptInsert, (AcGePoint3d &)ptUp);
|
||
AcGePlane plane;
|
||
plane.set((AcGePoint3d &)faceUcs.GetVertex(0),
|
||
(AcGePoint3d &)faceUcs.GetVertex(1),
|
||
(AcGePoint3d &)faceUcs.GetVertex(2));
|
||
|
||
if (!plane.intersectWith(ln, ptInsert))
|
||
{
|
||
ReleaseEntSet(entSet);
|
||
return RTERROR;
|
||
}
|
||
|
||
TRBList rbRet = ads_buildlist(RT3DPOINT, &ptInsert, RTLB, RT3DPOINT, &faceUcs.GetVertex(0),
|
||
RT3DPOINT, &faceUcs.GetVertex(1),
|
||
RT3DPOINT, &faceUcs.GetVertex(2),
|
||
RT3DPOINT, &faceUcs.GetVertex(0),
|
||
RTLE, NULL);
|
||
ads_retlist(rbRet);
|
||
ReleaseEntSet(entSet);
|
||
return RTNORM;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
ReleaseEntSet(entSet);
|
||
ads_retnil();
|
||
return RTNONE;
|
||
}
|
||
|
||
int TGRegApp(LPCTSTR pszAppName, AcDbDatabase* pDb)
|
||
{
|
||
ASSERT(NULL != pszAppName && 0 < _tcslen(pszAppName));
|
||
|
||
if (NULL == pDb)
|
||
{
|
||
return acdbRegApp(pszAppName);
|
||
}
|
||
|
||
AcDbRegAppTable* pTable = NULL;
|
||
pDb->getRegAppTable(pTable, AcDb::kForWrite);
|
||
if (NULL == pTable)
|
||
return RTERROR;
|
||
|
||
AcDbRegAppTableRecord* pRecord = new AcDbRegAppTableRecord;
|
||
if (NULL == pRecord)
|
||
{
|
||
pTable->close();
|
||
return RTERROR;
|
||
}
|
||
|
||
pRecord->setName(pszAppName);
|
||
Acad::ErrorStatus es = pTable->add(pRecord);
|
||
pTable->close();
|
||
if (Acad::eOk != es)
|
||
{
|
||
delete pRecord;
|
||
return RTERROR;
|
||
}
|
||
|
||
pRecord->close();
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
void GetOffsetPoly2D(const TGGePoly2D& polySrc, TGGePoly2D& polyOut, double dOffset, bool bZoomOut/* = ture*/ )
|
||
{
|
||
polyOut = polySrc;
|
||
|
||
AcDbCurve *pCurve = NULL;
|
||
pCurve = polySrc.AsAcDbCurve();
|
||
|
||
if (!bZoomOut)
|
||
{
|
||
dOffset *= -1.0;
|
||
}
|
||
|
||
double dOldLen = 0.0;
|
||
double dEndT = 0.0;
|
||
pCurve->getEndParam(dEndT);
|
||
pCurve->getDistAtParam(dEndT,dOldLen);
|
||
|
||
AcDbVoidPtrArray offsetCurves;
|
||
pCurve->getOffsetCurves(dOffset,offsetCurves);
|
||
if (offsetCurves.length() > 0)
|
||
{
|
||
AcDbPolyline *pPline = (AcDbPolyline*)offsetCurves[0];
|
||
if (pPline != NULL)
|
||
{
|
||
double dNewLen = 0.0;
|
||
pPline->getEndParam(dEndT);
|
||
pPline->getDistAtParam(dEndT,dNewLen);
|
||
|
||
if ((bZoomOut && dNewLen < dOldLen) || (!bZoomOut && dNewLen > dOldLen))
|
||
{//如果放大，却得到了缩小的poly或者如果缩小却得到放大的poly
|
||
offsetCurves.removeAt(0);
|
||
pCurve->getOffsetCurves(-dOffset,offsetCurves);
|
||
if (offsetCurves.length() > 0)
|
||
{
|
||
pPline = (AcDbPolyline*)offsetCurves[0];
|
||
}
|
||
}
|
||
|
||
polyOut.SetAcDbCurve(pPline);
|
||
delete pPline;
|
||
}
|
||
}
|
||
delete pCurve;
|
||
}
|
||
void DrawEntInsulate(const TDPtrList<TGGeCurveSegment> &lstInsulateCurves)
|
||
{
|
||
//单独绘制保温层标识 wlw 11.03.17
|
||
int nSysInsutlate = 0;
|
||
TGGetVar(_T("USERI5"), &nSysInsutlate);
|
||
AcGePoint3d pts,pte;
|
||
AcDbObjectId idLayer = InitLayer(LAY_SURFACE,FALSE);
|
||
if (nSysInsutlate == 999)
|
||
{
|
||
AcDbLine *pline = NULL;
|
||
for (int l = 0; l < lstInsulateCurves.Length(); l++)
|
||
{
|
||
pts = (lstInsulateCurves[l]).StartPoint().AsAcGePoint3d();
|
||
pte = (lstInsulateCurves[l]).EndPoint().AsAcGePoint3d();
|
||
pline = new AcDbLine(pts,pte);
|
||
|
||
pline->setLayer(idLayer);
|
||
AddToCurrentSpace(pline,Adesk::kTrue);
|
||
}
|
||
}
|
||
}
|
||
|
||
AcDbFace* GetFaceFromSegment(const TGGeCurveSegment& segment, double dHeight)
|
||
{
|
||
AcDbFace* pface = NULL;
|
||
AcGePoint3d ptArray[4];
|
||
ptArray[0] = ptArray[1] = segment.StartPoint();
|
||
ptArray[2] = ptArray[3] = segment.EndPoint();
|
||
ptArray[1][2] += dHeight;
|
||
ptArray[2][2] += dHeight;
|
||
pface = new AcDbFace(ptArray[0],ptArray[1],ptArray[2],ptArray[3]);
|
||
return pface;
|
||
}
|
||
#ifdef TASD
|
||
//结构用
|
||
TARCH_IMPEXP int g_nColuForce = TDbColumn::eNormal; //底层墙柱显示工况
|
||
TARCH_IMPEXP int g_nLoadDrawMode = 0; // 荷载显示控制
|
||
TARCH_IMPEXP int g_nLoadViewMode = 7; // 荷载显示控制
|
||
TARCH_IMPEXP BOOL g_bDetailMode = TRUE; // 特殊梁柱是否简图模式
|
||
TARCH_IMPEXP double g_dCLTextHeight; //单元编号文字字高
|
||
TARCH_IMPEXP int g_nCLTextColorBeam; //梁单元编号文字颜色
|
||
TARCH_IMPEXP int g_nCLTextColorColu; //柱单元编号文字颜色
|
||
TARCH_IMPEXP int g_nCLTextColorWall; //剪力墙单元编号文字颜色
|
||
TARCH_IMPEXP int g_nCLTextColorSlab; //板单元编号文字颜色
|
||
TARCH_IMPEXP int g_nCLTextColorNode; //节点编号文字颜色
|
||
TARCH_IMPEXP double g_dBHTextHeight; //截面尺寸文字字高
|
||
TARCH_IMPEXP int g_nBHTextColorBeam; //梁截面尺寸文字颜色
|
||
TARCH_IMPEXP int g_nBHTextColorColu; //柱截面尺寸文字颜色
|
||
TARCH_IMPEXP int g_nBHTextColorWall; //剪力墙截面尺寸文字颜色
|
||
TARCH_IMPEXP int g_nBHTextColorSlab; //板截面尺寸文字颜色
|
||
TARCH_IMPEXP int g_nBHTextColorSlabHole; //板洞截面尺寸文字颜色
|
||
TARCH_IMPEXP double g_dRGTextHeight; //刚域文字字高
|
||
TARCH_IMPEXP int g_nRGTextColorBeam; //梁刚域文字颜色
|
||
TARCH_IMPEXP int g_nRGTextColorColu; //柱刚域文字颜色
|
||
TARCH_IMPEXP int g_nGraph = FORCE_NORMAL;// 显示的力图的种类
|
||
TARCH_IMPEXP double g_dMGrapTextH = 5; // 弯矩包络图文字高
|
||
TARCH_IMPEXP double g_dMGrapScal = 10; // 弯矩包络图比例
|
||
TARCH_IMPEXP double g_dNGrapTextH = 3; // 轴力文字高度
|
||
TARCH_IMPEXP double g_dReinbarWidth = 30.0f;//钢筋线宽
|
||
TARCH_IMPEXP double g_dReinbarLenS = 100.0f;//钢筋直钩平直长度
|
||
TARCH_IMPEXP double g_dReinbarLenO = 100.0f;//钢筋斜钩平直长度
|
||
TARCH_IMPEXP double g_dReinbarLenB = 100.0f;//钢筋弯钩平直长度
|
||
TARCH_IMPEXP double g_dReinbarDiaB = 45.0f; //钢筋弯钩直径
|
||
TARCH_IMPEXP double g_dReinbarDotWidth = 50.0f;//点钢筋直径
|
||
TARCH_IMPEXP double g_dStirrupsLen = 100.0f;//箍筋平直长度
|
||
|
||
TARCH_IMPEXP int g_nDrawModeSlab = 0; //楼板显示控制
|
||
TARCH_IMPEXP int g_nDrawModeSlabBorder = 0;//楼板边界显示控制
|
||
TARCH_IMPEXP double g_dCrackGraphTextH = 3.5; // 字高
|
||
TARCH_IMPEXP double g_dCrackLimit = 0.3; // 裂缝限制值
|
||
TARCH_IMPEXP double g_dDeflectGraphTextH = 3.5; // 字高
|
||
TARCH_IMPEXP double g_dDeflectGraphScale = 10; // 幅度
|
||
TARCH_IMPEXP BOOL g_bShowCrack = FALSE; // 显示裂缝图
|
||
TARCH_IMPEXP BOOL g_bShowDef = FALSE; // 显示挠度图
|
||
TARCH_IMPEXP double g_dSGrapTextH = 5; // 剪力包络图文字高
|
||
TARCH_IMPEXP double g_dSGrapScal = 10; // 剪力包络图幅值
|
||
TARCH_IMPEXP BOOL g_bAutoBreak = TRUE; //梁柱自动打断控制参数
|
||
TARCH_IMPEXP BOOL g_bAutoUpdate = TRUE; // 自动更新图形控制参数
|
||
TARCH_IMPEXP double g_dNodeDiameter = 0.8; // 节点直径
|
||
TARCH_IMPEXP Adesk::UInt16 g_iSolidNodeColor = 0; // 实节点颜色
|
||
TARCH_IMPEXP Adesk::UInt16 g_iVirtualNodeColor = 0; // 虚节点颜色
|
||
TARCH_IMPEXP int g_nReinAreaMode = eNorm; //配筋面积显示方式
|
||
TARCH_IMPEXP int g_nReinAreaModeColu = eNorm; //柱配筋面积显示方式
|
||
TARCH_IMPEXP int g_nReinAreaModeWall = 0; //墙配筋面积显示方式
|
||
TARCH_IMPEXP BOOL g_bSplitFloor = TRUE;
|
||
|
||
|
||
#define WALL_BODY_CAL 0x001
|
||
#define WALL_COLU_CAL 0x002
|
||
#define WALL_BEAM_CAL 0x004
|
||
#define WALL_BODY_REAL 0x010
|
||
#define WALL_COLU_REAL 0x020
|
||
#define WALL_BEAM_REAL 0x040
|
||
|
||
BOOL GetViewStyle(int nStyle)
|
||
{
|
||
switch(nStyle)
|
||
{
|
||
case BYGRAPHIC:
|
||
return ((g_nLoadViewMode & GRAPHIC) != 0);
|
||
break;
|
||
case BYUNVARYING:
|
||
return ((g_nLoadViewMode & UNVARYINGLOAD) != 0);
|
||
break;
|
||
case BYVARYING:
|
||
return ((g_nLoadViewMode & VARYINGLOAD) != 0);
|
||
break;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
void SetViewStyle(int nStyle, BOOL bTrue)
|
||
{
|
||
if(bTrue)
|
||
{
|
||
switch(nStyle)
|
||
{
|
||
case BYGRAPHIC:
|
||
g_nLoadViewMode |= GRAPHIC;
|
||
break;
|
||
case BYUNVARYING:
|
||
g_nLoadViewMode |= UNVARYINGLOAD;
|
||
break;
|
||
case BYVARYING:
|
||
g_nLoadViewMode |= VARYINGLOAD;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch(nStyle)
|
||
{
|
||
case BYGRAPHIC:
|
||
g_nLoadViewMode &= ~GRAPHIC;
|
||
break;
|
||
case BYUNVARYING:
|
||
g_nLoadViewMode &= ~UNVARYINGLOAD;
|
||
break;
|
||
case BYVARYING:
|
||
g_nLoadViewMode &= ~VARYINGLOAD;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
// add by wjx on 120325
|
||
// 去除小数末尾的零
|
||
// in: dDara:数据
|
||
// in: nNum:保留的小数位 -1:只去除末尾的0, 否则就是小数位(如果是整数精度没用)
|
||
CString TrimDoubleZero(double dData, int nNum)
|
||
{
|
||
CString str;
|
||
str.Format(_T("%f"), dData);
|
||
str.TrimRight(_T("0")); // 去除末尾的0
|
||
CString strDot = str.Right(1);
|
||
if(_T(".") == strDot) // 如果末尾是小数点去除小数点
|
||
{
|
||
str.TrimRight(_T("."));
|
||
return str;
|
||
}
|
||
|
||
if(-1 == nNum)
|
||
{
|
||
return str;
|
||
}
|
||
else if(0 == nNum) // 保留整数部分
|
||
{
|
||
str.Format(_T("%.f"), dData);
|
||
}
|
||
else // 精确到小数
|
||
{
|
||
int nDotPos = str.Find(_T("."));
|
||
if(-1 == nDotPos)
|
||
{
|
||
return str; // 如果小数部分都是0精确位数没用
|
||
}
|
||
else
|
||
{
|
||
int nLen = str.GetLength();
|
||
if(nLen > (nDotPos + nNum + 1))
|
||
{
|
||
nLen = nDotPos + nNum + 1;
|
||
}
|
||
CString strDot = str.Left(nLen);
|
||
str = strDot;
|
||
}
|
||
}
|
||
|
||
return str;
|
||
}
|
||
|
||
void SetWallBodyCal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_BODY_CAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_BODY_CAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallBodyCal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_BODY_CAL) != 0);
|
||
}
|
||
|
||
|
||
void SetWallBeamCal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_BEAM_CAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_BEAM_CAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallBeamCal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_BEAM_CAL) != 0);
|
||
}
|
||
|
||
|
||
void SetWallColuCal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_COLU_CAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_COLU_CAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallColuCal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_COLU_CAL) != 0);
|
||
}
|
||
|
||
|
||
void SetWallBodyReal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_BODY_REAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_BODY_REAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallBodyReal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_BODY_REAL) != 0);
|
||
}
|
||
|
||
|
||
void SetWallBeamReal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_BEAM_REAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_BEAM_REAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallBeamReal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_BEAM_REAL) != 0);
|
||
}
|
||
|
||
|
||
void SetWallColuReal(BOOL bTrue)
|
||
{
|
||
if (bTrue)
|
||
{
|
||
g_nReinAreaModeWall |= WALL_COLU_REAL;
|
||
}
|
||
else
|
||
{
|
||
g_nReinAreaModeWall &= ~WALL_COLU_REAL;
|
||
}
|
||
}
|
||
|
||
BOOL IsWallColuReal()
|
||
{
|
||
return ((g_nReinAreaModeWall & WALL_COLU_REAL) != 0);
|
||
}
|
||
#endif |