621 lines
16 KiB
C++
621 lines
16 KiB
C++
#include "StdAfx.h"
|
||
#include "commonRoad.h"
|
||
|
||
namespace TRoadCommon
|
||
{
|
||
// 点相对于线段的关系，左侧，右侧，线段（所在的直线）上,
|
||
// dTol：判断点是否在线上
|
||
EPointToLine PointToLineSegPerp(const AcGeLineSeg2d &lineseg, const AcGePoint2d &point, double dTol)
|
||
{
|
||
if (ToLine(lineseg).distanceTo(point) < dTol)
|
||
return eOnLine;
|
||
|
||
// 叉积：
|
||
AcGeVector2d vecLine = lineseg.direction();
|
||
AcGeVector2d vecAccurate = point - lineseg.startPoint();
|
||
|
||
return vecLine.x * vecAccurate.y - vecLine.y * vecAccurate.x > 0 ? eLeft : eRight;
|
||
}
|
||
|
||
// 根据圆弧的clockwise，以及相对的半径来判断
|
||
EPointToLine PointToArcPerp(const AcGeCircArc2d &arc, const AcGePoint2d &point, double dTol)
|
||
{
|
||
double dRaidus = arc.radius();
|
||
double dDisAccurate = point.distanceTo(arc.center());
|
||
|
||
// 注意：如果圆弧半径过小，会发生问题。
|
||
if (fabs(dRaidus - dDisAccurate) < dTol)
|
||
return eOnLine;
|
||
else
|
||
{
|
||
if (arc.isClockWise())
|
||
{
|
||
return dDisAccurate < dRaidus ? eRight : eLeft;
|
||
}
|
||
else
|
||
{
|
||
return dDisAccurate < dRaidus ? eLeft : eRight;
|
||
}
|
||
}
|
||
}
|
||
|
||
EPointToLine PointToLineSegDir(const AcGeLineSeg2d &lineseg, const AcGePoint2d &point, double dTol)
|
||
{
|
||
AcGeVector2d vecLine = lineseg.direction();
|
||
AcGeVector2d vecPerp = vecLine.perpVector();
|
||
AcGeLineSeg2d startLine(lineseg.startPoint(), lineseg.startPoint() + vecPerp);
|
||
AcGeLineSeg2d endLine(lineseg.endPoint(), lineseg.endPoint() + vecPerp);
|
||
|
||
EPointToLine es = PointToLineSegPerp(startLine, point, dTol);
|
||
EPointToLine ee = PointToLineSegPerp(endLine, point, dTol);
|
||
|
||
if (es == eOnLine && ee == eOnLine)
|
||
return eOnLine; // 点和两端都接近的情况
|
||
else if (es == eLeft)
|
||
return eStartOut;
|
||
else if (es == eOnLine)
|
||
return eStartPoint;
|
||
else if (ee == eRight)
|
||
return eEndOut;
|
||
else if (ee == eOnLine)
|
||
return eEndPoint;
|
||
else
|
||
return eOnLine;
|
||
|
||
}
|
||
|
||
EPointToLine PointToArcDir(const AcGeCircArc2d &arcIn, const AcGePoint2d &point, double dTol)
|
||
{
|
||
ASSERT(dTol > 0);
|
||
// get Attirbute
|
||
AcGePoint2d startPoint = arcIn.startPoint();
|
||
AcGePoint2d endPoint = arcIn.endPoint();
|
||
AcGePoint2d centerPoint = arcIn.center();
|
||
bool bClock = arcIn.isClockWise() ? true : false;
|
||
double dRadius = arcIn.radius();
|
||
|
||
// 计算圆弧上的各个角度
|
||
double dangleStart = AcGeVector2d(startPoint-centerPoint).angle();
|
||
double dangleEnd = AcGeVector2d(endPoint - centerPoint).angle();
|
||
double dangleAccurate = AcGeVector2d(point - centerPoint).angle();
|
||
double dAntiMidAngle = AddAngleInClock(bClock, dangleStart, AngleInClock(bClock, dangleStart, dangleEnd)*0.5); // 首先获取midAngle
|
||
dAntiMidAngle = AntiAngle(dAntiMidAngle); // 获取antiMidAngle
|
||
|
||
|
||
// 计算相对于antiAngle的夹角
|
||
dangleStart = AngleInClock(bClock, dAntiMidAngle, dangleStart);
|
||
dangleEnd = AngleInClock(bClock, dAntiMidAngle, dangleEnd);
|
||
dangleAccurate = AngleInClock(bClock, dAntiMidAngle, dangleAccurate);
|
||
|
||
// 这类的角度都是相对于dAntiStart的角度，
|
||
double dStartlen = dangleStart * dRadius;
|
||
double dEndLen = dangleEnd * dRadius;
|
||
double dAccurateLen = dangleAccurate * dRadius;
|
||
|
||
if (fabs(dStartlen - dAccurateLen) < dTol && fabs(dEndLen - dAccurateLen) < dTol )
|
||
return eOnLine;
|
||
else if (fabs(dStartlen - dAccurateLen) < dTol)
|
||
return eStartPoint;
|
||
else if (dAccurateLen < dStartlen)
|
||
return eStartOut;
|
||
else if (fabs(dEndLen - dAccurateLen) < dTol)
|
||
return eEndPoint;
|
||
else if (dEndLen < dAccurateLen)
|
||
return eEndOut;
|
||
else
|
||
return eOnLine;
|
||
}
|
||
|
||
|
||
AcGeCircArc2d OutSideArc(const AcGeCircArc2d &arcTem, double dHalfWid)
|
||
{
|
||
return ConNewArc(arcTem, arcTem.radius() + dHalfWid);// 半径扩展
|
||
}
|
||
|
||
AcGeCircArc2d InSideArc(const AcGeCircArc2d &arcTem, double dHalfWid)
|
||
{
|
||
if (arcTem.radius() - dHalfWid < 1.0)
|
||
return arcTem;
|
||
|
||
return ConNewArc(arcTem, arcTem.radius() - dHalfWid);
|
||
}
|
||
|
||
AcDbArc& GeArcToDbSys(const AcGeCircArc2d &arc, AcDbArc &dbArc)
|
||
{
|
||
AcGePoint2d ptCenter = arc.center();
|
||
AcGeVector2d vecStart = arc.startPoint() - ptCenter;
|
||
AcGeVector2d vecEnd = arc.endPoint() - ptCenter;
|
||
AcGeVector3d norm(0.0, 0.0, 1.0);
|
||
|
||
dbArc.setCenter(POINT_2D_TO_3D(AsSysUnitPoint2d(ptCenter)));
|
||
dbArc.setRadius(_AS_SYS_UNIT(arc.radius()));
|
||
dbArc.setNormal(norm);
|
||
|
||
if (arc.isClockWise())
|
||
{
|
||
dbArc.setStartAngle(vecEnd.angle());
|
||
dbArc.setEndAngle(vecStart.angle());
|
||
}
|
||
else
|
||
{
|
||
dbArc.setStartAngle(vecStart.angle());
|
||
dbArc.setEndAngle(vecEnd.angle());
|
||
}
|
||
|
||
return dbArc;
|
||
}
|
||
|
||
AcDbArc* GeArcToDbSys(const AcGeCircArc2d &arc)
|
||
{
|
||
AcDbArc *pArc = new AcDbArc;
|
||
GeArcToDbSys(arc, *pArc);
|
||
return pArc;
|
||
}
|
||
|
||
AcDbLine* GeLineToDbLineSys(const AcGeLineSeg2d &lineSeg)
|
||
{
|
||
AcGePoint2d ptStart = lineSeg.startPoint();
|
||
AcGePoint2d ptEnd = lineSeg.endPoint();
|
||
|
||
ptStart = AsSysUnitPoint2d(ptStart);
|
||
ptEnd = AsSysUnitPoint2d(ptEnd);
|
||
|
||
return new AcDbLine(POINT_2D_TO_3D(ptStart), POINT_2D_TO_3D(ptEnd));
|
||
}
|
||
AcGeLineSeg2d DbLineToGeLineMM(const AcDbLine &dbLine)
|
||
{
|
||
AcGePoint3d ptStart = dbLine.startPoint();
|
||
AcGePoint3d ptEnd = dbLine.endPoint();
|
||
ptStart = AsMMUnitPoint3d(ptStart);
|
||
ptEnd = AsMMUnitPoint3d(ptEnd);
|
||
|
||
return AcGeLineSeg2d(POINT_3D_TO_2D(ptStart), POINT_3D_TO_2D(ptEnd));
|
||
}
|
||
|
||
// 首先：AcDbArc据说都是逆时针的
|
||
// 还是使用圆心，半径，角度构造圆弧比较靠谱
|
||
AcGeCircArc2d DbArcToGeMM(const AcDbArc &dbArc)
|
||
{
|
||
AcGePoint3d ptCenter3d = dbArc.center();
|
||
double dRadius = dbArc.radius();
|
||
double dangleStart = dbArc.startAngle();
|
||
double dangleEnd = dbArc.endAngle();
|
||
|
||
return AcGeCircArc2d(POINT_3D_TO_2D(AsMMUnitPoint3d(ptCenter3d)), _AS_MM(dRadius), dangleStart, dangleEnd);
|
||
}
|
||
|
||
void SetLayer(AcDbEntity *pEnt, EEntType entType)
|
||
{
|
||
if (entType == eRoadEdgeType)
|
||
{
|
||
if (pEnt->setLayer(InitLayer(LAY_ROAD)) != Acad::eOk)
|
||
ads_printf(_T("道路图层设置失败！"));
|
||
}
|
||
else
|
||
{
|
||
if (pEnt->setLayer(InitLayer(LAY_ROADDOTE)) != Acad::eOk)
|
||
ads_printf(_T("中线图层设置失败！"));
|
||
if (g_bMeterUnitDraw)
|
||
pEnt->setLinetypeScale(0.001);
|
||
}
|
||
}
|
||
|
||
|
||
AcGeLineSeg2d LeftLine(const AcGeLineSeg2d &lineseg, double dDis)
|
||
{
|
||
AcGeVector2d vecPrep = lineseg.direction().perpVector().normalize();
|
||
|
||
return AcGeLineSeg2d(lineseg.startPoint() + vecPrep * dDis,
|
||
lineseg.endPoint() + vecPrep * dDis);
|
||
}
|
||
|
||
AcGeLineSeg2d RightLine(const AcGeLineSeg2d &lineseg, double dDis)
|
||
{
|
||
AcGeVector2d vecPrep = lineseg.direction().perpVector().normalize();
|
||
|
||
return AcGeLineSeg2d(lineseg.startPoint() - vecPrep * dDis,
|
||
lineseg.endPoint() - vecPrep * dDis);
|
||
|
||
}
|
||
|
||
AcGeCircArc2d LeftArc(const AcGeCircArc2d &arc, double dDis)
|
||
{
|
||
if (arc.isClockWise())
|
||
{
|
||
return OutSideArc(arc, dDis);
|
||
}
|
||
else
|
||
{
|
||
return InSideArc(arc, dDis);
|
||
}
|
||
}
|
||
|
||
AcGeCircArc2d RightArc(const AcGeCircArc2d &arc, double dDis)
|
||
{
|
||
if (!arc.isClockWise())
|
||
{
|
||
return OutSideArc(arc, dDis);
|
||
}
|
||
else
|
||
{
|
||
return InSideArc(arc, dDis);
|
||
}
|
||
}
|
||
|
||
// 修改圆弧，而不改变圆心
|
||
AcGeCircArc2d ConNewArc(const AcGeCircArc2d &arcTemplate, const AcGePoint2d &ptStart, const AcGePoint2d &ptEnd)
|
||
{
|
||
AcGePoint2d ptCenter = arcTemplate.center();
|
||
AcGeVector2d vecStart = ptStart - ptCenter;
|
||
AcGeVector2d vecEnd = ptEnd - ptCenter;
|
||
|
||
double dStartAngle = vecStart.angle();
|
||
double dEndAngle = vecEnd.angle();
|
||
|
||
if (arcTemplate.isClockWise())
|
||
{
|
||
dStartAngle = 2 * PI - dStartAngle;
|
||
dEndAngle = 2 * PI - dEndAngle;
|
||
}
|
||
|
||
AcGeCircArc2d arc = AcGeCircArc2d(ptCenter,
|
||
arcTemplate.radius(),
|
||
dStartAngle,
|
||
dEndAngle,
|
||
AcGeVector2d::kXAxis,
|
||
arcTemplate.isClockWise());
|
||
|
||
|
||
return arc;
|
||
}
|
||
|
||
AcGeCircArc2d ConNewArc(const AcGeCircArc2d &arcTemplate, double dRadius)
|
||
{
|
||
AcGeCircArc2d arc = arcTemplate;
|
||
return arc.setRadius(dRadius);
|
||
}
|
||
|
||
AcGeVector2d TanVecOfArcStartPoint(const AcGeCircArc2d &arc)
|
||
{
|
||
AcGePoint2d ptStart = arc.startPoint();
|
||
AcGePoint2d ptCenter = arc.center();
|
||
|
||
AcGeVector2d vecTan = ptStart - ptCenter;
|
||
|
||
if (arc.isClockWise())
|
||
vecTan.rotateBy(-PI*0.5);
|
||
else
|
||
vecTan.rotateBy(PI*0.5);
|
||
|
||
return vecTan.normalize();
|
||
}
|
||
|
||
AcGeVector2d TanVecOfArcEndPoint(const AcGeCircArc2d &arc)
|
||
{
|
||
AcGePoint2d ptEnd = arc.endPoint();
|
||
AcGePoint2d ptCenter = arc.center();
|
||
|
||
AcGeVector2d vecTan = ptEnd - ptCenter;
|
||
|
||
if (!arc.isClockWise())
|
||
vecTan.rotateBy(-PI*0.5);
|
||
else
|
||
vecTan.rotateBy(PI*0.5);
|
||
|
||
return vecTan.normalize();
|
||
}
|
||
|
||
double NormalAngle(double dAngle)
|
||
{
|
||
return AngleRangeTo2PI(dAngle);
|
||
}
|
||
|
||
double VecAngle(const AcGeVector2d &vec1, const AcGeVector2d &vec2, bool bClock)
|
||
{
|
||
double dAngle1 = vec1.angle();
|
||
double dAngle2 = vec2.angle();
|
||
|
||
if (bClock)
|
||
{ //
|
||
return NormalAngle(dAngle1 - dAngle2);
|
||
}
|
||
else
|
||
{
|
||
return NormalAngle(dAngle2 - dAngle1);
|
||
}
|
||
}
|
||
|
||
|
||
// 按照bClockwise的方向，返回angle1和angle2的夹角
|
||
double AngleInClock(bool bClockwise, double angle1, double angle2)
|
||
{
|
||
if (angle2 < angle1)
|
||
angle2 += PI*2.0;
|
||
|
||
// 逆时针的夹角，顺时针的夹角是他跟2PI的差
|
||
double dAngleAnti = angle2 - angle1;
|
||
if (bClockwise)
|
||
{
|
||
return PI*2.0 - dAngleAnti;
|
||
}
|
||
else
|
||
{
|
||
return dAngleAnti;
|
||
}
|
||
}
|
||
|
||
// 向量vec的方向上，对pt1和pt2排序
|
||
// ret：-1:pt1 < pt2； 0： pt == pt2；1: pt1 > pt2。
|
||
int PointSequence(const AcGeVector2d &vec, const AcGePoint2d &pt1, const AcGePoint2d &pt2, double dTol)
|
||
{
|
||
double d1 = pt1.asVector().dotProduct(vec);
|
||
double d2 = pt2.asVector().dotProduct(vec);
|
||
|
||
if (fabs(d1 - d2) < dTol)
|
||
return 0;
|
||
else if (d1 < d2) return -1;
|
||
else
|
||
return 1;
|
||
|
||
}
|
||
|
||
// 圆弧arc的方向上（顺时针，逆时针）对pt1和pt2进行排序.
|
||
// 备注：排序的起点是arc另一侧圆弧的中点，方向是按照圆弧的时针方向
|
||
// ret：-1:pt1 < pt2； 0： pt == pt2；1: pt1 > pt2。
|
||
int PointSequence(const AcGeCircArc2d &arcDir, const AcGePoint2d &pt1, const AcGePoint2d &pt2, double dTol)
|
||
{
|
||
// 这个函数需要测试一下
|
||
AcGePoint2d ptStart = arcDir.startPoint();
|
||
AcGePoint2d ptEnd = arcDir.endPoint();
|
||
AcGePoint2d ptCenter = arcDir.center();
|
||
|
||
|
||
bool bClock = arcDir.isClockWise() == Adesk::kTrue;
|
||
double dStartAngle = AcGeVector2d(ptStart - ptCenter).angle();
|
||
double dEndAngle = AcGeVector2d(ptEnd - ptCenter).angle();
|
||
double dArcAngle = AngleInClock(bClock, dStartAngle, dEndAngle);
|
||
|
||
// 计算每个点与这个角度的夹角
|
||
double dAccurateStartAngle = AntiAngle(AddAngleInClock(bClock, dStartAngle, dArcAngle*0.5));
|
||
|
||
AcGeVector2d vecDump1 = pt1 - ptCenter;
|
||
AcGeVector2d vecDump2 = pt2 - ptCenter;
|
||
|
||
double dAngle1 = vecDump1.angle();
|
||
double dAngle2 = vecDump2.angle();
|
||
|
||
double d1, d2;
|
||
if (SameAngle(dAccurateStartAngle, dAngle1, dTol))
|
||
d1 = 0.0;
|
||
else
|
||
d1 = AngleInClock(bClock, dAccurateStartAngle, vecDump1.angle());
|
||
if (SameAngle(dAccurateStartAngle, dAngle2, dTol))
|
||
d2 = 0.0;
|
||
else
|
||
d2 = AngleInClock(bClock, dAccurateStartAngle, vecDump2.angle());
|
||
|
||
if (fabs(d1 - d2) < dTol)
|
||
return 0;
|
||
else if (d1 < d2)
|
||
return -1;
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
AcGePoint2d MidPointOfArc(const AcGeCircArc2d &arc)
|
||
{
|
||
AcGePoint2d ptStart = arc.startPoint();
|
||
AcGePoint2d ptEnd = arc.endPoint();
|
||
AcGePoint2d ptCenter = arc.center();
|
||
|
||
double dRadius = arc.radius();
|
||
|
||
double dangleStart = AcGeVector2d(ptStart - ptCenter).angle();
|
||
double dangleEnd = AcGeVector2d(ptEnd - ptCenter).angle();
|
||
|
||
double dangleWhole = AngleInClock(arc.isClockWise() ? true : false, dangleStart, dangleEnd);
|
||
double dangleMid = AddAngleInClock(arc.isClockWise() ? true : false, dangleStart, dangleWhole * 0.5);
|
||
|
||
return ptCenter + AcGeVector2d(cos(dangleMid)*dRadius, sin(dangleMid)*dRadius);
|
||
|
||
}
|
||
|
||
|
||
// 向一端延长直线段
|
||
AcGeLineSeg2d ExtendLine(const AcGeLineSeg2d &lineseg, bool bStart, double dExtend)
|
||
{
|
||
AcGeVector2d lineVec = lineseg.direction();
|
||
lineVec.normalize();
|
||
|
||
if (bStart)
|
||
return AcGeLineSeg2d(lineseg.startPoint() - lineVec*dExtend, lineseg.endPoint());
|
||
else
|
||
return AcGeLineSeg2d(lineseg.startPoint(), lineseg.endPoint() + lineVec*dExtend);
|
||
}
|
||
// 向一端延长弧线，
|
||
AcGeCircArc2d ExtendArc(const AcGeCircArc2d &arc, bool bStart, double dExtendLen)
|
||
{
|
||
if (bStart)
|
||
return ExtendArc(arc, dExtendLen, 0.0);
|
||
else
|
||
return ExtendArc(arc, 0.0, dExtendLen);
|
||
}
|
||
|
||
AcGeLineSeg2d ExtendLine(const AcGeLineSeg2d &lineseg, double dExtendStart, double dExtendEnd)
|
||
{
|
||
AcGeLineSeg2d line = ExtendLine(lineseg, true, dExtendStart);
|
||
return ExtendLine(line, false, dExtendEnd);
|
||
}
|
||
|
||
AcGeCircArc2d ExtendArc(const AcGeCircArc2d &arc, double dExtendStart, double dExtendEnd)
|
||
{
|
||
double dRaidus = arc.radius();
|
||
if (dRaidus < 1.0)
|
||
return arc;
|
||
|
||
AcGePoint2d ptCenter = arc.center();
|
||
AcGePoint2d ptStart = arc.startPoint();
|
||
AcGePoint2d ptEnd = arc.endPoint();
|
||
bool bClock = arc.isClockWise() == Adesk::kTrue ? true : false;
|
||
|
||
double dStartAngle = AcGeVector2d(ptStart - ptCenter).angle();
|
||
double dEndAngle = AcGeVector2d(ptEnd - ptCenter).angle();
|
||
|
||
double dArcAngle = AngleInClock(bClock, dStartAngle, dEndAngle);
|
||
double dMaxExtendAngle = PI - dArcAngle*0.5; // 最大延伸弧度
|
||
|
||
double dExtendStartAngle = dExtendStart/dRaidus;
|
||
double dExtendEndAngle = dExtendEnd / dRaidus;
|
||
|
||
bool bOverStart = (dExtendStartAngle - dMaxExtendAngle > 1e-6); // 起始延伸和终止延伸是否越界
|
||
bool bOverEnd = (dExtendEndAngle - dMaxExtendAngle > 1e-6);
|
||
|
||
if (bOverEnd && bOverStart) return AcGeCircArc2d(ptCenter, dRaidus); // 直接返回整个圆
|
||
else if (bOverEnd)
|
||
{
|
||
dExtendEndAngle = dMaxExtendAngle;
|
||
}
|
||
else if (bOverStart)
|
||
{
|
||
dExtendStartAngle = dMaxExtendAngle;
|
||
}
|
||
|
||
double dangleStartNew = AddAngleInClock(bClock, dStartAngle, -dExtendStartAngle);
|
||
double dangleEndNew = AddAngleInClock(bClock, dEndAngle, dExtendEndAngle);
|
||
|
||
AcGePoint2d ptStartNew = ptCenter + AcGeVector2d(cos(dangleStartNew)*dRaidus, sin(dangleStartNew)*dRaidus);
|
||
AcGePoint2d ptEndNew = ptCenter + AcGeVector2d(cos(dangleEndNew)*dRaidus, sin(dangleEndNew)*dRaidus);
|
||
|
||
return ConNewArc(arc, ptStartNew, ptEndNew);
|
||
}
|
||
|
||
void ResetLine(AcGeLineSeg2d &line, bool bStart, const AcGePoint2d &ptAccurate)
|
||
{
|
||
line.set(bStart ? ptAccurate : line.startPoint(), bStart ? line.endPoint() : ptAccurate);
|
||
}
|
||
void ResetArc(AcGeCircArc2d &arc, bool bStart, const AcGePoint2d &ptAccurate)
|
||
{
|
||
arc = ConNewArc(arc, bStart ? ptAccurate : arc.startPoint(), bStart ? arc.endPoint() : ptAccurate);
|
||
}
|
||
double LenOfArc(const AcGeCircArc2d &arc)
|
||
{
|
||
return arc.length(arc.startAng(), arc.endAng());
|
||
}
|
||
|
||
BOOL SameAngle(double dAngle1, double dAngle2, double dAngleTol)
|
||
{
|
||
dAngle1 = NormalAngle(dAngle1);
|
||
dAngle2 = NormalAngle(dAngle2);
|
||
|
||
// 判断是否和0度相等，或者和2PI相等。
|
||
return (DoubleEqual(fabs(dAngle1 - dAngle2), 0.0, dAngleTol) ||
|
||
DoubleEqual(fabs(dAngle1 - dAngle2), PI*2.0, dAngleTol));
|
||
}
|
||
|
||
|
||
class CSelectStruct
|
||
{
|
||
public:
|
||
#if ADS > 22
|
||
static bool KeyFilter(MSG* msg);
|
||
#else
|
||
static BOOL KeyFilter(MSG* msg);
|
||
#endif
|
||
static int SelectEnts(CString csPrompt,PickSet &ssResult, TRBList &rbBaseMask,const TCHAR* szKeyword, TCHAR &chRet);
|
||
|
||
|
||
private:
|
||
static CString m_sKeyWordList;
|
||
static int m_rtRet;
|
||
static TCHAR m_chRet;
|
||
};
|
||
|
||
CString CSelectStruct::m_sKeyWordList;
|
||
int CSelectStruct::m_rtRet;
|
||
TCHAR CSelectStruct::m_chRet;
|
||
////////////////////////////////////////////////////////////////////////////
|
||
#if ADS > 22
|
||
bool CSelectStruct::KeyFilter(MSG* msg)
|
||
#else
|
||
BOOL CSelectStruct::KeyFilter(MSG* msg)
|
||
#endif
|
||
{
|
||
if(!acdbCurDwg())
|
||
return FALSE;
|
||
|
||
BOOL bRet = FALSE;
|
||
m_sKeyWordList.MakeUpper();
|
||
switch(msg->message)
|
||
{
|
||
case WM_KEYDOWN: //键盘输入关键字
|
||
{
|
||
if (msg->wParam == VK_RETURN || msg->wParam == VK_SPACE)// 键盘输入回车，键盘输入空格
|
||
{
|
||
m_rtRet = RTNONE;
|
||
msg->wParam = VK_SPACE;
|
||
}
|
||
else
|
||
{
|
||
CString sKey(TCHAR(msg->wParam));
|
||
sKey.MakeUpper();
|
||
if (m_sKeyWordList.Find(sKey) != -1)
|
||
{
|
||
// ads_printf(sKey);
|
||
m_chRet = sKey[0];
|
||
m_rtRet = RTKWORD;
|
||
msg->wParam = VK_SPACE;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case WM_RBUTTONDOWN: // 鼠标右键
|
||
{
|
||
m_rtRet = RTNONE;
|
||
msg->wParam = VK_SPACE;
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return bRet;
|
||
}
|
||
|
||
int CSelectStruct::SelectEnts(CString csPrompt,PickSet &ssResult, TRBList &rbBaseMask,const TCHAR* szKeyword, TCHAR &chRet)
|
||
{
|
||
if (szKeyword == NULL)
|
||
m_sKeyWordList = _T("");
|
||
else
|
||
m_sKeyWordList = szKeyword;
|
||
m_rtRet = RTERROR;
|
||
// 钩子函数监视键盘中输入关键字
|
||
acedRegisterFilterWinMsg(KeyFilter);
|
||
|
||
// 保存返回结果
|
||
int nRet = 0;
|
||
const TCHAR *szTempPrompts[2]={csPrompt, _T("") };
|
||
int iRet = ssResult.Get(_T(":S:$"), szTempPrompts, NULL, rbBaseMask);
|
||
if (m_rtRet == RTKWORD)
|
||
{
|
||
chRet = m_chRet;
|
||
nRet = RTKWORD;
|
||
}
|
||
else if (m_rtRet == RTNONE)
|
||
{
|
||
nRet = RTNONE;
|
||
}
|
||
else
|
||
nRet = iRet;
|
||
|
||
// 释放函数
|
||
acedRemoveFilterWinMsg(KeyFilter);
|
||
return nRet;
|
||
}
|
||
|
||
int SelectEntitiesOnce(CString csPrompt,PickSet &ssResult, TRBList &rbBaseMask,const TCHAR* szKeyword, TCHAR &chRet)
|
||
{
|
||
return CSelectStruct::SelectEnts(csPrompt, ssResult, rbBaseMask, szKeyword, chRet);
|
||
}
|
||
}
|
||
|