From 738608db07d32769dc8b4ba42fe324d247f5b79f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Benjamin=20Br=C3=A6strup=20Sayoc?= Date: Mon, 3 Feb 2025 15:33:41 +0100 Subject: [PATCH] Remove magic number and hard type enums in DimensionValidator.h - Remove currently present magic numbers - Hard type enums, so magic numbers can no longer be introduced. We don't want people to introduce magic numbers. --- src/Mod/TechDraw/Gui/CommandCreateDims.cpp | 79 +++--- src/Mod/TechDraw/Gui/DimensionValidators.cpp | 239 ++++++++++--------- src/Mod/TechDraw/Gui/DimensionValidators.h | 72 +++--- src/Mod/TechDraw/Gui/TaskDimRepair.cpp | 12 +- 4 files changed, 201 insertions(+), 201 deletions(-) diff --git a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp index 18a4b58203..b8b1a2dc7a 100644 --- a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp +++ b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp @@ -79,6 +79,7 @@ using namespace TechDrawGui; using namespace TechDraw; using namespace std; using DimensionType = TechDraw::DrawViewDimension::DimensionType; +using DimensionGeometry = TechDraw::DimensionGeometry; //=========================================================================== // utility routines @@ -104,7 +105,7 @@ void execAngle3Pt(Gui::Command* cmd); void execRadius(Gui::Command* cmd); void execDiameter(Gui::Command* cmd); void execArea(Gui::Command* cmd); -void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector minimumCounts, std::vector acceptableDimensionGeometrys); +void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector minimumCounts, std::vector acceptableDimensionGeometrys); void execExtent(Gui::Command* cmd, const std::string& dimType); @@ -1100,7 +1101,7 @@ protected: } void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2) { - if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != isAngle) { + if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != DimensionGeometry::isAngle) { //isValidMultiEdge check if lines are parallel. restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension")); createDistanceDimension("Distance", { ref1, ref2 }); @@ -1354,10 +1355,10 @@ protected: bool isVerticalDistance(ReferenceVector refs) { - DimensionGeometryType geometryRefs2d = validateDimSelection( - refs, { "Edge", "Vertex" }, { 1, 2 }, { isDiagonal }); + DimensionGeometry geometryRefs2d = validateDimSelection( + refs, { "Edge", "Vertex" }, { 1, 2 }, { DimensionGeometry::isDiagonal }); - return geometryRefs2d == TechDraw::isDiagonal; + return geometryRefs2d == DimensionGeometry::isDiagonal; } QPixmap icon(std::string name) @@ -1531,8 +1532,8 @@ void execRadius(Gui::Command* cmd) //Define the geometric configuration required for a radius dimension StringVector acceptableGeometry({"Edge"}); std::vector minimumCounts({1}); - std::vector acceptableDimensionGeometrys( - {isCircle, isEllipse, isBSplineCircle, isBSpline}); + std::vector acceptableDimensionGeometrys( + {DimensionGeometry::isCircle, DimensionGeometry::isEllipse, DimensionGeometry::isBSplineCircle, DimensionGeometry::isBSpline}); execDim(cmd, "Radius", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1579,8 +1580,8 @@ void execDiameter(Gui::Command* cmd) //Define the geometric configuration required for a diameter dimension StringVector acceptableGeometry({"Edge"}); std::vector minimumCounts({1}); - std::vector acceptableDimensionGeometrys( - {isCircle, isEllipse, isBSplineCircle, isBSpline}); + std::vector acceptableDimensionGeometrys( + {DimensionGeometry::isCircle, DimensionGeometry::isEllipse, DimensionGeometry::isBSplineCircle, DimensionGeometry::isBSpline}); execDim(cmd, "Diameter", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1626,8 +1627,8 @@ void execDistance(Gui::Command* cmd) { StringVector acceptableGeometry({"Edge", "Vertex"}); std::vector minimumCounts({1, 2}); - std::vector acceptableDimensionGeometrys( - {isVertical, isHorizontal, isDiagonal, isHybrid}); + std::vector acceptableDimensionGeometrys( + {DimensionGeometry::isVertical, DimensionGeometry::isHorizontal, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid}); execDim(cmd, "Distance", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1675,7 +1676,7 @@ void execDistanceX(Gui::Command* cmd) //Define the geometric configuration required for a length dimension StringVector acceptableGeometry({"Edge", "Vertex"}); std::vector minimumCounts({1, 2}); - std::vector acceptableDimensionGeometrys({isHorizontal, isDiagonal, isHybrid}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isHorizontal, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid}); execDim(cmd, "DistanceX", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1723,7 +1724,7 @@ void execDistanceY(Gui::Command* cmd) //Define the geometric configuration required for a length dimension StringVector acceptableGeometry({"Edge", "Vertex"}); std::vector minimumCounts({1, 2}); - std::vector acceptableDimensionGeometrys({isVertical, isDiagonal, isHybrid}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isVertical, DimensionGeometry::isDiagonal, DimensionGeometry::isHybrid}); execDim(cmd, "DistanceY", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1770,7 +1771,7 @@ void execAngle(Gui::Command* cmd) //Define the geometric configuration required for a length dimension StringVector acceptableGeometry({"Edge"}); std::vector minimumCounts({2}); - std::vector acceptableDimensionGeometrys({isAngle}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isAngle}); execDim(cmd, "Angle", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1817,7 +1818,7 @@ void execAngle3Pt(Gui::Command* cmd) //Define the geometric configuration required for a length dimension StringVector acceptableGeometry({"Vertex"}); std::vector minimumCounts({3}); - std::vector acceptableDimensionGeometrys({isAngle3Pt}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isAngle3Pt}); execDim(cmd, "Angle3Pt", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -1864,7 +1865,7 @@ void execArea(Gui::Command* cmd) //Define the geometric configuration required for a area dimension StringVector acceptableGeometry({"Face"}); std::vector minimumCounts({1}); - std::vector acceptableDimensionGeometrys({isFace}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isFace}); execDim(cmd, "Area", acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); } @@ -2116,20 +2117,20 @@ void execExtent(Gui::Command* cmd, const std::string& dimType) //Define the geometric configuration required for a extent dimension StringVector acceptableGeometry({"Edge"}); std::vector minimumCounts({1}); - std::vector acceptableDimensionGeometrys({isMultiEdge, - isHorizontal, - isVertical, - isDiagonal, - isCircle, - isEllipse, - isBSplineCircle, - isBSpline, - isZLimited}); + std::vector acceptableDimensionGeometrys({DimensionGeometry::isMultiEdge, + DimensionGeometry::isHorizontal, + DimensionGeometry::isVertical, + DimensionGeometry::isDiagonal, + DimensionGeometry::isCircle, + DimensionGeometry::isEllipse, + DimensionGeometry::isBSplineCircle, + DimensionGeometry::isBSpline, + DimensionGeometry::isZLimited}); //what 2d geometry configuration did we receive? - DimensionGeometryType geometryRefs2d = validateDimSelection( + DimensionGeometry geometryRefs2d = validateDimSelection( references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs2d == TechDraw::isInvalid) { + if (geometryRefs2d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make 2D extent dimension from selection")); @@ -2137,14 +2138,14 @@ void execExtent(Gui::Command* cmd, const std::string& dimType) } //what 3d geometry configuration did we receive? - DimensionGeometryType geometryRefs3d; - if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) { + DimensionGeometry geometryRefs3d; + if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) { geometryRefs3d = validateDimSelection3d(partFeat, references3d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs3d == isInvalid) { + if (geometryRefs3d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make 3D extent dimension from selection")); @@ -2380,7 +2381,7 @@ void CreateTechDrawCommandsDims() //Common code to build a dimension feature -void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector minimumCounts, std::vector acceptableDimensionGeometrys) +void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometry, std::vector minimumCounts, std::vector acceptableDimensionGeometrys) { bool result = _checkDrawViewPart(cmd); if (!result) { @@ -2396,9 +2397,9 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr TechDraw::getReferencesFromSelection(references2d, references3d); //what 2d geometry configuration did we receive? - DimensionGeometryType geometryRefs2d = validateDimSelection( + DimensionGeometry geometryRefs2d = validateDimSelection( references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs2d == TechDraw::isInvalid) { + if (geometryRefs2d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make 2D dimension from selection")); @@ -2406,15 +2407,15 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr } //what 3d geometry configuration did we receive? - DimensionGeometryType geometryRefs3d{TechDraw::isInvalid}; - if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) { + DimensionGeometry geometryRefs3d{DimensionGeometry::isInvalid}; + if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) { geometryRefs3d = validateDimSelection3d(partFeat, references3d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs3d == TechDraw::isInvalid) { + if (geometryRefs3d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make 3D dimension from selection")); @@ -2427,7 +2428,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr //errors and warnings if (type == "Radius" || type == "Diameter") { - if (geometryRefs2d == isEllipse || geometryRefs3d == isEllipse) { + if (geometryRefs2d == DimensionGeometry::isEllipse || geometryRefs3d == DimensionGeometry::isEllipse) { QMessageBox::StandardButton result = QMessageBox::warning( Gui::getMainWindow(), QObject::tr("Ellipse Curve Warning"), @@ -2438,7 +2439,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr return; } } - if (geometryRefs2d == isBSplineCircle || geometryRefs3d == isBSplineCircle) { + if (geometryRefs2d == DimensionGeometry::isBSplineCircle || geometryRefs3d == DimensionGeometry::isBSplineCircle) { QMessageBox::StandardButton result = QMessageBox::warning( Gui::getMainWindow(), QObject::tr("B-spline Curve Warning"), @@ -2449,7 +2450,7 @@ void execDim(Gui::Command* cmd, std::string type, StringVector acceptableGeometr return; } } - if (geometryRefs2d == isBSpline || geometryRefs3d == isBSpline) { + if (geometryRefs2d == DimensionGeometry::isBSpline || geometryRefs3d == DimensionGeometry::isBSpline) { QMessageBox::critical( Gui::getMainWindow(), QObject::tr("B-spline Curve Error"), diff --git a/src/Mod/TechDraw/Gui/DimensionValidators.cpp b/src/Mod/TechDraw/Gui/DimensionValidators.cpp index f45b399bc1..2617ac2276 100644 --- a/src/Mod/TechDraw/Gui/DimensionValidators.cpp +++ b/src/Mod/TechDraw/Gui/DimensionValidators.cpp @@ -40,6 +40,7 @@ using namespace TechDraw; using namespace Measure; using DU = DrawUtil; +using DimensionGeometry = TechDraw::DimensionGeometry; TechDraw::DrawViewPart* TechDraw::getReferencesFromSelection(ReferenceVector& references2d, ReferenceVector& references3d) @@ -95,11 +96,11 @@ TechDraw::DrawViewPart* TechDraw::getReferencesFromSelection(ReferenceVector& re } //! verify that the proposed references contains valid geometries from a 2d DrawViewPart. -DimensionGeometryType TechDraw::validateDimSelection( +DimensionGeometry TechDraw::validateDimSelection( const ReferenceVector& references, //[(dvp*, std::string),...,(dvp*, std::string)] const StringVector& acceptableGeometry,//"Edge", "Vertex", etc const std::vector& minimumCounts, //how many of each geometry are needed for a good dimension - const std::vector& acceptableDimensionGeometrys)//isVertical, isHorizontal, ... + const std::vector& acceptableDimensionGeometrys)//isVertical, isHorizontal, ... { StringVector subNames; TechDraw::DrawViewPart* dvpSave(nullptr); @@ -114,18 +115,18 @@ DimensionGeometryType TechDraw::validateDimSelection( } if (!dvpSave) { //must have 1 DVP in selection - return isInvalid; + return DimensionGeometry::isInvalid; } if (subNames.empty()) { //no geometry referenced. can not make a dim from this mess. We are being called to validate //a selection for a 3d reference - return isViewReference; + return DimensionGeometry::isViewReference; } if (subNames.front().empty()) { //can this still happen? - return isViewReference; + return DimensionGeometry::isViewReference; } //check for invalid geometry descriptors in the subNames @@ -133,7 +134,7 @@ DimensionGeometryType TechDraw::validateDimSelection( acceptableGeometry.end()); if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) { //can not make a dimension from this - return isInvalid; + return DimensionGeometry::isInvalid; } //check for wrong number of geometry @@ -141,7 +142,7 @@ DimensionGeometryType TechDraw::validateDimSelection( GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts); if (!checkGeometryOccurrences(subNames, minimumCountMap)) { //too many or too few geometry descriptors. - return isInvalid; + return DimensionGeometry::isInvalid; } //we have a (potentially valid collection of 2d geometry @@ -151,7 +152,7 @@ DimensionGeometryType TechDraw::validateDimSelection( valid2dReferences.push_back(validEntry); } - DimensionGeometryType foundGeometry = getGeometryConfiguration(valid2dReferences); + DimensionGeometry foundGeometry = getGeometryConfiguration(valid2dReferences); if (acceptableDimensionGeometrys.empty()) { //if the list is empty, we are accepting anything return foundGeometry; @@ -162,16 +163,16 @@ DimensionGeometryType TechDraw::validateDimSelection( } } - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that the proposed references contains valid geometries from non-TechDraw objects. -DimensionGeometryType TechDraw::validateDimSelection3d( +DimensionGeometry TechDraw::validateDimSelection3d( TechDraw::DrawViewPart* dvp, const ReferenceVector& references, //[(dvp*, std::string),...,(dvp*, std::string)] const StringVector& acceptableGeometry,//"Edge", "Vertex", etc const std::vector& minimumCounts, //how many of each geometry are needed for a good dimension - const std::vector& acceptableDimensionGeometrys)//isVertical, isHorizontal, ... + const std::vector& acceptableDimensionGeometrys)//isVertical, isHorizontal, ... { StringVector subNames; for (auto& ref : references) { @@ -185,18 +186,18 @@ DimensionGeometryType TechDraw::validateDimSelection3d( acceptableGeometry.end()); if (!TechDraw::validateSubnameList(subNames, acceptableGeometrySet)) { //can not make a dimension from this - return isInvalid; + return DimensionGeometry::isInvalid; } //check for wrong number of geometry GeomCountMap minimumCountMap = loadRequiredCounts(acceptableGeometry, minimumCounts); if (!checkGeometryOccurrences(subNames, minimumCountMap)) { //too many or too few geometry descriptors. - return isInvalid; + return DimensionGeometry::isInvalid; } //we have a (potentially valid collection of 3d geometry - DimensionGeometryType foundGeometry = getGeometryConfiguration3d(dvp, references); + DimensionGeometry foundGeometry = getGeometryConfiguration3d(dvp, references); if (acceptableDimensionGeometrys.empty()) { //if the list is empty, we are accepting anything return foundGeometry; @@ -207,7 +208,7 @@ DimensionGeometryType TechDraw::validateDimSelection3d( } } - return isInvalid; + return DimensionGeometry::isInvalid; } bool TechDraw::validateSubnameList(StringVector subNames, GeometrySet acceptableGeometrySet) { @@ -263,36 +264,36 @@ bool TechDraw::checkGeometryOccurrences(StringVector subNames, GeomCountMap keye } //return the first valid configuration contained in the already validated references -DimensionGeometryType TechDraw::getGeometryConfiguration(ReferenceVector valid2dReferences) +DimensionGeometry TechDraw::getGeometryConfiguration(ReferenceVector valid2dReferences) { - DimensionGeometryType config = isValidHybrid(valid2dReferences); - if (config > isInvalid) { + DimensionGeometry config = isValidHybrid(valid2dReferences); + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidMultiEdge(valid2dReferences); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidVertexes(valid2dReferences); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidSingleEdge(valid2dReferences.front()); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidSingleFace(valid2dReferences.front()); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } // no valid configuration found - return isInvalid; + return DimensionGeometry::isInvalid; } //return the first valid configuration contained in the already validated references -DimensionGeometryType TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp, +DimensionGeometry TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp, ReferenceVector valid3dReferences) { //first we check for whole object references @@ -307,37 +308,37 @@ DimensionGeometryType TechDraw::getGeometryConfiguration3d(DrawViewPart* dvp, } if (subElementRefs.empty()) { //only whole object references - return isMultiEdge; + return DimensionGeometry::isMultiEdge; } if (!wholeObjectRefs.empty()) { //mix of whole object and subelement refs - return isMultiEdge;//??? correct ??? + return DimensionGeometry::isMultiEdge;//??? correct ??? } //only have subelement refs - DimensionGeometryType config = isValidMultiEdge3d(dvp, valid3dReferences); - if (config > isInvalid) { + DimensionGeometry config = isValidMultiEdge3d(dvp, valid3dReferences); + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidVertexes3d(dvp, valid3dReferences); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidSingleEdge3d(dvp, valid3dReferences.front()); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidSingleFace3d(dvp, valid3dReferences.front()); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } config = isValidHybrid3d(dvp, valid3dReferences); - if (config > isInvalid) { + if (config > DimensionGeometry::isInvalid) { return config; } // no valid configuration found - return isInvalid; + return DimensionGeometry::isInvalid; } //fill the GeomCountMap with pairs made from corresponding items in acceptableGeometry @@ -359,62 +360,62 @@ GeomCountMap TechDraw::loadRequiredCounts(const StringVector& acceptableGeometry } //! verify that Selection contains a valid Geometry for a single Edge Dimension -DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref) +DimensionGeometry TechDraw::isValidSingleEdge(ReferenceEntry ref) { auto objFeat(dynamic_cast(ref.getObject())); if (!objFeat) { - return isInvalid; + return DimensionGeometry::isInvalid; } //the Name starts with "Edge" std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName()); if (geomName != "Edge") { - return isInvalid; + return DimensionGeometry::isInvalid; } //the geometry exists (redundant?) int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName())); TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId); if (!geom) { - return isInvalid; + return DimensionGeometry::isInvalid; } if (geom->getGeomType() == GeomType::GENERIC) { TechDraw::GenericPtr gen1 = std::static_pointer_cast(geom); if (gen1->points.size() < 2) { - return isInvalid; + return DimensionGeometry::isInvalid; } Base::Vector3d line = gen1->points.at(1) - gen1->points.at(0); if (fabs(line.y) < FLT_EPSILON) { - return TechDraw::isHorizontal; + return DimensionGeometry::isHorizontal; } else if (fabs(line.x) < FLT_EPSILON) { - return TechDraw::isVertical; + return DimensionGeometry::isHorizontal; } else { - return TechDraw::isDiagonal; + return DimensionGeometry::isDiagonal; } } else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) { - return isCircle; + return DimensionGeometry::isCircle; } else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) { - return isEllipse; + return DimensionGeometry::isEllipse; } else if (geom->getGeomType() == GeomType::BSPLINE) { TechDraw::BSplinePtr spline = std::static_pointer_cast(geom); if (spline->isCircle()) { - return isBSplineCircle; + return DimensionGeometry::isBSplineCircle; } else { - return isBSpline; + return DimensionGeometry::isBSpline; } } - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that Selection contains a valid Geometry for a single Edge Dimension -DimensionGeometryType TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref) +DimensionGeometry TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref) { (void)dvp; //the Name starts with "Edge" std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName()); if (geomName != "Edge") { - return isInvalid; + return DimensionGeometry::isInvalid; } TopoDS_Shape refShape = ref.getGeometry(); @@ -431,85 +432,85 @@ DimensionGeometryType TechDraw::isValidSingleEdge3d(DrawViewPart* dvp, Reference point1 = dvp->projectPoint(point1); Base::Vector3d line = point1 - point0; if (fabs(line.y) < FLT_EPSILON) { - return TechDraw::isHorizontal; + return DimensionGeometry::isHorizontal; } else if (fabs(line.x) < FLT_EPSILON) { - return TechDraw::isVertical; + return DimensionGeometry::isHorizontal; } // else if (fabs(line.z) < FLT_EPSILON) { // return TechDraw::isZLimited; // } else { - return TechDraw::isDiagonal; + return DimensionGeometry::isDiagonal; } } else if (adapt.GetType() == GeomAbs_Circle) { - return isCircle; + return DimensionGeometry::isCircle; } else if (adapt.GetType() == GeomAbs_Ellipse) { - return isEllipse; + return DimensionGeometry::isEllipse; } else if (adapt.GetType() == GeomAbs_BSplineCurve) { if (GeometryUtils::isCircle(occEdge)) { - return isBSplineCircle; + return DimensionGeometry::isBSplineCircle; } else { - return isBSpline; + return DimensionGeometry::isBSpline; } } - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that Selection contains a valid Geometry for a single Edge Dimension -DimensionGeometryType TechDraw::isValidSingleFace(ReferenceEntry ref) +DimensionGeometry TechDraw::isValidSingleFace(ReferenceEntry ref) { auto objFeat(dynamic_cast(ref.getObject())); if (!objFeat) { - return isInvalid; + return DimensionGeometry::isInvalid; } //the Name starts with "Edge" std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName()); if (geomName != "Face") { - return isInvalid; + return DimensionGeometry::isInvalid; } auto geom = objFeat->getFace(ref.getSubName()); if (!geom) { - return isInvalid; + return DimensionGeometry::isInvalid; } - return isFace; + return DimensionGeometry::isFace; } //! verify that Selection contains a valid Geometry for a single Edge Dimension -DimensionGeometryType TechDraw::isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref) +DimensionGeometry TechDraw::isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref) { (void)dvp; //the Name starts with "Edge" std::string geomName = DrawUtil::getGeomTypeFromName(ref.getSubName()); if (geomName != "Face") { - return isInvalid; + return DimensionGeometry::isInvalid; } TopoDS_Shape refShape = ref.getGeometry(); if (refShape.IsNull() || refShape.ShapeType() != TopAbs_FACE) { Base::Console().Warning("Geometry for reference is not a face.\n"); - return isInvalid; + return DimensionGeometry::isInvalid; } - return isFace; + return DimensionGeometry::isFace; } //! verify that the edge references can make a dimension. Currently only extent //! dimensions support more than 2 edges -DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs) +DimensionGeometry TechDraw::isValidMultiEdge(ReferenceVector refs) { //there has to be at least 2 if (refs.size() < 2) { - return isInvalid; + return DimensionGeometry::isInvalid; } //they all must start with "Edge" const std::string matchToken{"Edge"}; if (!refsMatchToken(refs, matchToken)) { - return isInvalid; + return DimensionGeometry::isInvalid; } auto objFeat0(dynamic_cast(refs.at(0).getObject())); @@ -520,7 +521,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs) if (refs.size() > 2) { //many edges, must be an extent? - return isMultiEdge; + return DimensionGeometry::isMultiEdge; } //exactly 2 edges. could be angle, could be distance @@ -533,7 +534,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs) TechDraw::GenericPtr gen0 = std::static_pointer_cast(geom0); TechDraw::GenericPtr gen1 = std::static_pointer_cast(geom1); if (gen0->points.size() > 2 || gen1->points.size() > 2) {//the edge is a polyline - return isInvalid; //not supported yet + return DimensionGeometry::isInvalid; //not supported yet } Base::Vector3d line0 = gen0->points.at(1) - gen0->points.at(0); line0.Normalize(); @@ -541,27 +542,27 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs) line1.Normalize(); double dot = fabs(line0.Dot(line1)); if (DU::fpCompare(dot, 1.0, EWTOLERANCE)) { - return isDiagonal; //distance || line + return DimensionGeometry::isDiagonal; //distance || line } - return isAngle; //angle or distance + return DimensionGeometry::isAngle; //angle or distance } - return isDiagonal; //two edges, not both straight lines + return DimensionGeometry::isDiagonal; //two edges, not both straight lines } //! verify that the edge references can make a dimension. Currently only extent //! dimensions support more than 2 edges -DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs) +DimensionGeometry TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs) { (void)dvp; //there has to be at least 2 if (refs.size() < 2) { - return isInvalid; + return DimensionGeometry::isInvalid; } //they all must start with "Edge" const std::string matchToken{"Edge"}; if (!refsMatchToken(refs, matchToken)) { - return isInvalid; + return DimensionGeometry::isInvalid; } std::vector edges; @@ -569,7 +570,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV std::vector shapesAll = ShapeExtractor::getShapesFromObject(ref.getObject()); if (shapesAll.empty()) { //reference has no geometry - return isInvalid; + return DimensionGeometry::isInvalid; } } std::vector edgesAll; @@ -577,19 +578,19 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV for (auto& ref : refs) { TopoDS_Shape geometry = ref.getGeometry(); if (geometry.ShapeType() != TopAbs_EDGE) { - return isInvalid; + return DimensionGeometry::isInvalid; } TopoDS_Edge edge = TopoDS::Edge(geometry); BRepAdaptor_Curve adapt(edge); if (adapt.GetType() != GeomAbs_Line) { //not a line, so this must be an extent dim? - return isMultiEdge; + return DimensionGeometry::isMultiEdge; } edgesAll.push_back(edge); } if (edgesAll.size() > 2) { //must be an extent dimension of lines? - return isMultiEdge; + return DimensionGeometry::isMultiEdge; } if (edgesAll.size() == 2) { @@ -604,17 +605,17 @@ DimensionGeometryType TechDraw::isValidMultiEdge3d(DrawViewPart* dvp, ReferenceV auto dot = fabs(line0.Dot(line1)); if (DU::fpCompare(dot, 1.0, EWTOLERANCE)) { //lines are parallel, must be distance dim - return isDiagonal; + return DimensionGeometry::isDiagonal; } //lines are skew, could be angle, could be distance? - return isAngle; + return DimensionGeometry::isAngle; } - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that the vertex references can make a dimension -DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs) +DimensionGeometry TechDraw::isValidVertexes(ReferenceVector refs) { TechDraw::DrawViewPart* dvp(dynamic_cast(refs.front().getObject())); if (!dvp) { @@ -624,7 +625,7 @@ DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs) const std::string matchToken{"Vertex"}; if (!refsMatchToken(refs, matchToken)) { - return isInvalid; + return DimensionGeometry::isInvalid; } if (refs.size() == 2) { @@ -633,28 +634,28 @@ DimensionGeometryType TechDraw::isValidVertexes(ReferenceVector refs) TechDraw::VertexPtr v1 = dvp->getVertex(refs.at(1).getSubName()); Base::Vector3d line = v1->point() - v0->point(); if (fabs(line.y) < FLT_EPSILON) { - return isHorizontal; + return DimensionGeometry::isHorizontal; } else if (fabs(line.x) < FLT_EPSILON) { - return isVertical; + return DimensionGeometry::isHorizontal; } else { - return isDiagonal; + return DimensionGeometry::isDiagonal; } } else if (refs.size() == 3) { //three vertices make an angle dimension - return isAngle3Pt; + return DimensionGeometry::isAngle3Pt; } // did not find a valid configuration - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that the vertex references can make a dimension -DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs) +DimensionGeometry TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs) { (void)dvp; const std::string matchToken{"Vertex"}; if (!refsMatchToken(refs, matchToken)) { - return isInvalid; + return DimensionGeometry::isInvalid; } if (refs.size() == 2) { @@ -663,7 +664,7 @@ DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVe TopoDS_Shape geometry1 = refs.at(1).getGeometry(); if (geometry0.IsNull() || geometry1.IsNull() || geometry0.ShapeType() != TopAbs_VERTEX || geometry1.ShapeType() != TopAbs_VERTEX) { - return isInvalid; + return DimensionGeometry::isInvalid; } Base::Vector3d point0 = DU::toVector3d(BRep_Tool::Pnt(TopoDS::Vertex(geometry0))); point0 = dvp->projectPoint(point0); @@ -671,29 +672,29 @@ DimensionGeometryType TechDraw::isValidVertexes3d(DrawViewPart* dvp, ReferenceVe point1 = dvp->projectPoint(point1); Base::Vector3d line = point1 - point0; if (fabs(line.y) < FLT_EPSILON) { - return isHorizontal; + return DimensionGeometry::isHorizontal; } else if (fabs(line.x) < FLT_EPSILON) { - return isVertical; + return DimensionGeometry::isHorizontal; // } else if(fabs(line.z) < FLT_EPSILON) { // return isZLimited; } else { - return isDiagonal; + return DimensionGeometry::isDiagonal; } } else if (refs.size() == 3) { //three vertices make an angle dimension //we could check here that all the geometries are Vertex - return isAngle3Pt; + return DimensionGeometry::isAngle3Pt; } // did not find a valid configuration - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension -DimensionGeometryType TechDraw::isValidHybrid(ReferenceVector refs) +DimensionGeometry TechDraw::isValidHybrid(ReferenceVector refs) { if (refs.empty()) { - return isInvalid; + return DimensionGeometry::isInvalid; } int vertexCount(0); @@ -707,15 +708,15 @@ DimensionGeometryType TechDraw::isValidHybrid(ReferenceVector refs) } } if (vertexCount > 0 && edgeCount > 0) { - //must be a diagonal dim? could it be isHorizontal or isVertical? - return isHybrid; + //must be a diagonal dim? could it be DimensionGeometry::isHorizontal or isVertical? + return DimensionGeometry::isHybrid; } - return isInvalid; + return DimensionGeometry::isInvalid; } //! verify that the mixed bag (ex Vertex-Edge) of references can make a dimension -DimensionGeometryType TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs) +DimensionGeometry TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs) { (void)dvp; //we can reuse the 2d check here. @@ -723,38 +724,38 @@ DimensionGeometryType TechDraw::isValidHybrid3d(DrawViewPart* dvp, ReferenceVect } //handle situations where revised geometry type is valid but not suitable for existing dimType -long int TechDraw::mapGeometryTypeToDimType(long int dimType, DimensionGeometryType geometry2d, - DimensionGeometryType geometry3d) +long int TechDraw::mapGeometryTypeToDimType(long int dimType, DimensionGeometry geometry2d, + DimensionGeometry geometry3d) { - if (geometry2d == isInvalid && geometry3d == isInvalid) { + if (geometry2d == DimensionGeometry::isInvalid && geometry3d == DimensionGeometry::isInvalid) { //probably an error, but we can't do anything with this return dimType; } - if (geometry2d == isViewReference && geometry3d != isInvalid) { + if (geometry2d == DimensionGeometry::isViewReference && geometry3d != DimensionGeometry::isInvalid) { switch (geometry3d) { - case isDiagonal: + case DimensionGeometry::isDiagonal: return DrawViewDimension::Distance; - case isHorizontal: + case DimensionGeometry::isHorizontal: return DrawViewDimension::DistanceX; - case isVertical: + case DimensionGeometry::isVertical: return DrawViewDimension::DistanceY; - case isAngle: + case DimensionGeometry::isAngle: return DrawViewDimension::Angle; - case isAngle3Pt: + case DimensionGeometry::isAngle3Pt: return DrawViewDimension::Angle3Pt; } - } else if (geometry2d != isViewReference) { + } else if (geometry2d != DimensionGeometry::isViewReference) { switch (geometry2d) { - case isDiagonal: + case DimensionGeometry::isDiagonal: return DrawViewDimension::Distance; - case isHorizontal: + case DimensionGeometry::isHorizontal: return DrawViewDimension::DistanceX; - case isVertical: + case DimensionGeometry::isVertical: return DrawViewDimension::DistanceY; - case isAngle: + case DimensionGeometry::isAngle: return DrawViewDimension::Angle; - case isAngle3Pt: + case DimensionGeometry::isAngle3Pt: return DrawViewDimension::Angle3Pt; } } diff --git a/src/Mod/TechDraw/Gui/DimensionValidators.h b/src/Mod/TechDraw/Gui/DimensionValidators.h index d2865b7527..f70ec0663b 100644 --- a/src/Mod/TechDraw/Gui/DimensionValidators.h +++ b/src/Mod/TechDraw/Gui/DimensionValidators.h @@ -39,67 +39,65 @@ using GeomCountVector = std::vector; using GeomCountMap = std::map; using GeometrySet = std::unordered_set; //queryable unique set of geometrty descriptors -using DimensionGeometryType = int; - namespace TechDraw { class DrawViewPart; -enum DimensionGeometryEnum { - isInvalid, - isHorizontal, - isVertical, - isDiagonal, - isCircle, - isEllipse, - isBSplineCircle, - isBSpline, - isAngle, - isAngle3Pt, - isMultiEdge, - isZLimited, - isHybrid, - isFace, - isViewReference //never needs to be specified in the acceptable list - }; +enum class DimensionGeometry { + isInvalid, + isHorizontal, + isVertical, + isDiagonal, + isCircle, + isEllipse, + isBSplineCircle, + isBSpline, + isAngle, + isAngle3Pt, + isMultiEdge, + isZLimited, + isHybrid, + isFace, + isViewReference //never needs to be specified in the acceptable list +}; DrawViewPart* getReferencesFromSelection(ReferenceVector& references2d, ReferenceVector& references3d); -DimensionGeometryType validateDimSelection(const ReferenceVector& references, +DimensionGeometry validateDimSelection(const ReferenceVector& references, const StringVector& acceptableGeometry,//"Edge", "Vertex", etc const std::vector& minimumCounts, //how many of each geometry are needed for a good dimension - const std::vector& acceptableDimensionGeometrys);//isVertical, isHorizontal, ... -DimensionGeometryType validateDimSelection3d(DrawViewPart* dvp, + const std::vector& acceptableDimensionGeometrys);//isVertical, isHorizontal, ... +DimensionGeometry validateDimSelection3d(DrawViewPart* dvp, const ReferenceVector& references, const StringVector& acceptableGeometry, //"Edge", "Vertex", etc const std::vector& minimumCounts, //how many of each geometry are needed for a good dimension - const std::vector& acceptableDimensionGeometrys);//isVertical, isHorizontal, ... + const std::vector& acceptableDimensionGeometrys);//isVertical, isHorizontal, ... bool validateSubnameList(StringVector subNames, GeometrySet acceptableGeometrySet); -DimensionGeometryType getGeometryConfiguration(ReferenceVector valid2dReferences); -DimensionGeometryType getGeometryConfiguration3d(DrawViewPart* dvp, +DimensionGeometry getGeometryConfiguration(ReferenceVector valid2dReferences); +DimensionGeometry getGeometryConfiguration3d(DrawViewPart* dvp, ReferenceVector valid3dReferences); GeomCountMap loadRequiredCounts(const StringVector& acceptableGeometry, const std::vector& minimumCouts); bool checkGeometryOccurrences(StringVector subNames, GeomCountMap keyedMinimumCounts); -DimensionGeometryType isValidVertexes(ReferenceVector refs); -DimensionGeometryType isValidMultiEdge(ReferenceVector refs); -DimensionGeometryType isValidSingleEdge(ReferenceEntry ref); -DimensionGeometryType isValidSingleFace(ReferenceEntry ref); -DimensionGeometryType isValidHybrid(ReferenceVector refs); +DimensionGeometry isValidVertexes(ReferenceVector refs); +DimensionGeometry isValidMultiEdge(ReferenceVector refs); +DimensionGeometry isValidSingleEdge(ReferenceEntry ref); +DimensionGeometry isValidSingleFace(ReferenceEntry ref); +DimensionGeometry isValidHybrid(ReferenceVector refs); -DimensionGeometryType isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs); -DimensionGeometryType isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs); -DimensionGeometryType isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref); -DimensionGeometryType isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref); -DimensionGeometryType isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs); +DimensionGeometry isValidVertexes3d(DrawViewPart* dvp, ReferenceVector refs); +DimensionGeometry isValidMultiEdge3d(DrawViewPart* dvp, ReferenceVector refs); +DimensionGeometry isValidSingleEdge3d(DrawViewPart* dvp, ReferenceEntry ref); +DimensionGeometry isValidSingleFace3d(DrawViewPart* dvp, ReferenceEntry ref); +DimensionGeometry isValidHybrid3d(DrawViewPart* dvp, ReferenceVector refs); -long int mapGeometryTypeToDimType(long int dimType, DimensionGeometryType geometry2d, - DimensionGeometryType geometry3d); +long int mapGeometryTypeToDimType(long int dimType, DimensionGeometry geometry2d, + DimensionGeometry geometry3d); bool refsMatchToken(const ReferenceVector& refs, const std::string& matchToken); diff --git a/src/Mod/TechDraw/Gui/TaskDimRepair.cpp b/src/Mod/TechDraw/Gui/TaskDimRepair.cpp index b34bd98c7e..aaa73f94e8 100644 --- a/src/Mod/TechDraw/Gui/TaskDimRepair.cpp +++ b/src/Mod/TechDraw/Gui/TaskDimRepair.cpp @@ -128,21 +128,21 @@ void TaskDimRepair::slotUseSelection() StringVector acceptableGeometry({ "Edge", "Vertex", "Face" }); std::vector minimumCounts({1, 1, 1}); - std::vector acceptableDimensionGeometrys;//accept anything - DimensionGeometryType geometryRefs2d = validateDimSelection( + std::vector acceptableDimensionGeometrys;//accept anything + DimensionGeometry geometryRefs2d = validateDimSelection( references2d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs2d == isInvalid) { + if (geometryRefs2d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make dimension from selection")); return; } //what 3d geometry configuration did we receive? - DimensionGeometryType geometryRefs3d(isInvalid); - if (geometryRefs2d == TechDraw::isViewReference && !references3d.empty()) { + DimensionGeometry geometryRefs3d(DimensionGeometry::isInvalid); + if (geometryRefs2d == DimensionGeometry::isViewReference && !references3d.empty()) { geometryRefs3d = validateDimSelection3d( dvp, references3d, acceptableGeometry, minimumCounts, acceptableDimensionGeometrys); - if (geometryRefs3d == isInvalid) { + if (geometryRefs3d == DimensionGeometry::isInvalid) { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Incorrect Selection"), QObject::tr("Can not make dimension from selection"));