2631 lines
71 KiB
C++
2631 lines
71 KiB
C++
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "SetWall.h"
|
|
#include "InsertOpeningDlg.h"
|
|
|
|
// [2010-3-16 10:32 wubo] 移植到新Geo库
|
|
// extern GEOAPI Acad::ErrorStatus GetSafeSelection(PickSet &ss, const XPoint &ptLow, const XPoint &ptUp,
|
|
// DList<AcRxClass> &lstClass, AcDbObjectId idLayer);
|
|
|
|
extern GEOAPI Acad::ErrorStatus
|
|
GetSafeSelection(PickSet &ss, BOOL bCrossing,
|
|
const XPoint &ptLow, const XPoint &ptUp, const AcRxClass *pClass);
|
|
extern TARCH_IMPEXP BOOL g_bShiftToggle;
|
|
// [2010-3-16 10:32 wubo] 移植到新Geo库
|
|
// extern TARCH_IMPEXP BOOL g_bCtrlToggle;
|
|
|
|
// 绘制点的形状
|
|
void DrawOsnapShape(AcGiViewportDraw *pVd, XPoint m_ptLoc, int m_osShape)
|
|
{
|
|
XAcGiViewDraw dc(NULL, pVd);
|
|
AcGePoint2d pixelArea;
|
|
pVd->viewport().getNumPixelsInUnitSquare(m_ptLoc,pixelArea);
|
|
double nAperture = 16/pixelArea.asVector().length();
|
|
if (nAperture<1.0E-6)
|
|
return;
|
|
XRectAngle box(m_ptLoc, nAperture, nAperture);
|
|
AcDbPolyline pline;
|
|
pVd->subEntityTraits().setColor(2);
|
|
double nWidth=1/pixelArea.asVector().length();
|
|
pline.setConstantWidth(nWidth);
|
|
|
|
ads_matrix mat;
|
|
m_ptLoc.GetRotationMatrix(Ucs2Wcs(0.0),mat);
|
|
//dc.SetColor(6); //用粉红色
|
|
switch(m_osShape) {
|
|
case AcDb::kOsMaskEnd: {
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetUpRight().AsAcGePoint2d());
|
|
pline.addVertexAt(3, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kTrue);
|
|
//pline.viewportDraw(pVd);
|
|
XPoly2D poly1, poly2, poly;
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
}
|
|
break;
|
|
case AcDb::kOsMaskInt: {
|
|
pline.setClosed(Adesk::kFalse);
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetUpRight().AsAcGePoint2d());
|
|
XPoly2D poly1, poly2, poly;
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
pline.reset(Adesk::kFalse, 0);
|
|
poly1.Reset(); poly2.Reset(); poly.Reset();
|
|
pline.addVertexAt(0, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetUpLeft().AsAcGePoint2d());
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
}
|
|
break;
|
|
case AcDb::kOsMaskNear: {
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(3, box.GetUpRight().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kTrue);
|
|
XPoly2D poly1, poly2, poly;
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
}
|
|
break;
|
|
case AcDb::kOsMaskPerp: {
|
|
pline.addVertexAt(0, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetLowRight().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kFalse);
|
|
XPoly2D poly1, poly2, poly;
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
pline.reset(Adesk::kFalse, 0);
|
|
poly1.Reset(); poly2.Reset(); poly.Reset();
|
|
XPoint pt1, pt2;
|
|
Midpoint(box.GetUpLeft(), box.GetLowLeft(), pt1);
|
|
Midpoint(box.GetLowRight(), box.GetLowLeft(), pt2);
|
|
pline.addVertexAt(0, pt1.AsAcGePoint2d());
|
|
pline.addVertexAt(1, m_ptLoc.AsAcGePoint2d());
|
|
pline.addVertexAt(2, pt2.AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kFalse);
|
|
PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
dc << poly1 << poly2;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////
|
|
// 判断给定的点是否在墙体基线上
|
|
// -----------------------by gjm---------------------------//
|
|
/*
|
|
画墙时，如果墙起点与终点都在另一个墙A的轮廓线内，
|
|
并且新墙标高大于等于A墙标高并且小于A墙的标高+墙高，则为重复墙，不会成功。
|
|
以下条件是建立在以上观点上的。
|
|
1.终点在墙A的轮廓线内，起点不在，则将新墙线与A墙线取交点，并用交点替换终点
|
|
2.起点在墙A的轮廓线内，终点不在，则将新墙线与A墙线取交点，并用交点替换起点
|
|
3.弧墙两端点在墙A轮廓线内，而其弧顶点不在，这种情况也要处理，将两端点都替换成墙A基线上的最近点。
|
|
*/
|
|
namespace
|
|
{
|
|
// 返回 TRUE 说明对其中一点有过修改。
|
|
// 返回 FALSE说明对两点都无修改。即两点都在墙的轮廓线之外
|
|
BOOL ModifyPntByWall(TDbWall *pWall, XPoint &ptS, XPoint & ptE)
|
|
{
|
|
if (!pWall) return FALSE;
|
|
|
|
TGGePoly2D poly;
|
|
pWall->GetOutlinePoly(.0, poly, TRUE);
|
|
int nFlagS = ptS & poly ,nFlagE = ptE & poly;
|
|
|
|
bool bAllIn = nFlagE == PR_OUTSIDE && nFlagS == PR_OUTSIDE;
|
|
|
|
// 如果是直墙，且两端点都在pWall轮廓线内，则直接退出
|
|
if (!pWall->IsKindOf(TGGeEntity::eArc))
|
|
if (bAllIn) return FALSE;
|
|
|
|
// 求交点
|
|
TGGeLine line(ptS, ptE, LS_INFINITE);
|
|
TADSGePoint3d pt1, pt2;
|
|
int nCount = pWall->Intersection(line, pt1, pt2);
|
|
|
|
if ((nFlagS == PR_INSIDE) && (nFlagE != PR_INSIDE)) // 起点在内，终点不在
|
|
{
|
|
if (nCount == 1)
|
|
ptS = pt1;
|
|
else if (nCount ==2)
|
|
{
|
|
double d1 = pt1.Distance2d(ptS);
|
|
double d2 = pt2.Distance2d(ptS);
|
|
ptS = d1 < d2 ? pt1 : pt2;
|
|
}
|
|
return FALSE;
|
|
}
|
|
if ((nFlagS != PR_INSIDE) && (nFlagE == PR_INSIDE)) // 终点在内，起点不在
|
|
{
|
|
if (nCount == 1)
|
|
ptE = pt1;
|
|
else if (nCount == 2)
|
|
{
|
|
double d1 = pt1.Distance2d(ptE);
|
|
double d2 = pt2.Distance2d(ptE);
|
|
ptE = d1 < d2 ? pt1 : pt2;
|
|
}
|
|
return TRUE;
|
|
}
|
|
if ((nFlagS == PR_INSIDE) && (nFlagE == PR_INSIDE)) // 这种情况只能是弧墙
|
|
{
|
|
if (nCount == 2)
|
|
{
|
|
double d1 = pt1.Distance2d(ptE);
|
|
double d2 = pt2.Distance2d(ptE);
|
|
ptE = d1 < d2 ? pt1 : pt2;
|
|
d1 = pt1.Distance2d(ptS);
|
|
d2 = pt2.Distance2d(ptS);
|
|
ptS = d1 < d2 ? pt1 : pt2;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL IsOnWallBase(const XPoint &pt)
|
|
{
|
|
XPoint ptOnWall=pt;
|
|
PickSet ssWall(SS_FREE);
|
|
if (GetEntByDxf(ssWall, _T("TCH_WALL,TCH_CURTAIN_WALL"),1)==Acad::eOk)
|
|
{
|
|
long lCount=ssWall.Length();
|
|
for(long i=0L; i<lCount; i++)
|
|
{
|
|
Entity e=ssWall[i];
|
|
OPENOBJ_BEGIN(e, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall) {
|
|
ptOnWall.z=pWall->GetElevation();
|
|
int nPrFlag=ptOnWall&(*pWall);
|
|
if (nPrFlag==PR_INSIDE || nPrFlag==PR_ONPT1 || nPrFlag==PR_ONPT2)
|
|
return TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// 转为画墙而生
|
|
BOOL IsOnWallBaseForDraw(XPoint &ptEnd, XPoint &ptStart)
|
|
{
|
|
PickSet ssWall(SS_FREE);
|
|
if (GetEntByDxf(ssWall, _T("TCH_WALL,TCH_CURTAIN_WALL"),1)==Acad::eOk)
|
|
{
|
|
long lCount=ssWall.Length();
|
|
for(long i=0L; i<lCount; i++)
|
|
{
|
|
Entity e=ssWall[i];
|
|
OPENOBJ_BEGIN(e, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
if (ModifyPntByWall(pWall, ptStart, ptEnd))
|
|
return TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/////////////////////////////
|
|
// 捕捉轴线的交点
|
|
BOOL SnapAxisInt(PickSet &ssAxis, XPoint &ptWcs)
|
|
{
|
|
BOOL bRet=FALSE;
|
|
XPoint ptNearest;
|
|
double nMinDist=0.0;
|
|
long lCount=ssAxis.Length();
|
|
if (lCount<2)
|
|
return FALSE;
|
|
|
|
AcGePoint3dArray points;
|
|
AcDb::Intersect intType=AcDb::kOnBothOperands;
|
|
for(long i=0L; i<lCount-1; i++) {
|
|
Entity ent1=ssAxis[i];
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCurve, pEnt1);
|
|
if (!pEnt1)
|
|
continue;
|
|
for(long j=i+1; j<lCount; j++) {
|
|
Entity ent2=ssAxis[j];
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCurve, pEnt2);
|
|
if (!pEnt2)
|
|
continue;
|
|
|
|
pEnt1->intersectWith(pEnt2, intType, points);
|
|
OPENOBJ_END();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
int nInters=points.length();
|
|
for(int k=0; k<nInters; k++) {
|
|
XPoint ptCur=points[k];
|
|
double nDist=ptWcs.Distance(ptCur);
|
|
if (bRet) {
|
|
if (nDist<nMinDist) {
|
|
nMinDist=nDist;
|
|
ptNearest=ptCur;
|
|
}
|
|
} else {
|
|
nMinDist=nDist;
|
|
ptNearest=ptCur;
|
|
bRet=TRUE;
|
|
}
|
|
}
|
|
if (bRet)
|
|
ptWcs=ptNearest;
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//////////////////////////
|
|
// 捕捉最近点
|
|
BOOL SnapNear(PickSet &ss, XPoint &ptWcs, Entity &entNear)
|
|
{
|
|
BOOL bRet=FALSE;
|
|
XPoint ptNearest;
|
|
double nMinDist=0.0;
|
|
long lCount=ss.Length();
|
|
|
|
AcDb::Intersect intType=AcDb::kOnBothOperands;
|
|
|
|
// 构造WCS到Dcs的转换矩阵
|
|
AcGeMatrix3d transWcsToDcs;
|
|
XPoint xAxesWcs(1,0,0), yAxesWcs(0,1,0), zAxesWcs(0,0,1),
|
|
xAxesDcs, yAxesDcs, zAxesDcs;
|
|
XPoint ptOrginWcs(0,0,0), ptOrginDcs(0,0,0);
|
|
Groups fromWcs(0), toDcs(2);
|
|
ads_trans(ptOrginWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 0, ptOrginDcs);
|
|
ads_trans(xAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, xAxesDcs);
|
|
ads_trans(yAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, yAxesDcs);
|
|
ads_trans(zAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, zAxesDcs);
|
|
transWcsToDcs.setCoordSystem(ptOrginDcs, xAxesDcs, yAxesDcs, zAxesDcs);
|
|
|
|
XPoint ptLast;
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
|
if (!pEnt)
|
|
continue;
|
|
AcGePoint3dArray points;
|
|
if (pEnt->getOsnapPoints(AcDb::kOsModeNear, 0, ptWcs, ptLast, transWcsToDcs, points, AcDbIntArray())==Acad::eOk) {
|
|
int numPoints=points.length();
|
|
for(int k=0; k<numPoints; k++) {
|
|
XPoint ptCur=points[k];
|
|
ptCur.z=ptWcs.z;
|
|
double nDist=ptWcs.Distance(ptCur);
|
|
if (bRet) {
|
|
if (nDist<nMinDist) {
|
|
nMinDist=nDist;
|
|
ptNearest=ptCur;
|
|
entNear=ent;
|
|
}
|
|
} else {
|
|
nMinDist=nDist;
|
|
ptNearest=ptCur;
|
|
bRet=TRUE;
|
|
entNear=ent;
|
|
}
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
if (bRet)
|
|
ptWcs=ptNearest;
|
|
return bRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 捕捉墙的端点
|
|
BOOL SnapWallEnd(PickSet &ssWall, const XRectAngle &box, XPoint &ptWcs)
|
|
{
|
|
BOOL bRet=FALSE;
|
|
XPoint ptNearest;
|
|
double nMinDist=0.0;
|
|
long lCount=ssWall.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ssWall[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall) {
|
|
XPoint ptEnd[2]={pWall->StartPoint(), pWall->EndPoint()};
|
|
ptEnd[0].z=ptEnd[1].z=ptWcs.z;
|
|
for(int n=0; n<2; n++) {
|
|
if ((ptEnd[n]&box)!=PR_OUTSIDE) {
|
|
double nDist=ptEnd[n].Distance(ptWcs);
|
|
if (bRet) {
|
|
if (nDist<nMinDist) {
|
|
nMinDist=nDist;
|
|
ptNearest=ptEnd[n];
|
|
}
|
|
} else {
|
|
nMinDist=nDist;
|
|
ptNearest=ptEnd[n];
|
|
bRet=TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
if (bRet)
|
|
ptWcs=ptNearest;
|
|
return bRet;
|
|
}
|
|
|
|
|
|
// 为方便从数据库中开窗口搜索AcDbCurve的实体
|
|
class XCurvePickSet: public PickSet {
|
|
protected:
|
|
XStringList m_lstLayerFilter, m_lstDxfNameFilter;
|
|
public:
|
|
XCurvePickSet():PickSet(SS_FREE)
|
|
{}
|
|
void SetLayerFilter(XStringList &lstLay) {
|
|
m_lstLayerFilter=lstLay;
|
|
}
|
|
void SetDxfNameFilter(XStringList &lstDxf) {
|
|
m_lstDxfNameFilter=lstDxf;
|
|
}
|
|
int GetByCrossing(const XPoint &ptLow, const XPoint &ptUp);
|
|
};
|
|
|
|
// 给定窗口进行搜索
|
|
int XCurvePickSet::GetByCrossing(const XPoint &ptLow, const XPoint &ptUp)
|
|
{
|
|
XDbBlockTableRec objMSpace;
|
|
if (!objMSpace)
|
|
return RTERROR;
|
|
int nRet=RTNONE;
|
|
XRectAngle rect(ptLow, ptUp);
|
|
XPoint ptMid;
|
|
Midpoint(ptLow, ptUp, ptMid);
|
|
AcDbBlockTableRecordIterator* pBlockIterator=NULL;
|
|
Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
|
|
ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
|
|
|
|
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) {
|
|
AcDbEntity *pEntity=NULL;
|
|
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
|
|
if (es!=Acad::eOk) continue;
|
|
ASSERT(pEntity);
|
|
XDbObject vTemp(pEntity);
|
|
//不处理不可见的实体
|
|
if (pEntity->visibility() == AcDb::kInvisible) {
|
|
continue;
|
|
}
|
|
AcDbCurve *pCurve=AcDbCurve::cast(pEntity);
|
|
if (!pCurve)
|
|
continue;
|
|
if (!!m_lstDxfNameFilter) {
|
|
const TCHAR *pszDxfName=pEntity->isA()->dxfName();
|
|
if (m_lstDxfNameFilter.Index(pszDxfName, 0)<0)
|
|
continue;
|
|
}
|
|
AcDbObjectId idLayer=pEntity->layerId();
|
|
OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
|
|
if (pLayer) {
|
|
if (pLayer && pLayer->isFrozen() || pLayer->isOff())
|
|
continue;
|
|
}
|
|
OPENOBJ_END();
|
|
if (!!m_lstLayerFilter) {
|
|
TCHAR *pszLayer=pEntity->layer();
|
|
ASSERT(pszLayer);
|
|
if (m_lstLayerFilter.Index(pszLayer, 0)<0) {
|
|
delete pszLayer;
|
|
continue;
|
|
}
|
|
delete pszLayer;
|
|
}
|
|
XPoint ptCloseToCurve;
|
|
if (pCurve->getClosestPointTo(ptMid, ptCloseToCurve)==Acad::eOk &&
|
|
(ptCloseToCurve&rect)==PR_INSIDE) {
|
|
Entity ent;
|
|
VERIFY(acdbGetAdsName(ent.name, pCurve->objectId())==Acad::eOk);
|
|
*this += ent;
|
|
nRet=RTNORM;
|
|
}
|
|
}
|
|
delete pBlockIterator;
|
|
return nRet;
|
|
}
|
|
|
|
// nOsShape: 0--没有捕捉; 1--墙基线端点; 2--轴线交点; 3--墙基线最近点; 4--轴线最近点
|
|
// 对应: 的捕捉代码
|
|
int AsOsnapMask(int nOsShape)
|
|
{
|
|
int nRet=0;
|
|
switch(nOsShape) {
|
|
case 1:
|
|
nRet=AcDb::kOsMaskEnd;
|
|
break;
|
|
case 2:
|
|
nRet=AcDb::kOsMaskInt;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
nRet=AcDb::kOsMaskNear;
|
|
break;
|
|
case 5:
|
|
case 6:
|
|
nRet=AcDb::kOsMaskPerp;
|
|
break;
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
// 捕捉顺序: 墙基线端点,轴线交点,墙垂足，轴线垂足，墙基线最近点,轴线最近点
|
|
// ptWcs -- I/O
|
|
// 返回: 0--没有捕捉; 1--墙基线端点; 2--轴线交点; 3--墙基线最近点; 4--轴线最近点
|
|
// 5--墙垂足; 6--轴线垂足
|
|
int AutoSnapWall(XPoint &ptWcs, XPoint *ptBase=NULL)
|
|
{
|
|
double nApertureWcs=GetApertureWcs();
|
|
if (nApertureWcs<1.0E-6)
|
|
return 0;
|
|
int bSnap=0;
|
|
XPoint vtSnap(nApertureWcs, nApertureWcs);
|
|
XPoint ptLow=ptWcs-vtSnap;
|
|
XPoint ptUp = ptWcs+vtSnap;
|
|
|
|
XCurvePickSet ssWall, ssAxis;
|
|
/*
|
|
XStringList lstWallFilter, lstAxisFilter, lstAxisLayerFilter;
|
|
lstWallFilter.Append(strnew(_T("TCH_WALL")));
|
|
lstAxisFilter.Append(strnew(_T("LINE")));
|
|
lstAxisFilter.Append(strnew(_T("ARC")));
|
|
lstAxisFilter.Append(strnew(_T("CIRCLE")));
|
|
lstAxisLayerFilter.Append(strnew(LAY_AXIS));
|
|
|
|
ssWall.SetDxfNameFilter(lstWallFilter);
|
|
ssAxis.SetDxfNameFilter(lstAxisFilter);
|
|
ssAxis.SetLayerFilter(lstAxisLayerFilter);
|
|
|
|
BOOL bNearWall =
|
|
ssWall.GetByCrossing(ptLow, ptUp)==RTNORM;
|
|
BOOL bNearAxis =
|
|
ssAxis.GetByCrossing(ptLow, ptUp)==RTNORM;
|
|
*/
|
|
|
|
BOOL bNearWall = (GetSafeSelectionEx(ssWall, FALSE, ptLow, ptUp, TDbWall::desc())==Acad::eOk);
|
|
|
|
/*
|
|
PickSet ss1(SS_FREE), ss2(SS_FREE), ss3(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 bNearAxis3=(GetSafeSelection(ss3, FALSE, ptLow, ptUp, AcDbCircle::desc())==Acad::eOk);
|
|
BOOL bNearAxis=(bNearAxis1 || bNearAxis2 || bNearAxis3);
|
|
ssAxis += ss1;
|
|
ssAxis += ss2;
|
|
ssAxis += ss3;
|
|
if (bNearAxis) {
|
|
ssAxis.BaseFilter(RBList(8, LAY_AXIS, NULL));
|
|
bNearAxis=(ssAxis.Length()>0);
|
|
}
|
|
*/
|
|
AcDbObjectId idLay=GetLayerIdFromString(LAY_AXIS);
|
|
// sg modify 120305，由于在ARX2013的开发包中，AcRxClass类的构造函数、析构函数变成了保护成员，因此下面的用法是有错误的，换成其他接口
|
|
//DList<AcRxClass> lstClasses(FALSE);
|
|
//lstClasses.Append(AcDbLine::desc());
|
|
//lstClasses.Append(AcDbArc::desc());
|
|
//lstClasses.Append(AcDbCircle::desc());
|
|
//BOOL bNearAxis=(GetSafeSelection(ssAxis, ptLow, ptUp, lstClasses, idLay)==Acad::eOk
|
|
// && ssAxis.Length()>0);
|
|
CStringArray aryDxfNames;
|
|
aryDxfNames.Add(_T("Line"));
|
|
aryDxfNames.Add(_T("Arc"));
|
|
aryDxfNames.Add(_T("Circle"));
|
|
BOOL bNearAxis=(GetSafeSelection(ssAxis, ptLow, ptUp, aryDxfNames, idLay)==Acad::eOk
|
|
&& ssAxis.Length()>0);
|
|
|
|
XRectAngle box(ptLow, ptUp);
|
|
if (bNearWall)
|
|
if (SnapWallEnd(ssWall, box, ptWcs))
|
|
bSnap = 1;
|
|
if (!bSnap && bNearAxis)
|
|
if (SnapAxisInt(ssAxis, ptWcs))
|
|
bSnap = 2;
|
|
if (!bSnap && bNearWall) {
|
|
Entity entNear;
|
|
XPoint ptCursor=ptWcs;
|
|
if (SnapNear(ssWall, ptWcs, entNear)) {
|
|
bSnap = 3;
|
|
OPENOBJ_BEGIN(entNear, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall && ptBase) {
|
|
if (((*ptBase)&(*pWall))==PR_OUTSIDE) {
|
|
XPoint ptPrj;
|
|
pWall->ProjectToMe(*ptBase, ptPrj);
|
|
double nIntAng=CT_acute_angle(ads_angle(*ptBase, ptPrj)-ads_angle(*ptBase, ptCursor));
|
|
if ((ptPrj&(*pWall))==PR_INSIDE && nIntAng<5.0*PI/180.0) {
|
|
bSnap=5;
|
|
ptWcs=ptPrj;
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
if (!bSnap && bNearAxis) {
|
|
Entity entNear;
|
|
XPoint ptCursor=ptWcs;
|
|
if (SnapNear(ssAxis, ptWcs, entNear)) {
|
|
bSnap = 4;
|
|
XCurveSegment seg(entNear);
|
|
if (ptBase) {
|
|
XPoint ptPrj;
|
|
if (((*ptBase)&seg)==PR_OUTSIDE) {
|
|
seg.ProjectToMe(*ptBase, ptPrj);
|
|
double nIntAng=CT_acute_angle(ads_angle(*ptBase, ptPrj)-ads_angle(*ptBase, ptCursor));
|
|
if ((ptPrj&seg)==PR_INSIDE && nIntAng<5.0*PI/180.0) {
|
|
bSnap=6;
|
|
ptWcs=ptPrj;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return bSnap;
|
|
}
|
|
|
|
|
|
|
|
// 捕捉唯一的最近墙
|
|
// ptWcs(IN) -- 给定的点
|
|
// 返回: 捕捉到的墙体
|
|
AcDbObjectId SnapOnWall(const XPoint &ptWcs)
|
|
{
|
|
AcDbObjectId idRet;
|
|
XDbBlockTableRec objMSpace;
|
|
if (!objMSpace)
|
|
return idRet;
|
|
|
|
AcDbBlockTableRecordIterator* pBlockIterator=NULL;
|
|
Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
|
|
ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
|
|
|
|
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) {
|
|
AcDbEntity *pEntity=NULL;
|
|
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
|
|
if (es!=Acad::eOk) continue;
|
|
ASSERT(pEntity);
|
|
|
|
XDbObject vTemp(pEntity);
|
|
//不处理不可见的实体
|
|
if (pEntity->visibility() == AcDb::kInvisible || !pEntity->isKindOf(TDbWall::desc())) {
|
|
continue;
|
|
}
|
|
TDbWall *pWall=(TDbWall*)pEntity;
|
|
AcDbObjectId idLayer=pWall->layerId();
|
|
OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
|
|
ASSERT(pLayer);
|
|
if (pLayer->isFrozen() || pLayer->isOff())
|
|
continue;
|
|
OPENOBJ_END();
|
|
|
|
XPoint ptPrj;
|
|
if (pWall->ProjectToMe(ptWcs, ptPrj)!=RTNORM)
|
|
continue;
|
|
if ((ptPrj&(*pWall))!=PR_INSIDE)
|
|
continue;
|
|
double nDist2Wall=pWall->GetDist2Me(ptWcs);
|
|
if (nDist2Wall > -pWall->GetWidth(0) - _DIST_SNAP*10 &&
|
|
nDist2Wall < pWall->GetWidth(1)+_DIST_SNAP*10) {
|
|
idRet=pWall->objectId();
|
|
break;
|
|
}
|
|
}
|
|
delete pBlockIterator;
|
|
return idRet;
|
|
|
|
#if 0
|
|
// 不知道是否捕捉速度太慢, 光标移动到墙体内时，捕捉光标出现。
|
|
PickSet ssWall(SS_FREE);
|
|
if (GetEntByDxf(ssWall,_T("TCH_WALL,TCH_CURTAIN_WALL"),1)!=Acad::eOk)
|
|
//if (ssWall.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("TCH_WALL"), NULL))!=RTNORM)
|
|
return AcDbObjectId::kNull;
|
|
long lCount=ssWall.Length();
|
|
for(long i=0; i<lCount; i++) {
|
|
Entity ent=ssWall[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall) {
|
|
XPoly2D poly2d(1);
|
|
pWall->GetOutlinePoly(ptWcs.z, poly2d);
|
|
if ((ptWcs&poly2d)!=PR_OUTSIDE) {
|
|
return pWall->objectId();
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return AcDbObjectId::kNull;
|
|
/*
|
|
AcDbObjectId idRet;
|
|
double nApertureWcs=GetApertureWcs();
|
|
if (nApertureWcs<1.0E-6)
|
|
return idRet;
|
|
|
|
//int bSnap=0;
|
|
XPoint vtSnap(nApertureWcs*4, nApertureWcs*4);
|
|
XPoint ptLow=ptWcs-vtSnap;
|
|
XPoint ptUp = ptWcs+vtSnap;
|
|
|
|
XCurvePickSet ssWall;
|
|
XStringList lstWallFilter;
|
|
lstWallFilter.Append(strnew(_T("TCH_WALL")));
|
|
ssWall.SetDxfNameFilter(lstWallFilter);
|
|
BOOL bNearWall =
|
|
ssWall.GetByCrossing(ptLow, ptUp)==RTNORM;
|
|
|
|
if (bNearWall && ssWall.Length()==1) {
|
|
Entity ent=ssWall[0L];
|
|
acdbGetObjectId(idRet, ent.name);
|
|
}
|
|
return idRet;
|
|
*/
|
|
#endif
|
|
}
|
|
|
|
// 为了绘制Osnap点而构造临时实体
|
|
class XDbOsnapPoint: public AcDbEntity {
|
|
public:
|
|
XPoint m_ptLoc;
|
|
int m_osShape;
|
|
|
|
bool m_bRectCursor;
|
|
XPoint m_ptBase;
|
|
public:
|
|
XDbOsnapPoint(): m_osShape(0), m_bRectCursor(false)
|
|
{}
|
|
Adesk::Boolean subWorldDraw(AcGiWorldDraw *mode);
|
|
void subViewportDraw(AcGiViewportDraw *mode);
|
|
};
|
|
|
|
|
|
Adesk::Boolean XDbOsnapPoint::subWorldDraw(AcGiWorldDraw *mode)
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
// 由于视窗的实体不能访问, 因此本函数目前没有使用
|
|
|
|
void XDbOsnapPoint::subViewportDraw(AcGiViewportDraw *mode)
|
|
{
|
|
if (m_bRectCursor) {
|
|
XRectAngle box(Wcs2Ucs(m_ptBase), Wcs2Ucs(m_ptLoc));
|
|
XPoly2D poly2d(1);
|
|
box.AsPoly2D(poly2d);
|
|
poly2d.TransUCS(Groups(1), Groups(0));
|
|
AcDbPolyline pline;
|
|
PolyConvert(poly2d, pline);
|
|
pline.viewportDraw(mode);
|
|
}
|
|
|
|
if (CDrawWallDlg::g_bAutoSnap)
|
|
DrawOsnapShape(mode, m_ptLoc, m_osShape);
|
|
}
|
|
|
|
|
|
// 拖曳显示点
|
|
class XOsPointEdJig : public AcEdJig
|
|
{
|
|
public:
|
|
XOsPointEdJig();
|
|
virtual ~XOsPointEdJig();
|
|
void doIt();
|
|
virtual DragStatus sampler();
|
|
virtual Adesk::Boolean update();
|
|
virtual AcDbEntity* entity() const;
|
|
|
|
int GetRetCode(int *kwordId=NULL) const;
|
|
int m_nRetCode; //返回码
|
|
const TCHAR *m_pszPrompt; //提示信息
|
|
const TCHAR *m_pszKeyword; //关键字
|
|
XDbOsnapPoint *m_pDrawEnt; //临时实体
|
|
|
|
XPoint m_ptFrom, m_ptTo;
|
|
int m_osShape;
|
|
int m_nUsageFlag; //0--不带橡皮巾; 1--待橡皮巾; 2--矩形拖曳
|
|
};
|
|
|
|
|
|
|
|
// 转换成ADS代码
|
|
int XOsPointEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if (ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret <= 0)
|
|
ret = RTNORM;
|
|
else {
|
|
if (kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
XOsPointEdJig::XOsPointEdJig()
|
|
:m_pszKeyword(NULL), m_pszPrompt(NULL), m_pDrawEnt(NULL),
|
|
m_nRetCode(0), m_osShape(0), m_nUsageFlag(0)
|
|
{
|
|
}
|
|
|
|
XOsPointEdJig::~XOsPointEdJig()
|
|
{
|
|
if (m_pDrawEnt) delete m_pDrawEnt;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
void XOsPointEdJig::doIt()
|
|
{
|
|
m_pDrawEnt = new XDbOsnapPoint;
|
|
m_pDrawEnt->m_osShape=AsOsnapMask(m_osShape);
|
|
m_pDrawEnt->m_ptLoc = m_ptTo;
|
|
m_pDrawEnt->m_bRectCursor = (m_nUsageFlag==2);
|
|
m_pDrawEnt->m_ptBase=m_ptFrom;
|
|
|
|
setDispPrompt(m_pszPrompt);
|
|
if (m_nUsageFlag==2)
|
|
setSpecialCursorType(AcEdJig::kNoSpecialCursor);
|
|
if (m_pszKeyword) {
|
|
INITGET_BEG(-1, m_pszKeyword);
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
INITGET_END();
|
|
} else {
|
|
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus XOsPointEdJig::sampler()
|
|
{
|
|
DragStatus stat;
|
|
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted
|
|
| AcEdJig::kNoNegativeResponseAccepted
|
|
| AcEdJig::kNoZeroResponseAccepted));
|
|
|
|
if (m_pszKeyword) setKeywordList(m_pszKeyword);
|
|
XPoint ptTemp;
|
|
XPoint *ptBase=NULL;
|
|
if (m_nUsageFlag==2) {
|
|
setSpecialCursorType(AcEdJig::kNoSpecialCursor);
|
|
stat = acquirePoint(ptTemp, m_ptFrom);
|
|
ptBase=&m_ptFrom;
|
|
} else if (m_nUsageFlag==1) {
|
|
stat = acquirePoint(ptTemp, m_ptFrom);
|
|
ptBase=&m_ptFrom;
|
|
} else {
|
|
stat = acquirePoint(ptTemp);
|
|
}
|
|
if (stat == AcEdJig::kNormal) {
|
|
m_osShape=CDrawWallDlg::g_bAutoSnap? AutoSnapWall(ptTemp, ptBase) : 0;
|
|
if (ads_distance(ptTemp, m_ptTo)>_DIST_SNAP) {
|
|
m_ptTo=ptTemp;
|
|
}
|
|
else
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean XOsPointEdJig::update()
|
|
{
|
|
if (!(m_pDrawEnt->m_ptLoc == m_ptTo)) {
|
|
m_pDrawEnt->m_ptLoc = m_ptTo;
|
|
m_pDrawEnt->m_osShape = AsOsnapMask(m_osShape);
|
|
m_pDrawEnt->m_bRectCursor = (m_nUsageFlag==2);
|
|
m_pDrawEnt->m_ptBase=m_ptFrom;
|
|
}
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* XOsPointEdJig::entity() const
|
|
{
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////
|
|
// 为了拖曳墙体和绘制Osnap点而构造临时实体
|
|
class TDbWallOsnapPoint: public TDbWall {
|
|
public:
|
|
XPoint m_ptLoc;
|
|
int m_osShape;
|
|
public:
|
|
TDbWallOsnapPoint(): m_osShape(0)
|
|
{}
|
|
Adesk::Boolean subWorldDraw(AcGiWorldDraw *mode);
|
|
void subViewportDraw(AcGiViewportDraw *mode);
|
|
};
|
|
|
|
|
|
Adesk::Boolean TDbWallOsnapPoint::subWorldDraw(AcGiWorldDraw *mode)
|
|
{
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
|
|
void TDbWallOsnapPoint::subViewportDraw(AcGiViewportDraw *mode)
|
|
{
|
|
TDbWall::subViewportDraw(mode);
|
|
if (CDrawWallDlg::g_bAutoSnap)
|
|
DrawOsnapShape(mode, m_ptLoc, m_osShape);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////
|
|
// 拖曳墙体, 并确定半径或者顶点
|
|
class XDrawWallEdJig : public TEdJig
|
|
{
|
|
public:
|
|
XDrawWallEdJig(CDrawWallDlg *pDlg);
|
|
virtual ~XDrawWallEdJig();
|
|
void doIt();
|
|
virtual DragStatus sampler();
|
|
virtual Adesk::Boolean Update();
|
|
virtual AcDbEntity* entity() const;
|
|
|
|
#if ADS>15
|
|
virtual void CreateGrip();
|
|
virtual Acad::ErrorStatus EntityToDim(long iGrip,long iDim);
|
|
virtual Acad::ErrorStatus DimToEntity(long iGrip,long iDim,double newValue);
|
|
#endif
|
|
|
|
int GetRetCode(int *kwordId=NULL) const;
|
|
|
|
int m_nRetCode; //返回码
|
|
const TCHAR *m_pszPrompt; //提示信息
|
|
const TCHAR *m_pszKeyword; //关键字
|
|
TDbWallOsnapPoint *m_pDrawEnt; //临时实体
|
|
|
|
int m_osShape; //捕捉性质
|
|
|
|
XPoint m_ptStart, m_ptEnd, m_ptAny;
|
|
double m_nRadius;
|
|
|
|
|
|
//控制方案
|
|
//int m_bIsDouble; //是否为双线
|
|
|
|
// 0--已知起点, 待定终点
|
|
// 1--已知起点,弧上任意点,待定终点
|
|
// 2--已知起点终点, 待定弧上一点
|
|
// 3--已知起点终点, 待定半径
|
|
int m_nFlag;
|
|
CDrawWallDlg *m_pDlg;
|
|
};
|
|
/* ========================================================== */
|
|
#if ADS>15
|
|
void XDrawWallEdJig::CreateGrip()
|
|
{
|
|
SetGripNum(2);
|
|
|
|
//直墙
|
|
GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));
|
|
GetGrip(0)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));
|
|
|
|
//弧墙
|
|
GetGrip(1)->AppendDim(new TDbGripRadiusDim(AcDbDimData::kDimRadius));
|
|
GetGrip(1)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));
|
|
}
|
|
Acad::ErrorStatus XDrawWallEdJig::EntityToDim(long iGrip,long iDim)
|
|
{
|
|
TDbGripDim*pDim=GetGripDim(iGrip,iDim);
|
|
if (pDim==NULL)
|
|
return Acad::eInvalidInput;
|
|
|
|
TDbWall*pWall=m_pDrawEnt;
|
|
double dist=5000;
|
|
switch(iGrip)
|
|
{
|
|
case 0://直墙终点
|
|
switch(iDim)
|
|
{
|
|
case 0://长度
|
|
{
|
|
TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
|
|
pDistDim->SetData(pWall->EndPoint().AsAcGePoint3d(),pWall->StartPoint().AsAcGePoint3d(),dist);
|
|
}
|
|
break;
|
|
case 1://角度
|
|
{
|
|
TDbGripAngleDim*pAngleDim=(TDbGripAngleDim*)pDim;
|
|
XPoint ptEnd=pWall->StartPoint()+XPoint(1000,0,0);
|
|
pAngleDim->SetData(pWall->StartPoint().AsAcGePoint3d(),pWall->EndPoint().AsAcGePoint3d(),ptEnd.AsAcGePoint3d());
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
case 1://中点
|
|
switch(iDim)
|
|
{
|
|
case 0://半径
|
|
{
|
|
TDbGripRadiusDim*pRadiusDim=(TDbGripRadiusDim*)pDim;
|
|
pRadiusDim->SetData(pWall->GetArc().GetCenterPt().AsAcGePoint3d(),pWall->MidPoint().AsAcGePoint3d());
|
|
}
|
|
break;
|
|
case 1://包络角
|
|
{
|
|
TDbGripAngleDim*pAngleDim=(TDbGripAngleDim*)pDim;
|
|
pAngleDim->SetData(*pWall);
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
Acad::ErrorStatus XDrawWallEdJig::DimToEntity(long iGrip,long iDim,double newValue)
|
|
{
|
|
XPoint vt=m_pDrawEnt->EndPoint()-m_pDrawEnt->StartPoint();
|
|
vt.Normalize();
|
|
|
|
switch(iGrip)
|
|
{
|
|
case 0://终点
|
|
switch(iDim)
|
|
{
|
|
case 0://长度
|
|
if (newValue>1E-6)
|
|
{
|
|
vt*=newValue;
|
|
m_ptEnd=m_pDrawEnt->EndPoint()=m_pDrawEnt->StartPoint()+vt;
|
|
}
|
|
break;
|
|
case 1://角度
|
|
{
|
|
if (vt.y<0)
|
|
newValue*=-1;
|
|
XPoint vt2(m_pDrawEnt->GetLength(),0,0);
|
|
vt2.Rotate(newValue);
|
|
m_ptEnd=m_pDrawEnt->EndPoint()=m_pDrawEnt->StartPoint()+vt2;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
case 1://中点
|
|
switch(iDim)
|
|
{
|
|
case 0://半径
|
|
{
|
|
XCurveSegment line(m_pDrawEnt->StartPoint(),m_pDrawEnt->EndPoint(),0);
|
|
double len=line.GetLength();
|
|
double as=len*0.5/newValue;
|
|
if (as>1)
|
|
return Acad::eInvalidInput;
|
|
newValue=2*asin(as);
|
|
}
|
|
case 1://包络角
|
|
{
|
|
m_pDrawEnt->SetBulge(CT_std_angle(newValue));
|
|
m_ptAny=m_pDrawEnt->MidPoint();
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
#endif;
|
|
// 转换成ADS代码
|
|
int XDrawWallEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if (ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret <= 0)
|
|
ret = RTNORM;
|
|
else {
|
|
if (kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
XDrawWallEdJig::XDrawWallEdJig(CDrawWallDlg *pDlg)
|
|
:m_pDlg(pDlg), m_pszKeyword(NULL), m_pszPrompt(NULL), m_pDrawEnt(NULL), m_nRetCode(0), m_osShape(0)
|
|
{
|
|
#if ADS>15
|
|
CreateGrip();
|
|
#endif
|
|
}
|
|
|
|
XDrawWallEdJig::~XDrawWallEdJig()
|
|
{
|
|
if (m_pDrawEnt) delete m_pDrawEnt;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
void XDrawWallEdJig::doIt()
|
|
{
|
|
m_pDrawEnt = new TDbWallOsnapPoint;
|
|
m_pDrawEnt->StartPoint() = m_ptStart;
|
|
m_pDrawEnt->EndPoint() = m_ptEnd;
|
|
if (m_pDlg) {
|
|
m_pDrawEnt->SetWidth(0, m_pDlg->GetLeftWidth());
|
|
m_pDrawEnt->SetWidth(1, m_pDlg->GetRightWidth());
|
|
} else {
|
|
m_pDrawEnt->SetWidth(0, g_lWallWidth);
|
|
m_pDrawEnt->SetWidth(1, g_rWallWidth);
|
|
}
|
|
TDbWall::Catalog nCatalog;
|
|
m_pDrawEnt->setLayer(m_pDrawEnt->GetDefaultLayer());
|
|
if (m_pDlg==NULL||m_pDlg->GetUsage(nCatalog)!=TWallData::kVirtual)
|
|
m_pDrawEnt->SetUsageFlag(TWallData::kEdJig);
|
|
else
|
|
m_pDrawEnt->SetUsageFlag(TWallData::kVirtual);
|
|
|
|
// Osnap Point member
|
|
m_pDrawEnt->m_osShape=AsOsnapMask(m_osShape);
|
|
if (m_nFlag==0 || m_nFlag==1)
|
|
m_pDrawEnt->m_ptLoc = m_ptEnd;
|
|
else if (m_nFlag==2)
|
|
m_pDrawEnt->m_ptLoc = m_ptAny;
|
|
|
|
|
|
setDispPrompt(m_pszPrompt);
|
|
if (m_pszKeyword) {
|
|
INITGET_BEG(-1, m_pszKeyword);
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
INITGET_END();
|
|
} else {
|
|
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
} }
|
|
|
|
extern TARCH_IMPEXP void GetWallLengthModel(DList<double> &lstWidth);
|
|
extern TARCH_IMPEXP double GetModelNumber(DList<double> &lstModel, double nNearNumber);
|
|
// 反馈
|
|
AcEdJig::DragStatus XDrawWallEdJig::sampler()
|
|
{
|
|
DragStatus stat;
|
|
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted
|
|
| AcEdJig::kNoNegativeResponseAccepted
|
|
| AcEdJig::kNoZeroResponseAccepted));
|
|
|
|
if (m_pszKeyword) setKeywordList(m_pszKeyword);
|
|
XPoint ptTemp;
|
|
if (m_nFlag==0 || m_nFlag==1 || m_nFlag==2) {
|
|
stat = acquirePoint(ptTemp, m_ptStart);
|
|
if (stat == AcEdJig::kNormal) {
|
|
m_osShape=CDrawWallDlg::g_bAutoSnap? AutoSnapWall(ptTemp, &m_ptStart):0;
|
|
if (m_nFlag==0 || m_nFlag==1) { //求终点
|
|
if (m_pDrawEnt->Is(CURVE_LINE) && m_nFlag==0 && g_bModelNumber && !m_osShape) {
|
|
//模数打开
|
|
double nAng=ads_angle(m_ptStart, ptTemp);
|
|
double nSize; //=GetModelNumber(lstSize, );
|
|
nSize = AS_INT(ads_distance(m_ptStart, ptTemp)/g_nWallStep)*g_nWallStep;
|
|
if (nSize>0)
|
|
ads_polar(m_ptStart, nAng, nSize, ptTemp);
|
|
}
|
|
|
|
if (ads_distance(ptTemp, m_ptEnd)>_DIST_SNAP)
|
|
m_ptEnd=ptTemp;
|
|
else return AcEdJig::kNoChange;
|
|
} else if (m_nFlag==2) {
|
|
if (ptTemp.Distance(m_ptAny)>_DIST_SNAP)
|
|
m_ptAny=ptTemp;
|
|
else return AcEdJig::kNoChange;
|
|
}
|
|
}
|
|
} else if (m_nFlag==3) { //已知起点终点, 待定半径
|
|
double nTemp;
|
|
stat = acquireDist(nTemp, m_ptStart);
|
|
if (fabs(nTemp-m_nRadius)>_DIST_SNAP) {
|
|
m_nRadius=nTemp;
|
|
} else if (stat==AcEdJig::kNormal) {
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
}
|
|
|
|
|
|
return stat;
|
|
}
|
|
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean XDrawWallEdJig::Update()
|
|
{
|
|
extern TARCH_IMPEXP BOOL g_bRevWallFlag;
|
|
m_pDrawEnt->m_osShape = AsOsnapMask(m_osShape);
|
|
if (m_pDlg) {
|
|
m_pDrawEnt->SetWidth(0, m_pDlg->GetLeftWidth());
|
|
m_pDrawEnt->SetWidth(1, m_pDlg->GetRightWidth());
|
|
} else {
|
|
m_pDrawEnt->SetWidth(0, g_lWallWidth);
|
|
m_pDrawEnt->SetWidth(1, g_rWallWidth);
|
|
}
|
|
XCurveSegment seg;
|
|
if (m_nFlag==0) {
|
|
if (m_ptStart==m_ptEnd)
|
|
return Adesk::kFalse;
|
|
seg=XLine(m_ptStart, m_ptEnd);
|
|
m_pDrawEnt->m_ptLoc = m_ptEnd;
|
|
} else if (m_nFlag==1) {//已知起点,弧上任意点,待定终点
|
|
if (m_ptEnd==m_ptStart || m_ptEnd==m_ptAny)
|
|
return Adesk::kFalse;
|
|
seg=XArc(m_ptStart, m_ptAny, m_ptEnd);
|
|
m_pDrawEnt->m_ptLoc = m_ptEnd;
|
|
} else if (m_nFlag==2) { //已知起点终点, 待定弧上一点
|
|
if (m_ptAny==m_ptStart || m_ptEnd==m_ptAny ||
|
|
(m_ptAny&XLine(m_ptStart, m_ptEnd))!=PR_OUTSIDE)
|
|
return Adesk::kFalse;
|
|
seg=XArc(m_ptStart, m_ptAny, m_ptEnd);
|
|
if (seg.StartPoint().Distance(m_ptStart)>seg.StartPoint().Distance(m_ptEnd)) {
|
|
//m_pDrawEnt->SetWidth(0, g_rWallWidth);
|
|
//m_pDrawEnt->SetWidth(1, g_lWallWidth);
|
|
g_bRevWallFlag=TRUE;
|
|
double lWidth=m_pDrawEnt->GetWidth(0);
|
|
double rWidth=m_pDrawEnt->GetWidth(1);
|
|
m_pDrawEnt->SetWidth(0, rWidth);
|
|
m_pDrawEnt->SetWidth(1, lWidth);
|
|
} else {
|
|
//m_pDrawEnt->SetWidth(0, g_lWallWidth);
|
|
//m_pDrawEnt->SetWidth(1, g_rWallWidth);
|
|
g_bRevWallFlag=FALSE;
|
|
}
|
|
m_pDrawEnt->m_ptLoc = m_ptAny;
|
|
} else if (m_nFlag==3) {
|
|
double nChordLen=ads_distance(m_ptStart, m_ptEnd);
|
|
if (nChordLen<2.0*fabs(m_nRadius)-1.0E-6) {
|
|
double bulge=2.0*asin(nChordLen/2.0/m_nRadius);
|
|
seg=XDirectionCurve(m_ptStart, m_ptEnd, bulge, LS_FINITE).GetCurve();
|
|
if (seg.StartPoint().Distance(m_ptStart)>seg.StartPoint().Distance(m_ptEnd)) {
|
|
g_bRevWallFlag=TRUE;
|
|
double lWidth=m_pDrawEnt->GetWidth(0);
|
|
double rWidth=m_pDrawEnt->GetWidth(1);
|
|
m_pDrawEnt->SetWidth(0, rWidth);
|
|
m_pDrawEnt->SetWidth(1, lWidth);
|
|
} else {
|
|
//m_pDrawEnt->SetWidth(0, g_lWallWidth);
|
|
//m_pDrawEnt->SetWidth(1, g_rWallWidth);
|
|
}
|
|
} else {
|
|
return Adesk::kFalse;
|
|
}
|
|
} else {
|
|
return Adesk::kFalse;
|
|
}
|
|
*(XCurveSegment *)m_pDrawEnt = seg;
|
|
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* XDrawWallEdJig::entity() const
|
|
{
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
|
|
// 给定起点, 终点进行弧上一点拖动绘制弧
|
|
int DragDrawArc_SEP(CDrawWallDlg *pDlg, const XPoint &ptStart, const XPoint &ptEnd, const TCHAR *prompt, XPoint &ptAny, const TCHAR *kword, int *kwordId)
|
|
{
|
|
XDrawWallEdJig jig(pDlg);
|
|
#if ADS>15
|
|
jig.SetCurGrip(1);
|
|
#endif
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptStart = ptStart;
|
|
jig.m_ptEnd=ptEnd;
|
|
Midpoint(ptStart, ptEnd, jig.m_ptAny);
|
|
//jig.m_bIsDouble = bDouble;
|
|
jig.m_nFlag=2;
|
|
LAB_REPEAT:
|
|
jig.doIt();
|
|
int nRetCode=jig.GetRetCode(kwordId);
|
|
if (nRetCode==RTNORM && (jig.m_ptAny&XLine(ptStart, ptEnd))!=PR_OUTSIDE)
|
|
goto LAB_REPEAT;
|
|
if (nRetCode==RTNORM)
|
|
ptAny = jig.m_ptAny;
|
|
return nRetCode;
|
|
}
|
|
|
|
|
|
// 给定起点, 弧上一点, 进行终点拖动绘制弧
|
|
int DragDrawArc_SPE(CDrawWallDlg * pDlg, const XPoint &ptStart, const XPoint &ptAny, const TCHAR *prompt, XPoint &ptEnd, const TCHAR *kword, int *kwordId)
|
|
{
|
|
XDrawWallEdJig jig(pDlg);
|
|
#if ADS>15
|
|
jig.SetCurGrip(-1);
|
|
#endif
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptStart = ptStart;
|
|
jig.m_ptAny=ptAny;
|
|
//jig.m_bIsDouble = bDouble;
|
|
jig.m_nFlag=1;
|
|
|
|
jig.doIt();
|
|
int nRetCode=jig.GetRetCode(kwordId);
|
|
if (nRetCode==RTNORM)
|
|
ptEnd = jig.m_ptEnd;
|
|
return nRetCode;
|
|
}
|
|
|
|
|
|
// 给定起点, 终点进行拖动半径绘制弧
|
|
int DragDrawArc_SER(CDrawWallDlg *pDlg, const XPoint &ptStart, const XPoint &ptEnd, const TCHAR *prompt, double *nRadius, const TCHAR *kword, int *kwordId)
|
|
{
|
|
XDrawWallEdJig jig(pDlg);
|
|
#if ADS>15
|
|
jig.SetCurGrip(-1);
|
|
#endif
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptStart = ptStart;
|
|
jig.m_ptEnd=ptEnd;
|
|
//jig.m_bIsDouble = bDouble;
|
|
jig.m_nFlag=3;
|
|
jig.doIt();
|
|
|
|
int nRetCode=jig.GetRetCode(kwordId);
|
|
if (nRetCode==RTNORM)
|
|
*nRadius = jig.m_nRadius;
|
|
return nRetCode;
|
|
}
|
|
|
|
|
|
// 给定起点, 终点进行拖动半径绘制弧
|
|
int DragDrawLine(CDrawWallDlg *pDlg, XPoint &ptStart, const TCHAR *prompt, XPoint &ptEnd, const TCHAR *kword, int *kwordId, BOOL *bDiscontinue)
|
|
{
|
|
XDrawWallEdJig jig(pDlg);
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptStart = ptStart;
|
|
xg_getvar(_T("LASTPOINT"), jig.m_ptEnd);
|
|
jig.m_ptEnd=Ucs2Wcs(jig.m_ptEnd);
|
|
//jig.m_bIsDouble = bDouble;
|
|
jig.m_nFlag=0;
|
|
jig.doIt();
|
|
|
|
int nRetCode=jig.GetRetCode(kwordId);
|
|
if (nRetCode==RTNORM) {
|
|
ptEnd = jig.m_ptEnd;
|
|
if (bDiscontinue)
|
|
*bDiscontinue=IsOnWallBase(ptEnd);
|
|
}
|
|
return nRetCode;
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
// 获取输入点, 自动对墙体/轴线进行模糊捕捉
|
|
int OsGetPointWall(double *ptFrom, const TCHAR *prompt, XPoint &pt, const TCHAR *kword=NULL, int *kwordId=NULL, BOOL *bDiscontinue=NULL)
|
|
{
|
|
XOsPointEdJig jig;
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptTo = pt;
|
|
jig.m_osShape=0;
|
|
jig.m_nUsageFlag=ptFrom!=NULL;
|
|
if (ptFrom)
|
|
jig.m_ptFrom = ptFrom;
|
|
jig.doIt();
|
|
|
|
int nKeyword;
|
|
int & kid=kwordId? *kwordId : nKeyword;
|
|
int nRetCode=jig.GetRetCode(&kid);
|
|
if (nRetCode==RTNORM) {
|
|
pt = jig.m_ptTo;
|
|
if (bDiscontinue)
|
|
*bDiscontinue=IsOnWallBase(pt);
|
|
}
|
|
return nRetCode;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
// 获取输入点, 自动对墙体/轴线进行模糊捕捉
|
|
int OsGetCornerWall(double *ptFrom, const TCHAR *prompt, XPoint &pt, const TCHAR *kword=NULL, int *kwordId=NULL)
|
|
{
|
|
XPushVar<int> vOrthoMode(_T("ORTHOMODE"), 0);
|
|
ASSERT(ptFrom);
|
|
XOsPointEdJig jig;
|
|
jig.m_pszKeyword = kword;
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_ptTo = pt;
|
|
jig.m_osShape=0;
|
|
jig.m_nUsageFlag=2;
|
|
jig.m_ptFrom = ptFrom;
|
|
jig.doIt();
|
|
|
|
int nKeyword;
|
|
int & kid=kwordId? *kwordId : nKeyword;
|
|
int nRetCode=jig.GetRetCode(&kid);
|
|
if (nRetCode==RTNORM)
|
|
pt = jig.m_ptTo;
|
|
return nRetCode;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// 门窗的绘制
|
|
|
|
/////////////////////////////////////////////////////
|
|
// 为了拖曳门窗和绘制Osnap点而构造临时实体
|
|
|
|
class TDbOpeningJig:public AcDbEntity
|
|
{
|
|
public:
|
|
TDbOpening *m_pOpening;
|
|
public:
|
|
TDbOpeningJig() {m_pOpening=NULL;}
|
|
~TDbOpeningJig()
|
|
{
|
|
if (m_pOpening!=NULL)
|
|
delete m_pOpening;
|
|
}
|
|
void SetOpening(TDbOpening*pOpening)
|
|
{
|
|
if (m_pOpening!=NULL)
|
|
delete m_pOpening;
|
|
m_pOpening=(TDbOpening*)pOpening->clone();
|
|
m_pOpening->InitHardPointerId();
|
|
|
|
// add by xly on 1103302设置转角布局
|
|
m_pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
TMasterProperties prop;
|
|
prop.SetFrom(pOpening);
|
|
prop.SetTo(this);
|
|
}
|
|
Adesk::Boolean subWorldDraw(AcGiWorldDraw *mode);
|
|
void subViewportDraw(AcGiViewportDraw *mode);
|
|
void SetParameters(const TDbWall *pWall, const XPoint &ptOnWall, const XPoint &ptQuadrant, UINT nInsMode);
|
|
};
|
|
|
|
void TDbOpeningJig::SetParameters(const TDbWall *pWall, const XPoint &ptOnWall, const XPoint &ptQuadrant, UINT nInsMode)
|
|
{
|
|
//SHORT nShiftState=GetKeyState(VK_SHIFT);
|
|
BOOL bShiftPressed = g_bShiftToggle; //(nShiftState&256)!=0;
|
|
|
|
XPoint ptLoc;
|
|
pWall->GetOpeningLocation(ptOnWall, m_pOpening->GetKind(), m_pOpening->GetWidth(), ptLoc);
|
|
ptLoc.z = m_pOpening->GetLocation().z;
|
|
m_pOpening->SetLocation(ptLoc);
|
|
|
|
// add by xly on 110216 8.5需求修改矩形洞，增加是否穿透墙体设置
|
|
//m_pOpening->SetThickness(m_pOpening->GetKind()==TOpeningData::OP_HOLE? pWall->GetWidth() : pWall->GetWidth()/2.0);
|
|
if (m_pOpening->GetKind()==TOpeningData::OP_HOLE)
|
|
{
|
|
m_pOpening->SetThickness(m_pOpening->GetThickness());
|
|
}
|
|
else
|
|
{
|
|
m_pOpening->SetThickness(pWall->GetWidth()/2.0);
|
|
}
|
|
m_pOpening->SetRotation(pWall->Direction(ptOnWall));
|
|
if (m_pOpening->isKindOf(TDbGroupOpening::desc()))
|
|
{
|
|
((TDbGroupOpening*)m_pOpening)->Update(false);
|
|
}
|
|
|
|
ads_real nAng=CT_std_angle(ads_angle(m_pOpening->GetLocation(), ptQuadrant)-m_pOpening->GetRotation());
|
|
if (nAng>=0.0 && nAng<PI) m_pOpening->SetQuadrant(bShiftPressed? 1:0);
|
|
else m_pOpening->SetQuadrant(bShiftPressed? 2:3);
|
|
|
|
m_pOpening->SetLabelPos(m_pOpening->GetDefaultLabPos());
|
|
}
|
|
|
|
|
|
Adesk::Boolean TDbOpeningJig::subWorldDraw(AcGiWorldDraw *mode)
|
|
{
|
|
if (!m_pOpening->GetWallId())
|
|
return Adesk::kTrue; //Draw nothing
|
|
|
|
return Adesk::kFalse;;
|
|
}
|
|
|
|
|
|
void TDbOpeningJig::subViewportDraw(AcGiViewportDraw *mode)
|
|
{
|
|
// modify by xly on 110217 增加同时绘制多个门窗时提供预览
|
|
//m_pOpening->subViewportDraw(mode);
|
|
//DrawOsnapShape(mode, m_pOpening->GetLocation(), AcDb::kOsMaskNear);
|
|
int nNums = CInsertOpeningDlg::g_pCurDlg->GetOpeningNums();
|
|
if (CInsertOpeningDlg::g_nInsertMode==7)
|
|
{
|
|
nNums = 1;
|
|
}
|
|
if (nNums>1)
|
|
{
|
|
XPoint ptLoc = m_pOpening->GetLocation(),
|
|
ptPos;
|
|
double dWidth = m_pOpening->GetWidth();
|
|
double dAngle = m_pOpening->GetRotation();
|
|
double dDist(0.0);
|
|
if (nNums%2 == 0)// 偶数个门
|
|
{
|
|
for (int i=0; i<nNums; i++)
|
|
{
|
|
if (i==0)
|
|
{
|
|
dDist += dWidth/2.0;
|
|
}
|
|
else if (i%2 == 0)
|
|
{
|
|
dDist += dWidth;
|
|
}
|
|
ads_polar(ptLoc,dAngle,dDist,ptPos);
|
|
TDbOpening *pOpening = (TDbOpening*)m_pOpening->clone();
|
|
pOpening->SetLocation(ptPos);
|
|
pOpening->m_ptLabel=pOpening->GetDefaultLabPos();
|
|
pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
pOpening->subViewportDraw(mode);
|
|
dAngle = PI+dAngle;
|
|
}
|
|
}
|
|
else// 奇数个门
|
|
{
|
|
m_pOpening->subViewportDraw(mode);
|
|
for (int i=1; i<nNums; i++)
|
|
{
|
|
if (i%2 != 0)
|
|
{
|
|
dDist += dWidth;
|
|
}
|
|
ads_polar(ptLoc,dAngle,dDist,ptPos);
|
|
TDbOpening *pOpening = (TDbOpening*)m_pOpening->clone();
|
|
pOpening->SetLocation(ptPos);
|
|
pOpening->m_ptLabel=pOpening->GetDefaultLabPos();
|
|
pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
pOpening->subViewportDraw(mode);
|
|
dAngle = PI+dAngle;
|
|
}
|
|
}
|
|
DrawOsnapShape(mode, ptLoc, AcDb::kOsMaskNear);
|
|
}
|
|
else
|
|
{
|
|
m_pOpening->subViewportDraw(mode);
|
|
DrawOsnapShape(mode, m_pOpening->GetLocation(), AcDb::kOsMaskNear);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
// 拖曳墙体, 并确定半径或者顶点
|
|
class XDrawOpeningEdJig : public TEdJig //modified by whl
|
|
{
|
|
public:
|
|
XDrawOpeningEdJig(TDbOpening*pOpening);
|
|
virtual ~XDrawOpeningEdJig();
|
|
void doIt();
|
|
virtual DragStatus sampler();
|
|
virtual Adesk::Boolean Update();
|
|
virtual AcDbEntity* entity() const;
|
|
|
|
#if ADS>15
|
|
virtual void CreateGrip();
|
|
virtual Acad::ErrorStatus EntityToDim(long iGrip,long iDim);
|
|
virtual Acad::ErrorStatus DimToEntity(long iGrip,long iDim,double newValue);
|
|
#endif
|
|
|
|
int GetRetCode(int *kwordId=NULL) const;
|
|
|
|
XPoint m_ptCursor, m_ptOnWall;
|
|
AcDbObjectId m_idWall;
|
|
int m_nRetCode; //返回码
|
|
const TCHAR *m_pszPrompt; //提示信息
|
|
const TCHAR *m_pszKeyword; //关键字
|
|
TDbOpeningJig *m_pDrawEnt; //临时实体
|
|
//CInsertOpeningDlg *m_pDataDlg; replaced by CInsertOpeningDlg::g_pCurDlg
|
|
};
|
|
/* ========================================================== */
|
|
#if ADS>15
|
|
void XDrawOpeningEdJig::CreateGrip()
|
|
{
|
|
SetGripNum(1);
|
|
GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength));//前垛距
|
|
GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength));//后垛距
|
|
}
|
|
Acad::ErrorStatus XDrawOpeningEdJig::EntityToDim(long iGrip,long iDim)
|
|
{
|
|
TDbOpeningJig *pEnt=m_pDrawEnt;
|
|
XCurveSegment wall;
|
|
if (!pEnt->m_pOpening->GetCenterCurve(wall))//中线
|
|
return Acad::eInvalidInput;
|
|
|
|
TDbGripDim*pDim=GetGripDim(iGrip,iDim);
|
|
if (pDim==NULL)
|
|
return Acad::eInvalidInput;
|
|
switch(iGrip)
|
|
{
|
|
case 0:
|
|
switch(iDim)
|
|
{
|
|
case 0://前垛距
|
|
{
|
|
XCurveSegment seg;
|
|
TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
|
|
XPoint pt;
|
|
if (pEnt->m_pOpening->GetNeighbourPoint(pt,true))
|
|
{
|
|
XPoint ptSideStart,ptSideEnd;
|
|
pEnt->m_pOpening->GetSidePoints(ptSideStart, ptSideEnd);
|
|
wall.ProjectToMe(pt,pt);
|
|
wall.ProjectToMe(ptSideStart,ptSideStart);
|
|
pDistDim->SetData(pt.AsAcGePoint3d(),ptSideStart.AsAcGePoint3d(),1200);
|
|
}
|
|
}
|
|
break;
|
|
case 1://后垛距
|
|
{
|
|
XCurveSegment seg;
|
|
TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
|
|
XPoint pt;
|
|
if (pEnt->m_pOpening->GetNeighbourPoint(pt,false))
|
|
{
|
|
XPoint ptSideStart,ptSideEnd;
|
|
pEnt->m_pOpening->GetSidePoints(ptSideStart, ptSideEnd);
|
|
wall.ProjectToMe(pt,pt);
|
|
wall.ProjectToMe(ptSideEnd,ptSideEnd);
|
|
pDistDim->SetData(ptSideEnd.AsAcGePoint3d(),pt.AsAcGePoint3d(),1200);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
Acad::ErrorStatus XDrawOpeningEdJig::DimToEntity(long iGrip,long iDim,double newValue)
|
|
{
|
|
XCurveSegment wall;
|
|
m_pDrawEnt->m_pOpening->GetCenterCurve(wall);
|
|
XPoint vt=wall.EndPoint()-wall.StartPoint();
|
|
vt.Normalize();
|
|
switch(iGrip)
|
|
{
|
|
case 0:
|
|
switch(iDim)
|
|
{
|
|
case 0://后垛距
|
|
{
|
|
XCurveSegment seg;
|
|
XPoint pt,pt1,pt2;
|
|
m_pDrawEnt->m_pOpening->GetNeighbourPoint(pt,true);
|
|
wall.ProjectToMe(pt,pt);
|
|
m_pDrawEnt->m_pOpening->GetSidePoints(pt1,pt2);
|
|
double oldValue=pt.Distance2d(pt1.AsAcGePoint3d());
|
|
vt*=(newValue-oldValue);
|
|
m_pDrawEnt->m_pOpening->SetLocation(m_pDrawEnt->m_pOpening->GetLocation()+vt);
|
|
m_pDrawEnt->m_pOpening->SetLabelPos(m_pDrawEnt->m_pOpening->GetDefaultLabPos());//add by whl on 060301
|
|
}
|
|
break;
|
|
case 1://后垛距
|
|
{
|
|
XCurveSegment seg;
|
|
XPoint pt,pt1,pt2;
|
|
m_pDrawEnt->m_pOpening->GetNeighbourPoint(pt,false);
|
|
wall.ProjectToMe(pt,pt);
|
|
m_pDrawEnt->m_pOpening->GetSidePoints(pt1,pt2);
|
|
double oldValue=pt.Distance2d(pt2.AsAcGePoint3d());
|
|
vt*=(oldValue-newValue);
|
|
m_pDrawEnt->m_pOpening->SetLocation(m_pDrawEnt->m_pOpening->GetLocation()+vt);
|
|
m_pDrawEnt->m_pOpening->SetLabelPos(m_pDrawEnt->m_pOpening->GetDefaultLabPos());//add by whl on 060301
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
// 转换成ADS代码
|
|
int XDrawOpeningEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if (ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret <= 0)
|
|
ret = RTNORM;
|
|
else {
|
|
if (kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
XDrawOpeningEdJig::XDrawOpeningEdJig(TDbOpening*pOpening)//modified by whl
|
|
:m_pszKeyword(NULL), m_pszPrompt(NULL), m_pDrawEnt(NULL), m_nRetCode(0)//,m_pDataDlg(NULL)
|
|
{
|
|
m_pDrawEnt = new TDbOpeningJig;
|
|
m_pDrawEnt->SetOpening(pOpening);
|
|
#if ADS>15
|
|
CreateGrip();
|
|
#endif
|
|
}
|
|
|
|
XDrawOpeningEdJig::~XDrawOpeningEdJig()
|
|
{
|
|
if (m_pDrawEnt)
|
|
delete m_pDrawEnt;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
void XDrawOpeningEdJig::doIt()
|
|
{
|
|
m_pDrawEnt->m_pOpening->setLayer(m_pDrawEnt->m_pOpening->GetDefaultLayer());
|
|
setDispPrompt(m_pszPrompt);
|
|
if (m_pszKeyword) {
|
|
INITGET_BEG(-1, m_pszKeyword);
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
INITGET_END();
|
|
} else {
|
|
try {
|
|
m_nRetCode = drag();
|
|
} catch(...) {
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus XDrawOpeningEdJig::sampler()//modified by whl
|
|
{
|
|
double nIncStep=g_nWinStep;
|
|
DragStatus stat;
|
|
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted
|
|
| AcEdJig::kNoNegativeResponseAccepted
|
|
| AcEdJig::kNoZeroResponseAccepted));
|
|
|
|
if (m_pszKeyword) setKeywordList(m_pszKeyword);
|
|
XPoint ptTemp;
|
|
stat = acquirePoint(ptTemp);
|
|
if (stat == AcEdJig::kNormal) {
|
|
if (ptTemp.Distance(m_ptCursor)>_DIST_SNAP) {
|
|
m_ptCursor=ptTemp;
|
|
m_idWall=SnapOnWall(ptTemp);
|
|
if (!!m_idWall) {
|
|
OPENOBJ_BEGIN(m_idWall, AcDb::kForRead, TDbWall, pWall);
|
|
ASSERT(pWall);
|
|
if (pWall->Is(CURVE_LINE) && m_pDrawEnt->m_pOpening->GetKind()==TOpeningData::OP_ARCWIN)
|
|
return AcEdJig::kNoChange;
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
m_ptOnWall=ptTemp;
|
|
if (!!m_idWall && g_bModelNumber && CInsertOpeningDlg::g_pCurDlg->GetInsertMode()==ID_FREE_INSERT) {
|
|
OPENOBJ_BEGIN(m_idWall, AcDb::kForRead, TDbWall, pWall);
|
|
ASSERT(pWall);
|
|
XPoly2D poly(0);
|
|
if (pWall->GetKey3Seg(m_ptOnWall, m_pDrawEnt->m_pOpening->GetWidth(), poly)) {
|
|
ASSERT(poly.TotalSegments()==3);
|
|
XCurveSegment segFirst, segMid, segLast;
|
|
poly.Nth(0, segFirst);
|
|
poly.Nth(1, segMid);
|
|
poly.Nth(2, segLast);
|
|
SHORT nControlState=g_bCtrlToggle; //GetKeyState(VK_CONTROL);
|
|
bool bCtrlPressed = (nControlState&256)!=0;
|
|
if (!bCtrlPressed) {
|
|
double nModelFirst=AS_INT(segFirst.GetLength()/nIncStep)*nIncStep;
|
|
double nDistPos=segMid.GetLength()/2.0 + nModelFirst - segFirst.GetLength();
|
|
if (nDistPos>=0 && nDistPos<=segMid.GetLength()) {
|
|
XPointDir2d ptNewPos;
|
|
segMid.Polar(nDistPos, ptNewPos);
|
|
m_ptOnWall=ptNewPos;
|
|
}
|
|
} else {
|
|
double nModelLast=AS_INT(segLast.GetLength()/nIncStep)*nIncStep;
|
|
double nDistPos=segMid.GetLength()/2.0 + nModelLast - segLast.GetLength();
|
|
if (nDistPos>=0 && nDistPos<=segMid.GetLength()) {
|
|
XPointDir2d ptNewPos;
|
|
segMid.Polar(nDistPos, ptNewPos, FALSE);
|
|
m_ptOnWall=ptNewPos;
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
} else {
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean XDrawOpeningEdJig::Update()//modidfied by whl
|
|
{
|
|
//add by whl
|
|
if (CInsertOpeningDlg::g_pCurDlg!=NULL&&
|
|
CInsertOpeningDlg::g_pCurDlg->IsWindowVisible())
|
|
{
|
|
TDbOpening*pOpening=CInsertOpeningDlg::g_pCurDlg->NewOpening();
|
|
m_pDrawEnt->SetOpening(pOpening);
|
|
delete pOpening;
|
|
}
|
|
|
|
if (!m_idWall) {
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
return Adesk::kTrue;
|
|
}
|
|
OPENOBJ_BEGIN(m_idWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall) {
|
|
if (m_pDrawEnt->m_pOpening->GetKind()==TOpeningData::OP_ARCWIN) {
|
|
if (pWall->Is(CURVE_ARC))
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
} else {
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
}
|
|
m_pDrawEnt->SetParameters(pWall, m_ptOnWall, m_ptCursor,
|
|
CInsertOpeningDlg::g_pCurDlg?CInsertOpeningDlg::g_pCurDlg->GetInsertMode():0);
|
|
}
|
|
OPENOBJ_END();
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* XDrawOpeningEdJig::entity() const
|
|
{
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
AcDbObjectId GetOpeingLocation(const TCHAR *prompt, TDbOpening *&pWin,bool bFreeInsert)//modified by whl
|
|
{
|
|
int nOsMode=0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode |= 0x4000;
|
|
XPushVar<int> osmode(_T("OSMODE"), nOsMode);
|
|
AcDbObjectId idWall;
|
|
|
|
XDrawOpeningEdJig jig(pWin);
|
|
#if ADS>15
|
|
if (!bFreeInsert)
|
|
jig.SetCurGrip(-1);
|
|
#endif
|
|
jig.m_pszPrompt = prompt;
|
|
|
|
LAB_REINPUT:
|
|
jig.doIt();
|
|
|
|
int kwordId;
|
|
int nRetCode=jig.GetRetCode(&kwordId);
|
|
if (nRetCode==RTNORM) {
|
|
idWall = jig.m_idWall;
|
|
if (!!idWall) {
|
|
delete pWin;
|
|
pWin=jig.m_pDrawEnt->m_pOpening;
|
|
jig.m_pDrawEnt->m_pOpening=NULL;
|
|
|
|
//成功的添加了门窗, 那么把最近一次的参数写入注册表
|
|
CInsertOpeningDlg::g_pCurDlg->UpdateOpening(*pWin, TRUE);
|
|
CInsertOpeningDlg::g_pCurDlg->WriteParamToRegistry();
|
|
CInsertOpeningDlg::g_pCurDlg->SetupLabelList();
|
|
} else {
|
|
goto LAB_REINPUT;
|
|
}
|
|
}
|
|
return idWall;
|
|
}
|
|
|
|
|
|
|
|
// add by lgy 20120521，为智能插入门窗jig时的临时实体
|
|
class TDbOpeningAptJig: public AcDbEntity
|
|
{
|
|
public:
|
|
// 门窗对象参数
|
|
TDbOpening *m_pOpening;
|
|
|
|
// 示意短线所用参数
|
|
XCurveSegment m_segWall;
|
|
double m_dWallWidth;
|
|
int m_nLineColor;
|
|
|
|
BOOL m_bShow;
|
|
|
|
public:
|
|
TDbOpeningAptJig()
|
|
{
|
|
m_pOpening = NULL;
|
|
m_bShow = FALSE;
|
|
m_dWallWidth = 0.0;
|
|
m_nLineColor = 6;
|
|
}
|
|
|
|
~TDbOpeningAptJig()
|
|
{
|
|
if (m_pOpening != NULL)
|
|
{
|
|
delete m_pOpening;
|
|
}
|
|
}
|
|
|
|
void SetOpening(TDbOpening *pOpening)
|
|
{
|
|
if (m_pOpening != NULL)
|
|
{
|
|
delete m_pOpening;
|
|
}
|
|
|
|
m_pOpening = (TDbOpening*)pOpening->clone();
|
|
m_pOpening->InitHardPointerId();
|
|
m_pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
m_pOpening->setLayer(m_pOpening->GetDefaultLayer());
|
|
|
|
TMasterProperties prop;
|
|
prop.SetFrom(pOpening);
|
|
prop.SetTo(this);
|
|
}
|
|
|
|
void SetOpeningParameters(const TDbWall *pWall, const XPoint &ptOnWall, const XPoint &ptQuadrant, UINT nInsMode);
|
|
void SetLineParameters(const AcDbObjectId &wallId, const XCurveSegment &cvSeg, int nColor);
|
|
|
|
public:
|
|
Adesk::Boolean subWorldDraw(AcGiWorldDraw *mode);
|
|
void subViewportDraw(AcGiViewportDraw *mode);
|
|
};
|
|
|
|
void TDbOpeningAptJig::SetLineParameters(const AcDbObjectId &wallId, const XCurveSegment &cvSeg, int nColor)
|
|
{
|
|
m_segWall = cvSeg;
|
|
m_nLineColor = nColor;
|
|
|
|
OPENOBJ_BEGIN(wallId, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
XCurveSegment segGeom;
|
|
segGeom = pWall->OffsetGeomCenter(LS_INFINITE, TRUE);
|
|
|
|
XPoint ptStart, ptEnd;
|
|
if (segGeom.ProjectToMe(cvSeg.StartPoint(), ptStart)==RTNORM &&
|
|
segGeom.ProjectToMe(cvSeg.EndPoint(), ptEnd)==RTNORM)
|
|
m_segWall.SetPoints(ptStart, ptEnd);
|
|
|
|
m_dWallWidth = pWall->GetWidth(4);
|
|
pWall->close();
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
|
|
void TDbOpeningAptJig::SetOpeningParameters(const TDbWall *pWall, const XPoint &ptOnWall, const XPoint &ptQuadrant, UINT nInsMode)
|
|
{
|
|
BOOL bShiftPressed = g_bShiftToggle;
|
|
|
|
XPoint ptLoc;
|
|
pWall->GetOpeningLocation(ptOnWall, m_pOpening->GetKind(), m_pOpening->GetWidth(), ptLoc);
|
|
ptLoc.z = m_pOpening->GetLocation().z;
|
|
m_pOpening->SetLocation(ptLoc);
|
|
|
|
if (m_pOpening->GetKind() == TOpeningData::OP_HOLE)
|
|
{
|
|
m_pOpening->SetThickness(m_pOpening->GetThickness());
|
|
}
|
|
else
|
|
{
|
|
m_pOpening->SetThickness(pWall->GetWidth()/2.0);
|
|
}
|
|
|
|
m_pOpening->SetRotation(pWall->Direction(ptOnWall));
|
|
if (m_pOpening->isKindOf(TDbGroupOpening::desc()))
|
|
{
|
|
((TDbGroupOpening*)m_pOpening)->Update(false);
|
|
}
|
|
|
|
ads_real nAng = CT_std_angle(ads_angle(m_pOpening->GetLocation(), ptQuadrant)-m_pOpening->GetRotation());
|
|
if (nAng>=0.0 && nAng<PI)
|
|
{
|
|
m_pOpening->SetQuadrant(bShiftPressed? 1:0);
|
|
}
|
|
else
|
|
{
|
|
m_pOpening->SetQuadrant(bShiftPressed? 2:3);
|
|
}
|
|
|
|
m_pOpening->SetLabelPos(m_pOpening->GetDefaultLabPos());
|
|
}
|
|
|
|
Adesk::Boolean TDbOpeningAptJig::subWorldDraw(AcGiWorldDraw *mode)
|
|
{
|
|
if (!m_pOpening->GetWallId())
|
|
{
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
if (m_bShow)
|
|
{
|
|
double dPLWidth = 0.5 * DocGetPScale(); // 默认50线宽
|
|
|
|
TADSGePointDir2d ptDir2d;
|
|
double dLen = m_segWall.GetLength();
|
|
m_segWall.Polar(dLen/3, ptDir2d);
|
|
|
|
XPoint ptTmp1, ptTmp2;
|
|
ptTmp1 = ptDir2d.AsAcGePoint3d();
|
|
|
|
AcDbPolyline pline1, pline2;
|
|
ads_polar(ptTmp1, ptDir2d.nDirection+PI/2, m_dWallWidth*1.5, ptTmp2);
|
|
pline1.addVertexAt(0, ptTmp2.AsAcGePoint2d(), 0, dPLWidth, dPLWidth);
|
|
ads_polar(ptTmp1, ptDir2d.nDirection-PI/2, m_dWallWidth*1.5, ptTmp2);
|
|
pline1.addVertexAt(1, ptTmp2.AsAcGePoint2d(), 0, dPLWidth, dPLWidth);
|
|
|
|
m_segWall.Polar(dLen*2/3, ptDir2d);
|
|
ptTmp1 = ptDir2d.AsAcGePoint3d();
|
|
|
|
ads_polar(ptTmp1, ptDir2d.nDirection+PI/2, m_dWallWidth*1.5, ptTmp2);
|
|
pline2.addVertexAt(0, ptTmp2.AsAcGePoint2d(), 0, dPLWidth, dPLWidth);
|
|
ads_polar(ptTmp1, ptDir2d.nDirection-PI/2, m_dWallWidth*1.5, ptTmp2);
|
|
pline2.addVertexAt(1, ptTmp2.AsAcGePoint2d(), 0, dPLWidth, dPLWidth);
|
|
|
|
int nColor = colorIndex(); // 门窗的颜色
|
|
mode->subEntityTraits().setColor(m_nLineColor);
|
|
mode->geometry().pline(pline1);
|
|
mode->geometry().pline(pline2);
|
|
mode->subEntityTraits().setColor(nColor);
|
|
}
|
|
|
|
return Adesk::kFalse;;
|
|
}
|
|
|
|
|
|
void TDbOpeningAptJig::subViewportDraw(AcGiViewportDraw *mode)
|
|
{
|
|
int nNums = CInsertOpeningDlg::g_pCurDlg->GetOpeningNums();
|
|
if (nNums>1)
|
|
{
|
|
XPoint ptLoc = m_pOpening->GetLocation(),
|
|
ptPos;
|
|
double dWidth = m_pOpening->GetWidth();
|
|
double dAngle = m_pOpening->GetRotation();
|
|
double dDist(0.0);
|
|
if (nNums%2 == 0) // 偶数个门
|
|
{
|
|
for (int i=0; i<nNums; i++)
|
|
{
|
|
if (i==0)
|
|
{
|
|
dDist += dWidth/2.0;
|
|
}
|
|
else if (i%2 == 0)
|
|
{
|
|
dDist += dWidth;
|
|
}
|
|
ads_polar(ptLoc, dAngle, dDist, ptPos);
|
|
|
|
TDbOpening *pOpening = (TDbOpening*)m_pOpening->clone();
|
|
pOpening->SetLocation(ptPos);
|
|
pOpening->m_ptLabel = pOpening->GetDefaultLabPos();
|
|
pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
pOpening->subViewportDraw(mode);
|
|
dAngle = PI + dAngle;
|
|
}
|
|
}
|
|
else // 奇数个门
|
|
{
|
|
m_pOpening->subViewportDraw(mode);
|
|
for (int i=1; i<nNums; i++)
|
|
{
|
|
if (i%2 != 0)
|
|
{
|
|
dDist += dWidth;
|
|
}
|
|
ads_polar(ptLoc, dAngle, dDist, ptPos);
|
|
|
|
TDbOpening *pOpening = (TDbOpening*)m_pOpening->clone();
|
|
pOpening->SetLocation(ptPos);
|
|
pOpening->m_ptLabel = pOpening->GetDefaultLabPos();
|
|
pOpening->SetLayoutRotation(Ucs2Wcs(0));
|
|
pOpening->subViewportDraw(mode);
|
|
dAngle = PI + dAngle;
|
|
}
|
|
}
|
|
DrawOsnapShape(mode, ptLoc, AcDb::kOsMaskNear);
|
|
}
|
|
else
|
|
{
|
|
m_pOpening->subViewportDraw(mode);
|
|
DrawOsnapShape(mode, m_pOpening->GetLocation(), AcDb::kOsMaskNear);
|
|
}
|
|
}
|
|
|
|
// add by lgy 20120612，智能插入门窗时由于jig时无法获取墙线两侧的轴线，
|
|
// 此函数根据点，求两侧的轴线
|
|
// ptPick:拾取点， cvBase:基线， cvSeg:所求线段
|
|
//void GetSubSegmentByPoint(XPoint ptPick, XCurveSegment cvBase, XCurveSegment &cvSeg)
|
|
//{
|
|
// XDbBlockTableRec objMSpace;
|
|
// if (!objMSpace)
|
|
// return;
|
|
//
|
|
// AcDbBlockTableRecordIterator *pIterator = NULL;
|
|
// Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pIterator);
|
|
// if (es!=Acad::eOk || pIterator==NULL)
|
|
// return;
|
|
//
|
|
// double dDist = cvBase.PathDistance(ptPick),
|
|
// dDistLeft(0.0),
|
|
// dDistRight = cvBase.GetLength();
|
|
// XPoint ptTempS, ptTempE, ptInt1, ptInt2, ptInters, ptStart, ptEnd;
|
|
//
|
|
// for (pIterator->start(); !pIterator->done(); pIterator->step())
|
|
// {
|
|
// AcDbEntity *pEnt = NULL;
|
|
// es = pIterator->getEntity(pEnt, AcDb::kForRead);
|
|
// if (es!=Acad::eOk || pEnt==NULL)
|
|
// continue;
|
|
//
|
|
// if (pEnt->visibility()==AcDb::kInvisible || _tcsicmp(pEnt->layer(), LAY_AXIS)!=0 || !pEnt->isKindOf(AcDbLine::desc()))
|
|
// continue;
|
|
//
|
|
// AcDbLine *pLine = AcDbLine::cast(pEnt);
|
|
// pLine->getStartPoint(ptTempS);
|
|
// pLine->getEndPoint(ptTempE);
|
|
// pLine->close();
|
|
//
|
|
// XCurveSegment segTemp(ptTempS, ptTempE, 0);
|
|
// segTemp.SetElevation(0.0);
|
|
//
|
|
// int nRet = cvBase.Intersection(segTemp, ptInt1, ptInt2);
|
|
// if (nRet < 1)
|
|
// continue;
|
|
// else if (nRet == 1)
|
|
// ptInters = ptInt1;
|
|
// else
|
|
// ptInters = TGGeLine(ptInt1, ptInt2).NearPoint(ptPick);
|
|
//
|
|
// double dDist0 = cvBase.PathDistance(ptInters);
|
|
// if (dDist0 < dDist + _DIST_SNAP)
|
|
// {
|
|
// if (dDist0 > dDistLeft - _DIST_SNAP)
|
|
// {
|
|
// ptStart = ptInters;
|
|
// dDistLeft = dDist0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// if (dDist0 < dDistRight + _DIST_SNAP)
|
|
// {
|
|
// ptEnd = ptInters;
|
|
// dDistRight = dDist0;
|
|
// }
|
|
// }
|
|
// }
|
|
// delete pIterator;
|
|
//
|
|
// XCurveSegment cvTemp(ptStart, ptEnd, cvBase.GetBulge());
|
|
// cvSeg = cvTemp;
|
|
//}
|
|
|
|
BOOL GetSubSegmentByPoint2(AcDbObjectId wallId, DList<TWallAxisData> &lstIds, XPoint ptPick, XCurveSegment cvBase, XCurveSegment &cvSeg,
|
|
XPoint &ptS, XPoint &ptE)
|
|
{
|
|
BOOL bRet(FALSE);
|
|
XPoint ptStart, ptEnd;
|
|
|
|
long lLen = lstIds.Length();
|
|
for (long l=0; l<lLen; l++)
|
|
{
|
|
TWallAxisData data = *lstIds[l];
|
|
if (data.m_idWall != wallId)
|
|
continue;
|
|
|
|
double dDist = cvBase.PathDistance(ptPick),
|
|
dDistLeft(0.0),
|
|
dDistRight = cvBase.GetLength();
|
|
XPoint ptTempS, ptTempE, ptInt1, ptInt2, ptInters;
|
|
|
|
bool bSAxisOk = false,
|
|
bEAxisOk = false;
|
|
|
|
int nAxisLen = data.m_aryAxisIds.logicalLength();
|
|
for (int m=0; m<nAxisLen; m++)
|
|
{
|
|
XCurveSegment segAxis;
|
|
OPENOBJ_BEGIN(data.m_aryAxisIds[m], AcDb::kForRead, AcDbEntity, pEntity);
|
|
if (pEntity != NULL)
|
|
{
|
|
AcDbLine *pLine = AcDbLine::cast(pEntity);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->getStartPoint(ptTempS);
|
|
pLine->getEndPoint(ptTempE);
|
|
segAxis.SetPoints(ptTempS, ptTempE);
|
|
}
|
|
else
|
|
{
|
|
AcDbArc *pArc = AcDbArc::cast(pEntity);
|
|
if (pArc != NULL)
|
|
{
|
|
pArc->center();
|
|
|
|
TADSGePoint3d ptCen;
|
|
(AcGePoint3d &)ptCen = pArc->center();
|
|
TVector3D vtNormal;
|
|
(AcGeVector3d &)vtNormal = pArc->normal();
|
|
ptCen = TchPrivate::Wcs2Ecs(ptCen, vtNormal);
|
|
|
|
TGGeArc arc(ptCen, pArc->radius(), pArc->startAngle(), pArc->endAngle());
|
|
ads_polar(arc.GetCenterPt(), arc.GetStarAngle(), arc.GetRadius(), segAxis.StartPoint());
|
|
ads_polar(arc.GetCenterPt(), arc.GetEndAngle(), arc.GetRadius(), segAxis.EndPoint());
|
|
segAxis.SetBulge(arc.Bulge());
|
|
}
|
|
}
|
|
pEntity->close();
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
segAxis.SetElevation(0.0);
|
|
segAxis.SetLineFlag(LS_FINITE);
|
|
int nRet = cvBase.Intersection(segAxis, ptInt1, ptInt2);
|
|
if (nRet < 1)
|
|
continue;
|
|
else if (nRet == 1)
|
|
ptInters = ptInt1;
|
|
else
|
|
ptInters = TGGeLine(ptInt1, ptInt2).NearPoint(ptPick);
|
|
|
|
double dDist0 = cvBase.PathDistance(ptInters);
|
|
if (dDist0 < dDist + _DIST_SNAP)
|
|
{
|
|
if (dDist0 > dDistLeft - _DIST_SNAP)
|
|
{
|
|
ptStart = ptInters;
|
|
dDistLeft = dDist0;
|
|
bSAxisOk = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dDist0 < dDistRight + _DIST_SNAP)
|
|
{
|
|
ptEnd = ptInters;
|
|
dDistRight = dDist0;
|
|
bEAxisOk = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bEAxisOk || !bSAxisOk) // 两边可能就没有轴线，或者只有1根，总之，只要一边的轴线不OK，那么就使用墙线做为SEG
|
|
{
|
|
ptStart = ptS;
|
|
ptEnd = ptE;
|
|
}
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
XCurveSegment cvTemp(ptStart, ptEnd, cvBase.GetBulge());
|
|
cvSeg = cvTemp;
|
|
return bRet;
|
|
}
|
|
|
|
// add by lgy 20120521 根据jig时的墙的ID和拾取点，得到当前智能分割线
|
|
// add by lgy 20120518 根据墙体id，拾取点，智能插入门窗方式，获取门窗应该插入的位置
|
|
// [wallId]:墙体ID, [ptPick]:拾取点， [cvSeg]:智能插入分割线1, [bAptType]:智能插入方式
|
|
BOOL GetAptitudeLocalPt(AcDbObjectId wallId, XPoint ptPick, XCurveSegment &cvSeg, int nAptType, DList<TWallAxisData> &lstIds)
|
|
{
|
|
PickSet ss;
|
|
XPoly2D poly;
|
|
XCurveSegment cvSegBase;
|
|
TDPtrList<AcDbSoftPointerId> openingList;
|
|
|
|
OPENOBJ_BEGIN(wallId, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall == NULL)
|
|
return FALSE;
|
|
|
|
if (nAptType == 1) // 轴线定距
|
|
{
|
|
XCurveSegment cvLongBaseLine = pWall->GetLongBaseLine();
|
|
cvLongBaseLine.SetElevation(0.0);
|
|
cvLongBaseLine.SetLineFlag(LS_FINITE);
|
|
|
|
// 不再采用全图搜索的方法，效率差，而且试用起来总有问题
|
|
if (!GetSubSegmentByPoint2(wallId, lstIds, ptPick, cvLongBaseLine, cvSegBase, pWall->StartPoint(), pWall->EndPoint()) ||
|
|
cvSegBase.GetLength()<_DIST_SNAP)
|
|
{
|
|
pWall->close();
|
|
return FALSE;
|
|
}
|
|
|
|
// add by lgy 20120614 轴线定距插入时无法将门窗插入到墙上，关闭墙实体后可以插入，具体原因不清楚
|
|
pWall->close();
|
|
}
|
|
else // 墙线定距
|
|
{
|
|
if (!pWall->GetSubSegmentByPierAt(ptPick, cvSegBase))
|
|
{
|
|
pWall->close();
|
|
return FALSE;
|
|
}
|
|
|
|
const TDPtrList<AcDbSoftPointerId> &openingList = pWall->GetOpeningIdList();
|
|
|
|
ss.Free();
|
|
for (int j = 0; j < openingList.Length(); j ++)
|
|
ss += openingList[j];
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
if (nAptType == 1)
|
|
{
|
|
cvSeg = cvSegBase;
|
|
return TRUE;
|
|
}
|
|
|
|
XPoint ptTemp;
|
|
ads_polar(ptPick, cvSegBase.Direction(ptPick) + PI/2, 1000, ptTemp);
|
|
XCurveSegment segAppeak(ptPick, ptTemp, 0);
|
|
|
|
XPoint ptNear1 = cvSegBase.StartPoint(),
|
|
ptNear2 = cvSegBase.EndPoint(); // 保存离拾取点最近的两个点
|
|
int nSide = segAppeak.OnWhichSide(ptNear1);
|
|
|
|
for (long i = 0; i < ss.Length(); i++)
|
|
{
|
|
Entity ent = ss[i];
|
|
XPoint pt1, pt2;
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
|
|
if (pOpening == NULL)
|
|
continue;
|
|
|
|
pOpening->GetSidePoints(pt1, pt2);
|
|
|
|
XPoint ptTemp1;
|
|
cvSegBase.ProjectToMe(pt1, ptTemp1);
|
|
pt1 = ptTemp1;
|
|
cvSegBase.ProjectToMe(pt2, ptTemp1);
|
|
pt2 = ptTemp1;
|
|
|
|
if (segAppeak.OnWhichSide(pt1) == nSide) // 在拾取点的左边
|
|
{
|
|
if (ptNear1.Distance2d(ptPick) > pt2.Distance2d(ptPick))
|
|
ptNear1 = pt2;
|
|
}
|
|
else
|
|
{
|
|
if (ptNear2.Distance2d(ptPick) > pt1.Distance2d(ptPick))
|
|
ptNear2 = pt1;
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
ss.Free();
|
|
cvSeg = XCurveSegment(ptNear1, ptNear2, cvSegBase.GetBulge());
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// add by lgy 20120521 为智能插入门窗添加jig类
|
|
// 没有使用原本的类的原因是智能插入门窗时需要显示两段分割线
|
|
class XDrawAptOpeningEdJig : public TEdJig
|
|
{
|
|
public:
|
|
XDrawAptOpeningEdJig(TDbOpening *pOpening, DList<TWallAxisData> &lstIds);
|
|
virtual ~XDrawAptOpeningEdJig();
|
|
|
|
public:
|
|
void doIt();
|
|
virtual DragStatus sampler();
|
|
virtual Adesk::Boolean Update();
|
|
virtual AcDbEntity *entity() const;
|
|
|
|
int GetRetCode(int *kwordId = NULL) const;
|
|
|
|
public:
|
|
XPoint m_ptOnWall;
|
|
AcDbObjectId m_idWall;
|
|
XCurveSegment m_cvSeg; // 智能分割的线段
|
|
DList<TWallAxisData> m_lstIds; // 提前搜索出来墙和轴网的关系，防止在JIG过程中有对象打开，无法通过SSGET获得轴网
|
|
|
|
XPoint m_ptCursor;
|
|
int m_nRetCode; // 返回码
|
|
const TCHAR* m_pszPrompt; // 提示信息
|
|
const TCHAR* m_pszKeyword; // 关键字
|
|
int m_nAptType; // 智能插入门窗方式
|
|
|
|
public:
|
|
TDbOpeningAptJig *m_pDrawEnt; // 临时实体
|
|
};
|
|
|
|
XDrawAptOpeningEdJig::XDrawAptOpeningEdJig(TDbOpening *pOpening, DList<TWallAxisData> &lstIds)
|
|
: m_pszKeyword(NULL), m_pszPrompt(NULL), m_pDrawEnt(NULL), m_nRetCode(0)
|
|
{
|
|
m_pDrawEnt = new TDbOpeningAptJig;
|
|
m_pDrawEnt->SetOpening(pOpening);
|
|
|
|
// 提前搜索出来墙和轴网的关系，防止在JIG过程中有对象打开，无法通过SSGET获得轴网
|
|
m_lstIds.Reset();
|
|
int nLength = lstIds.Length();
|
|
for (int i=0; i<nLength; i++)
|
|
{
|
|
TWallAxisData data = *lstIds[i];
|
|
m_lstIds.Append(new TWallAxisData(data));
|
|
}
|
|
|
|
m_nAptType = 0; // 墙线定距
|
|
}
|
|
|
|
XDrawAptOpeningEdJig::~XDrawAptOpeningEdJig()
|
|
{
|
|
if (m_pDrawEnt)
|
|
{
|
|
delete m_pDrawEnt;
|
|
}
|
|
}
|
|
|
|
// 转换成ADS代码
|
|
int XDrawAptOpeningEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
{
|
|
ret = RTCAN;
|
|
}
|
|
else if (ret == AcEdJig::kNull)
|
|
{
|
|
ret = RTNONE;
|
|
}
|
|
else if (ret <= 0)
|
|
{
|
|
ret = RTNORM;
|
|
}
|
|
else
|
|
{
|
|
if (kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
void XDrawAptOpeningEdJig::doIt()
|
|
{
|
|
setDispPrompt(m_pszPrompt);
|
|
if (m_pszKeyword) // 存在关键字
|
|
{
|
|
INITGET_BEG(-1, m_pszKeyword);
|
|
try
|
|
{
|
|
m_nRetCode = drag();
|
|
}
|
|
catch(...)
|
|
{
|
|
m_nRetCode = AcEdJig::kCancel;
|
|
}
|
|
INITGET_END();
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
m_nRetCode = drag();
|
|
}
|
|
catch(...)
|
|
{
|
|
m_nRetCode = AcEdJig::kCancel;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus XDrawAptOpeningEdJig::sampler()
|
|
{
|
|
double nIncStep = g_nWinStep;
|
|
|
|
DragStatus stat;
|
|
setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted |
|
|
AcEdJig::kNoNegativeResponseAccepted | AcEdJig::kNoZeroResponseAccepted));
|
|
|
|
if (m_pszKeyword)
|
|
{
|
|
setKeywordList(m_pszKeyword);
|
|
}
|
|
|
|
XPoint ptTemp;
|
|
stat = acquirePoint(ptTemp);
|
|
if (stat == AcEdJig::kNormal)
|
|
{
|
|
if (ptTemp.Distance(m_ptCursor) > _DIST_SNAP)
|
|
{
|
|
m_ptCursor = ptTemp;
|
|
m_idWall = SnapOnWall(ptTemp); // 判断点在墙上的id
|
|
|
|
if (!!m_idWall)
|
|
{
|
|
OPENOBJ_BEGIN(m_idWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall == NULL)
|
|
{
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
|
|
if (pWall->Is(CURVE_LINE) && m_pDrawEnt->m_pOpening->GetKind()==TOpeningData::OP_ARCWIN)
|
|
{
|
|
pWall->close();
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
if (GetAptitudeLocalPt(m_idWall, m_ptCursor, m_cvSeg, m_nAptType, m_lstIds))
|
|
{
|
|
m_pDrawEnt->m_bShow = TRUE;
|
|
m_pDrawEnt->SetLineParameters(m_idWall, m_cvSeg, (m_nAptType==0)?6:4); // 更新线的参数
|
|
}
|
|
}
|
|
|
|
m_ptOnWall = ptTemp;
|
|
}
|
|
else
|
|
{
|
|
m_pDrawEnt->m_bShow = FALSE;
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean XDrawAptOpeningEdJig::Update()
|
|
{
|
|
if (CInsertOpeningDlg::g_pCurDlg!=NULL &&
|
|
CInsertOpeningDlg::g_pCurDlg->IsWindowVisible())
|
|
{
|
|
TDbOpening *pOpening = CInsertOpeningDlg::g_pCurDlg->NewOpening();
|
|
m_pDrawEnt->SetOpening(pOpening);
|
|
delete pOpening;
|
|
}
|
|
|
|
if (!m_idWall)
|
|
{
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
OPENOBJ_BEGIN(m_idWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
if (m_pDrawEnt->m_pOpening->GetKind() == TOpeningData::OP_ARCWIN)
|
|
{
|
|
if (pWall->Is(CURVE_ARC))
|
|
{
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pDrawEnt->m_pOpening->SetWallId(m_idWall);
|
|
}
|
|
m_pDrawEnt->SetOpeningParameters(pWall, m_ptOnWall, m_ptCursor, CInsertOpeningDlg::g_pCurDlg?CInsertOpeningDlg::g_pCurDlg->GetInsertMode():0);
|
|
}
|
|
OPENOBJ_END();
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* XDrawAptOpeningEdJig::entity() const
|
|
{
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
//add by lgy 20120517 智能插入门窗
|
|
AcDbObjectId GetOpeingLocationApt(const TCHAR *prompt, TDbOpening *&pWin, XPoint &ptPick, XCurveSegment &cvSeg, int &nRetCode,
|
|
int nAptType, DList<TWallAxisData> &lstIds)
|
|
{
|
|
int nOsMode = 0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode |= 0x4000;
|
|
XPushVar<int> osmode(_T("OSMODE"), nOsMode);
|
|
|
|
XDrawAptOpeningEdJig jig(pWin, lstIds);
|
|
jig.m_pszPrompt = prompt;
|
|
jig.m_pszKeyword = _T("Q");
|
|
jig.m_nAptType = nAptType;
|
|
jig.doIt();
|
|
|
|
ptPick = jig.m_ptCursor;
|
|
cvSeg = jig.m_cvSeg;
|
|
|
|
int kwordId;
|
|
AcDbObjectId idWall;
|
|
nRetCode = jig.GetRetCode(&kwordId);
|
|
if (nRetCode == RTNORM)
|
|
{
|
|
idWall = jig.m_idWall;
|
|
if (!!idWall)
|
|
{
|
|
delete pWin;
|
|
pWin = jig.m_pDrawEnt->m_pOpening;
|
|
jig.m_pDrawEnt->m_pOpening = NULL;
|
|
|
|
// 成功的添加了门窗，那么把最近一次的参数写入注册表
|
|
CInsertOpeningDlg::g_pCurDlg->UpdateOpening(*pWin, TRUE);
|
|
CInsertOpeningDlg::g_pCurDlg->WriteParamToRegistry();
|
|
CInsertOpeningDlg::g_pCurDlg->SetupLabelList();
|
|
}
|
|
}
|
|
return idWall;
|
|
}
|