diff --git a/src/Mod/TechDraw/App/CenterLine.cpp b/src/Mod/TechDraw/App/CenterLine.cpp
index 9c1363f57a..8ccfee8677 100644
--- a/src/Mod/TechDraw/App/CenterLine.cpp
+++ b/src/Mod/TechDraw/App/CenterLine.cpp
@@ -136,10 +136,10 @@ CenterLine::~CenterLine()
 
 void CenterLine::initialize()
 {
-    m_geometry->setClassOfEdge(ecHARD);
+    m_geometry->setClassOfEdge(EdgeClass::HARD);
     m_geometry->setHlrVisible( true);
     m_geometry->setCosmetic(true);
-    m_geometry->source(CENTERLINE);
+    m_geometry->source(SourceType::CENTERLINE);
 
     createNewTag();
     m_geometry->setCosmeticTag(getTagAsString());
@@ -268,10 +268,10 @@ TechDraw::BaseGeomPtr CenterLine::scaledGeometry(const TechDraw::DrawViewPart* p
     TopoDS_Shape s = ShapeUtils::scaleShape(e, scale);
     TopoDS_Edge newEdge = TopoDS::Edge(s);
     TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
-    newGeom->setClassOfEdge(ecHARD);
+    newGeom->setClassOfEdge(EdgeClass::HARD);
     newGeom->setHlrVisible( true);
     newGeom->setCosmetic(true);
-    newGeom->source(CENTERLINE);
+    newGeom->source(SourceType::CENTERLINE);
     newGeom->setCosmeticTag(getTagAsString());
 
     return newGeom;
@@ -346,10 +346,10 @@ TechDraw::BaseGeomPtr CenterLine::scaledAndRotatedGeometry(TechDraw::DrawViewPar
     if (!newGeom) {
         throw Base::RuntimeError("Failed to create center line");
     }
-    newGeom->setClassOfEdge(ecHARD);
+    newGeom->setClassOfEdge(EdgeClass::HARD);
     newGeom->setHlrVisible( true);
     newGeom->setCosmetic(true);
-    newGeom->source(CENTERLINE);
+    newGeom->source(SourceType::CENTERLINE);
     newGeom->setCosmeticTag(getTagAsString());
 
     return newGeom;
@@ -900,13 +900,13 @@ void CenterLine::Save(Base::Writer &writer) const
     }
 
     writer.Stream() << writer.ind() << "<GeometryType value=\"" << m_geometry->getGeomType() <<"\"/>" << std::endl;
-    if (m_geometry->getGeomType() == TechDraw::GeomType::GENERIC) {
+    if (m_geometry->getGeomType() == GeomType::GENERIC) {
         GenericPtr gen = std::static_pointer_cast<Generic>(m_geometry);
         gen->Save(writer);
-    } else if (m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE) {
+    } else if (m_geometry->getGeomType() == GeomType::CIRCLE) {
         TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(m_geometry);
         circ->Save(writer);
-    } else if (m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
+    } else if (m_geometry->getGeomType() == GeomType::ARCOFCIRCLE) {
         TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(m_geometry);
         aoc->Save(writer);
     } else {
@@ -1000,18 +1000,18 @@ void CenterLine::Restore(Base::XMLReader &reader)
 
 //stored geometry
     reader.readElement("GeometryType");
-    TechDraw::GeomType gType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
-    if (gType == TechDraw::GeomType::GENERIC) {
+    GeomType gType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
+    if (gType == GeomType::GENERIC) {
         TechDraw::GenericPtr gen = std::make_shared<TechDraw::Generic> ();
         gen->Restore(reader);
         gen->setOCCEdge(GeometryUtils::edgeFromGeneric(gen));
         m_geometry = gen;
-    } else if (gType == TechDraw::GeomType::CIRCLE) {
+    } else if (gType == GeomType::CIRCLE) {
         TechDraw::CirclePtr circ = std::make_shared<TechDraw::Circle> ();
         circ->Restore(reader);
         circ->setOCCEdge(GeometryUtils::edgeFromCircle(circ));
         m_geometry = circ;
-    } else if (gType == TechDraw::GeomType::ARCOFCIRCLE) {
+    } else if (gType == GeomType::ARCOFCIRCLE) {
         TechDraw::AOCPtr aoc = std::make_shared<TechDraw::AOC> ();
         aoc->Restore(reader);
         aoc->setOCCEdge(GeometryUtils::edgeFromCircleArc(aoc));
diff --git a/src/Mod/TechDraw/App/Cosmetic.cpp b/src/Mod/TechDraw/App/Cosmetic.cpp
index 923190c74f..7ff83c29c6 100644
--- a/src/Mod/TechDraw/App/Cosmetic.cpp
+++ b/src/Mod/TechDraw/App/Cosmetic.cpp
@@ -46,10 +46,6 @@ using namespace TechDraw;
 using namespace std;
 using DU = DrawUtil;
 
-#define GEOMETRYEDGE 0
-#define COSMETICEDGE 1
-#define CENTERLINE   2
-
 TYPESYSTEM_SOURCE(TechDraw::CosmeticEdge, Base::Persistence)
 
 //note this ctor has no occEdge or first/last point for geometry!
@@ -89,13 +85,13 @@ CosmeticEdge::CosmeticEdge(const TechDraw::BaseGeomPtr g)
     //we assume input edge is already in Yinverted coordinates
     permaStart = m_geometry->getStartPoint();
     permaEnd   = m_geometry->getEndPoint();
-    if ((g->getGeomType() == TechDraw::GeomType::CIRCLE) ||
-       (g->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
+    if ((g->getGeomType() == GeomType::CIRCLE) ||
+       (g->getGeomType() == GeomType::ARCOFCIRCLE)) {
        TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(g);
        permaStart  = circ->center;
        permaEnd    = circ->center;
        permaRadius = circ->radius;
-       if (g->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
+       if (g->getGeomType() == GeomType::ARCOFCIRCLE) {
            TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(circ);
            aoc->clockwiseAngle(g->clockwiseAngle());
            aoc->startPnt = g->getStartPoint();
@@ -115,10 +111,10 @@ CosmeticEdge::~CosmeticEdge()
 
 void CosmeticEdge::initialize()
 {
-    m_geometry->setClassOfEdge(ecHARD);
+    m_geometry->setClassOfEdge(EdgeClass::HARD);
     m_geometry->setHlrVisible( true);
     m_geometry->setCosmetic(true);
-    m_geometry->source(COSMETICEDGE);
+    m_geometry->source(SourceType::COSMETICEDGE);
 
     createNewTag();
     m_geometry->setCosmeticTag(getTagAsString());
@@ -137,10 +133,10 @@ TechDraw::BaseGeomPtr CosmeticEdge::scaledGeometry(const double scale)
     TopoDS_Shape s = ShapeUtils::scaleShape(e, scale);
     TopoDS_Edge newEdge = TopoDS::Edge(s);
     TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
-    newGeom->setClassOfEdge(ecHARD);
+    newGeom->setClassOfEdge(EdgeClass::HARD);
     newGeom->setHlrVisible( true);
     newGeom->setCosmetic(true);
-    newGeom->source(COSMETICEDGE);
+    newGeom->source(SourceType::COSMETICEDGE);
     newGeom->setCosmeticTag(getTagAsString());
     return newGeom;
 }
@@ -156,10 +152,10 @@ TechDraw::BaseGeomPtr CosmeticEdge::scaledAndRotatedGeometry(const double scale,
     s = ShapeUtils::mirrorShape(s);
     TopoDS_Edge newEdge = TopoDS::Edge(s);
     TechDraw::BaseGeomPtr newGeom = TechDraw::BaseGeom::baseFactory(newEdge);
-    newGeom->setClassOfEdge(ecHARD);
+    newGeom->setClassOfEdge(EdgeClass::HARD);
     newGeom->setHlrVisible( true);
     newGeom->setCosmetic(true);
-    newGeom->source(COSMETICEDGE);
+    newGeom->source(SourceType::COSMETICEDGE);
     newGeom->setCosmeticTag(getTagAsString());
     newGeom->clockwiseAngle(saveCW);
     return newGeom;
@@ -223,13 +219,13 @@ void CosmeticEdge::Save(Base::Writer &writer) const
     writer.Stream() << writer.ind() << "<Visible value=\"" <<  v << "\"/>" << endl;
 
     writer.Stream() << writer.ind() << "<GeometryType value=\"" << m_geometry->getGeomType() <<"\"/>" << endl;
-    if (m_geometry->getGeomType() == TechDraw::GeomType::GENERIC) {
+    if (m_geometry->getGeomType() == GeomType::GENERIC) {
         GenericPtr gen = std::static_pointer_cast<Generic>(m_geometry);
         gen->Save(writer);
-    } else if (m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE) {
+    } else if (m_geometry->getGeomType() == GeomType::CIRCLE) {
         TechDraw::CirclePtr circ = std::static_pointer_cast<TechDraw::Circle>(m_geometry);
         circ->Save(writer);
-    } else if (m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
+    } else if (m_geometry->getGeomType() == GeomType::ARCOFCIRCLE) {
         TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(m_geometry);
         aoc->inverted()->Save(writer);
     } else {
@@ -259,16 +255,16 @@ void CosmeticEdge::Restore(Base::XMLReader &reader)
     m_format.setVisible(reader.getAttributeAsInteger("value") != 0);
 
     reader.readElement("GeometryType");
-    TechDraw::GeomType gType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
+    GeomType gType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
 
-    if (gType == TechDraw::GeomType::GENERIC) {
+    if (gType == GeomType::GENERIC) {
         TechDraw::GenericPtr gen = std::make_shared<TechDraw::Generic> ();
         gen->Restore(reader);
         gen->setOCCEdge(GeometryUtils::edgeFromGeneric(gen));
         m_geometry = gen;
         permaStart = gen->getStartPoint();
         permaEnd   = gen->getEndPoint();
-    } else if (gType == TechDraw::GeomType::CIRCLE) {
+    } else if (gType == GeomType::CIRCLE) {
         TechDraw::CirclePtr circ = std::make_shared<TechDraw::Circle> ();
         circ->Restore(reader);
         circ->setOCCEdge(GeometryUtils::edgeFromCircle(circ));
@@ -276,7 +272,7 @@ void CosmeticEdge::Restore(Base::XMLReader &reader)
         permaRadius = circ->radius;
         permaStart  = circ->center;
         permaEnd    = circ->center;
-    } else if (gType == TechDraw::GeomType::ARCOFCIRCLE) {
+    } else if (gType == GeomType::ARCOFCIRCLE) {
         TechDraw::AOCPtr aoc = std::make_shared<TechDraw::AOC> ();
         aoc->Restore(reader);
         aoc->setOCCEdge(GeometryUtils::edgeFromCircleArc(aoc));
diff --git a/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp b/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
index 5476544dc0..5cab4be262 100644
--- a/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
+++ b/src/Mod/TechDraw/App/CosmeticEdgePyImp.cpp
@@ -231,9 +231,9 @@ void CosmeticEdgePy::setEnd(Py::Vector arg)
 
 Py::Float CosmeticEdgePy::getRadius() const
 {
-    TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
-    if ( (gt != TechDraw::GeomType::CIRCLE) &&
-         (gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
+    GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
+    if ( (gt != GeomType::CIRCLE) &&
+         (gt != GeomType::ARCOFCIRCLE) ) {
         throw Py::TypeError("Not a circle. Can not get radius");
     }
     double r = getCosmeticEdgePtr()->permaRadius;
@@ -242,9 +242,9 @@ Py::Float CosmeticEdgePy::getRadius() const
 
 void CosmeticEdgePy::setRadius(Py::Float arg)
 {
-    TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
-    if ( (gt != TechDraw::GeomType::CIRCLE) &&
-         (gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
+    GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
+    if ( (gt != GeomType::CIRCLE) &&
+         (gt != GeomType::ARCOFCIRCLE) ) {
         throw Py::TypeError("Not a circle. Can not set radius");
     }
 
@@ -258,9 +258,9 @@ void CosmeticEdgePy::setRadius(Py::Float arg)
 
 Py::Vector CosmeticEdgePy::getCenter() const
 {
-    TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
-    if ( (gt != TechDraw::GeomType::CIRCLE) &&
-         (gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
+    GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
+    if ( (gt != GeomType::CIRCLE) &&
+         (gt != GeomType::ARCOFCIRCLE) ) {
         throw Py::TypeError("Not a circle. Can not get center");
     }
     Base::Vector3d point = getCosmeticEdgePtr()->permaStart;
@@ -270,10 +270,10 @@ Py::Vector CosmeticEdgePy::getCenter() const
 
 void CosmeticEdgePy::setCenter(Py::Vector arg)
 {
-    TechDraw::GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
+    GeomType gt = getCosmeticEdgePtr()->m_geometry->getGeomType();
 //    PyObject* p = arg.ptr();
-    if ( (gt != TechDraw::GeomType::CIRCLE) &&
-         (gt != TechDraw::GeomType::ARCOFCIRCLE) ) {
+    if ( (gt != GeomType::CIRCLE) &&
+         (gt != GeomType::ARCOFCIRCLE) ) {
         throw Py::TypeError("Not a circle. Can not set center");
     }
 
diff --git a/src/Mod/TechDraw/App/CosmeticExtension.cpp b/src/Mod/TechDraw/App/CosmeticExtension.cpp
index 3bf122c2f5..cd42e7a17b 100644
--- a/src/Mod/TechDraw/App/CosmeticExtension.cpp
+++ b/src/Mod/TechDraw/App/CosmeticExtension.cpp
@@ -328,7 +328,7 @@ void CosmeticExtension::refreshCEGeoms()
     std::vector<TechDraw::BaseGeomPtr> gEdges = getOwner()->getEdgeGeometry();
     std::vector<TechDraw::BaseGeomPtr> oldGEdges;
     for (auto& ge : gEdges) {
-        if (ge->source() != SourceType::COSEDGE) {
+        if (ge->source() != SourceType::COSMETICEDGE) {
             oldGEdges.push_back(ge);
         }
     }
diff --git a/src/Mod/TechDraw/App/DrawUtil.cpp b/src/Mod/TechDraw/App/DrawUtil.cpp
index 833ac66051..def1417792 100644
--- a/src/Mod/TechDraw/App/DrawUtil.cpp
+++ b/src/Mod/TechDraw/App/DrawUtil.cpp
@@ -1859,7 +1859,7 @@ bool DrawUtil::isCosmeticEdge(App::DocumentObject* owner, std::string element)
 {
     auto ownerView = static_cast<TechDraw::DrawViewPart*>(owner);
     auto edge = ownerView->getEdge(element);
-    if (edge && edge->source() == 1 && edge->getCosmetic()) {
+    if (edge && edge->source() == SourceType::COSMETICEDGE && edge->getCosmetic()) {
         return true;
     }
     return false;
@@ -1870,7 +1870,7 @@ bool DrawUtil::isCenterLine(App::DocumentObject* owner, std::string element)
 {
     auto ownerView = static_cast<TechDraw::DrawViewPart*>(owner);
     auto edge = ownerView->getEdge(element);
-    if (edge && edge->source() == 2 && edge->getCosmetic()) {
+    if (edge && edge->source() == SourceType::CENTERLINE && edge->getCosmetic()) {
         return true;
     }
     return false;
diff --git a/src/Mod/TechDraw/App/DrawViewDimension.cpp b/src/Mod/TechDraw/App/DrawViewDimension.cpp
index 842c1075c5..ca78906b04 100644
--- a/src/Mod/TechDraw/App/DrawViewDimension.cpp
+++ b/src/Mod/TechDraw/App/DrawViewDimension.cpp
@@ -821,7 +821,7 @@ pointPair DrawViewDimension::getPointsOneEdge(ReferenceVector references)
             ssMessage << getNameInDocument() << " can not find geometry for 2d reference (1)";
             throw Base::RuntimeError(ssMessage.str());
         }
-        if (geom->getGeomType() != TechDraw::GeomType::GENERIC) {
+        if (geom->getGeomType() != GeomType::GENERIC) {
             std::stringstream ssMessage;
             ssMessage << getNameInDocument() << " 2d reference is a " << geom->geomTypeName();
             throw Base::RuntimeError(ssMessage.str());
@@ -1007,12 +1007,12 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
     arcPoints pts;
     pts.center = Base::Vector3d(0.0, 0.0, 0.0);
     pts.radius = 0.0;
-    if ((base && base->getGeomType() == TechDraw::GeomType::CIRCLE)
-        || (base && base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
+    if ((base && base->getGeomType() == GeomType::CIRCLE)
+        || (base && base->getGeomType() == GeomType::ARCOFCIRCLE)) {
         circle = std::static_pointer_cast<TechDraw::Circle>(base);
         pts.center = Base::Vector3d(circle->center.x, circle->center.y, 0.0);
         pts.radius = circle->radius;
-        if (base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
+        if (base->getGeomType() == GeomType::ARCOFCIRCLE) {
             TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(circle);
             pts.isArc = true;
             pts.onCurve.first(Base::Vector3d(aoc->midPnt.x, aoc->midPnt.y, 0.0));
@@ -1029,8 +1029,8 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
                 pts.center + Base::Vector3d(-1, 0, 0) * circle->radius);  // arbitrary point on edge
         }
     }
-    else if ((base && base->getGeomType() == TechDraw::GeomType::ELLIPSE)
-             || (base && base->getGeomType() == TechDraw::GeomType::ARCOFELLIPSE)) {
+    else if ((base && base->getGeomType() == GeomType::ELLIPSE)
+             || (base && base->getGeomType() == GeomType::ARCOFELLIPSE)) {
         TechDraw::EllipsePtr ellipse = std::static_pointer_cast<TechDraw::Ellipse>(base);
         if (ellipse->closed()) {
             double r1 = ellipse->minor;
@@ -1063,7 +1063,7 @@ arcPoints DrawViewDimension::arcPointsFromBaseGeom(TechDraw::BaseGeomPtr base)
                                + Base::Vector3d(-1, 0, 0) * rAvg);  // arbitrary point on edge
         }
     }
-    else if (base && base->getGeomType() == TechDraw::GeomType::BSPLINE) {
+    else if (base && base->getGeomType() == GeomType::BSPLINE) {
         TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
         if (spline->isCircle()) {
             bool arc{false};
@@ -1219,13 +1219,13 @@ anglePoints DrawViewDimension::getAnglePointsTwoEdges(ReferenceVector references
             ssMessage << getNameInDocument() << " can not find geometry for 2d reference (5)";
             throw Base::RuntimeError(ssMessage.str());
         }
-        if (geom0->getGeomType() != TechDraw::GeomType::GENERIC) {
+        if (geom0->getGeomType() != GeomType::GENERIC) {
             std::stringstream ssMessage;
             ssMessage << getNameInDocument() << " first 2d reference is a "
                       << geom0->geomTypeName();
             throw Base::RuntimeError(ssMessage.str());
         }
-        if (geom1->getGeomType() != TechDraw::GeomType::GENERIC) {
+        if (geom1->getGeomType() != GeomType::GENERIC) {
             std::stringstream ssMessage;
             ssMessage << getNameInDocument() << " second 2d reference is a "
                       << geom0->geomTypeName();
@@ -1977,13 +1977,13 @@ bool DrawViewDimension::leaderIntersectsArc(Base::Vector3d s, Base::Vector3d poi
     const std::vector<std::string>& subElements = References2D.getSubValues();
     int idx = DrawUtil::getIndexFromName(subElements[0]);
     TechDraw::BaseGeomPtr base = getViewPart()->getGeomByIndex(idx);
-    if (base && base->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE) {
+    if (base && base->getGeomType() == GeomType::ARCOFCIRCLE) {
         TechDraw::AOCPtr aoc = std::static_pointer_cast<TechDraw::AOC>(base);
         if (aoc->intersectsArc(s, pointOnCircle)) {
             result = true;
         }
     }
-    else if (base && base->getGeomType() == TechDraw::GeomType::BSPLINE) {
+    else if (base && base->getGeomType() == GeomType::BSPLINE) {
         TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(base);
         if (spline->isCircle()) {
             if (spline->intersectsArc(s, pointOnCircle)) {
diff --git a/src/Mod/TechDraw/App/Geometry.cpp b/src/Mod/TechDraw/App/Geometry.cpp
index a70bf33812..19db1c4b92 100644
--- a/src/Mod/TechDraw/App/Geometry.cpp
+++ b/src/Mod/TechDraw/App/Geometry.cpp
@@ -101,10 +101,6 @@ using DU = DrawUtil;
 using BRepAdaptor_HCurve = BRepAdaptor_Curve;
 #endif
 
-#define GEOMETRYEDGE 0
-#define COSMETICEDGE 1
-#define CENTERLINE   2
-
 // Collection of Geometric Features
 Wire::Wire()
 {
@@ -195,14 +191,14 @@ Face::~Face()
 }
 
 BaseGeom::BaseGeom() :
-    geomType(NOTDEF),
-    extractType(Plain),             //obs
-    classOfEdge(ecNONE),
+    geomType(GeomType::NOTDEF),
+    extractType(ExtractionType::Plain),             //obs
+    classOfEdge(EdgeClass::NONE),
     hlrVisible(true),
     reversed(false),
     ref3D(-1),                      //obs?
     cosmetic(false),
-    m_source(0),
+    m_source(SourceType::GEOMETRY),
     m_sourceIndex(-1)
 {
     occEdge = TopoDS_Edge();
@@ -270,7 +266,7 @@ void BaseGeom::Save(Base::Writer &writer) const
     writer.Stream() << writer.ind() << "<Ref3D value=\"" << ref3D << "\"/>" << endl;
     const char c = cosmetic?'1':'0';
     writer.Stream() << writer.ind() << "<Cosmetic value=\"" << c << "\"/>" << endl;
-    writer.Stream() << writer.ind() << "<Source value=\"" << m_source << "\"/>" << endl;
+    writer.Stream() << writer.ind() << "<Source value=\"" << m_source << "\"/>" << endl; // Should this save as text and not number?
     writer.Stream() << writer.ind() << "<SourceIndex value=\"" << m_sourceIndex << "\"/>" << endl;
     writer.Stream() << writer.ind() << "<CosmeticTag value=\"" <<  cosmeticTag << "\"/>" << endl;
 //    writer.Stream() << writer.ind() << "<Tag value=\"" <<  getTagAsString() << "\"/>" << endl;
@@ -279,11 +275,11 @@ void BaseGeom::Save(Base::Writer &writer) const
 void BaseGeom::Restore(Base::XMLReader &reader)
 {
     reader.readElement("GeomType");
-    geomType = static_cast<TechDraw::GeomType>(reader.getAttributeAsInteger("value"));
+    geomType = static_cast<GeomType>(reader.getAttributeAsInteger("value"));
     reader.readElement("ExtractType");
-    extractType = static_cast<TechDraw::ExtractionType>(reader.getAttributeAsInteger("value"));
+    extractType = static_cast<ExtractionType>(reader.getAttributeAsInteger("value"));
     reader.readElement("EdgeClass");
-    classOfEdge = static_cast<TechDraw::edgeClass>(reader.getAttributeAsInteger("value"));
+    classOfEdge = static_cast<EdgeClass>(reader.getAttributeAsInteger("value"));
     reader.readElement("HLRVisible");
     hlrVisible = reader.getAttributeAsInteger("value") != 0;
     reader.readElement("Reversed");
@@ -293,7 +289,7 @@ void BaseGeom::Restore(Base::XMLReader &reader)
     reader.readElement("Cosmetic");
     cosmetic = reader.getAttributeAsInteger("value") != 0;
     reader.readElement("Source");
-    m_source = reader.getAttributeAsInteger("value");
+    m_source = static_cast<SourceType>(reader.getAttributeAsInteger("value"));
     reader.readElement("SourceIndex");
     m_sourceIndex = reader.getAttributeAsInteger("value");
     reader.readElement("CosmeticTag");
@@ -470,11 +466,8 @@ std::string BaseGeom::geomTypeName()
         "Bezier",
         "BSpline",
         "Line",         //why was this ever called "Generic"?
-        "Unknown" } ;
-    if (geomType >= typeNames.size()) {
-        return "Unknown";
-    }
-    return typeNames.at(geomType);
+    };
+    return typeNames.at(static_cast<int>(geomType));
 }
 
 //! Convert 1 OCC edge into 1 BaseGeom (static factory method)
@@ -651,7 +644,7 @@ TopoShape BaseGeom::asTopoShape(double scale)
 
 Ellipse::Ellipse(const TopoDS_Edge &e)
 {
-    geomType = ELLIPSE;
+    geomType = GeomType::ELLIPSE;
     BRepAdaptor_Curve c(e);
     occEdge = e;
     gp_Elips ellp = c.Ellipse();
@@ -668,7 +661,7 @@ Ellipse::Ellipse(const TopoDS_Edge &e)
 
 Ellipse::Ellipse(Base::Vector3d c, double mnr, double mjr)
 {
-    geomType = ELLIPSE;
+    geomType = GeomType::ELLIPSE;
     center = c;
     major = mjr;
     minor = mnr;
@@ -688,7 +681,7 @@ Ellipse::Ellipse(Base::Vector3d c, double mnr, double mjr)
 
 AOE::AOE(const TopoDS_Edge &e) : Ellipse(e)
 {
-    geomType = ARCOFELLIPSE;
+    geomType = GeomType::ARCOFELLIPSE;
 
     BRepAdaptor_Curve c(e);
     double f = c.FirstParameter();
@@ -725,14 +718,14 @@ AOE::AOE(const TopoDS_Edge &e) : Ellipse(e)
 
 Circle::Circle()
 {
-    geomType = CIRCLE;
+    geomType = GeomType::CIRCLE;
     radius = 0.0;
     center = Base::Vector3d(0.0, 0.0, 0.0);
 }
 
 Circle::Circle(Base::Vector3d c, double r)
 {
-    geomType = CIRCLE;
+    geomType = GeomType::CIRCLE;
     radius = r;
     center = c;
     gp_Pnt loc(c.x, c.y, c.z);
@@ -753,7 +746,7 @@ Circle::Circle(Base::Vector3d c, double r)
 
 Circle::Circle(const TopoDS_Edge &e)
 {
-    geomType = CIRCLE;             //center, radius
+    geomType = GeomType::CIRCLE;             //center, radius
     BRepAdaptor_Curve c(e);
     occEdge = e;
 
@@ -802,7 +795,7 @@ void Circle::Restore(Base::XMLReader &reader)
 
 AOC::AOC(const TopoDS_Edge &e) : Circle(e)
 {
-    geomType = ARCOFCIRCLE;
+    geomType = GeomType::ARCOFCIRCLE;
     BRepAdaptor_Curve c(e);
 
     double f = c.FirstParameter();
@@ -834,7 +827,7 @@ AOC::AOC(const TopoDS_Edge &e) : Circle(e)
 
 AOC::AOC(Base::Vector3d c, double r, double sAng, double eAng) : Circle()
 {
-    geomType = ARCOFCIRCLE;
+    geomType = GeomType::ARCOFCIRCLE;
 
     radius = r;
     center = c;
@@ -883,7 +876,7 @@ AOC::AOC(Base::Vector3d c, double r, double sAng, double eAng) : Circle()
 
 AOC::AOC() : Circle()
 {
-    geomType = ARCOFCIRCLE;
+    geomType = GeomType::ARCOFCIRCLE;
 
     startPnt = Base::Vector3d(0.0, 0.0, 0.0);
     endPnt = Base::Vector3d(0.0, 0.0, 0.0);
@@ -1028,7 +1021,7 @@ void AOC::Restore(Base::XMLReader &reader)
 //! Generic is a multiline
 Generic::Generic(const TopoDS_Edge &e)
 {
-    geomType = GENERIC;
+    geomType = GeomType::GENERIC;
     occEdge = e;
     BRepLib::BuildCurve3d(occEdge);
 
@@ -1055,7 +1048,7 @@ Generic::Generic(const TopoDS_Edge &e)
 
 Generic::Generic()
 {
-    geomType = GENERIC;
+    geomType = GeomType::GENERIC;
 }
 
 std::string Generic::toString() const
@@ -1145,7 +1138,7 @@ Base::Vector3d Generic::apparentInter(GenericPtr g)
 
 BSpline::BSpline(const TopoDS_Edge &e)
 {
-    geomType = BSPLINE;
+    geomType = GeomType::BSPLINE;
     BRepAdaptor_Curve c(e);
     isArc = !c.IsClosed();
     Handle(Geom_BSplineCurve) cSpline = c.BSpline();
@@ -1260,7 +1253,7 @@ bool BSpline::intersectsArc(Base::Vector3d p1, Base::Vector3d p2)
 
 BezierSegment::BezierSegment(const TopoDS_Edge &e)
 {
-    geomType = BEZIER;
+    geomType = GeomType::BEZIER;
     occEdge = e;
     BRepAdaptor_Curve c(e);
     Handle(Geom_BezierCurve) bez = c.Bezier();
diff --git a/src/Mod/TechDraw/App/Geometry.h b/src/Mod/TechDraw/App/Geometry.h
index 93909deadd..6ee4ce1ba3 100644
--- a/src/Mod/TechDraw/App/Geometry.h
+++ b/src/Mod/TechDraw/App/Geometry.h
@@ -45,22 +45,22 @@ namespace TechDraw {
 
 class DrawViewPart;
 
-enum ExtractionType {               //obs
+enum class ExtractionType : int {               //obs
     Plain,
     WithHidden,
     WithSmooth
 };
 
-enum edgeClass {
-    ecNONE,  // Not used, OCC index starts at 1
-    ecUVISO,
-    ecOUTLINE,
-    ecSMOOTH,
-    ecSEAM,
-    ecHARD
+enum class EdgeClass : int {
+    NONE,  // Not used, OCC index starts at 1
+    UVISO,
+    OUTLINE,
+    SMOOTH,
+    SEAM,
+    HARD
 };
 
-enum GeomType {
+enum class GeomType : int {
     NOTDEF,
     CIRCLE,
     ARCOFCIRCLE,
@@ -71,12 +71,24 @@ enum GeomType {
     GENERIC
 };
 
-enum SourceType {
-    GEOM,
-    COSEDGE,
+enum class SourceType : int {
+    GEOMETRY,
+    COSMETICEDGE,
     CENTERLINE
 };
 
+template <typename T, std::enable_if_t<
+    std::is_same_v<EdgeClass, T> ||
+    std::is_same_v<ExtractionType, T> ||
+    std::is_same_v<GeomType, T> ||
+    std::is_same_v<SourceType, T>,
+    bool
+> =true>
+std::ostream& operator<<(std::ostream& out, const T& type) {
+    out << static_cast<int>(type);
+    return out;
+}
+
 class BaseGeom;
 using BaseGeomPtr = std::shared_ptr<BaseGeom>;
 class Circle;
@@ -131,8 +143,8 @@ class TechDrawExport BaseGeom : public std::enable_shared_from_this<BaseGeom>
         // attribute setters and getters
         GeomType getGeomType() { return geomType; }
         void setGeomType(GeomType type) { geomType = type; }
-        edgeClass getClassOfEdge() { return classOfEdge; }
-        void setClassOfEdge(edgeClass newClass) { classOfEdge = newClass; }
+        EdgeClass getClassOfEdge() { return classOfEdge; }
+        void setClassOfEdge(EdgeClass newClass) { classOfEdge = newClass; }
         bool getHlrVisible() { return hlrVisible; }
         void setHlrVisible(bool state) { hlrVisible = state; }
         bool getReversed()  { return reversed; }
@@ -143,8 +155,8 @@ class TechDrawExport BaseGeom : public std::enable_shared_from_this<BaseGeom>
         void setOCCEdge(TopoDS_Edge newEdge)  { occEdge = newEdge; }
         bool getCosmetic()  { return cosmetic; }
         void setCosmetic (bool state)  { cosmetic = state; }
-        int source() { return m_source; }
-        void source(int s) { m_source = s; }
+        SourceType source() { return m_source; }
+        void source(SourceType s) { m_source = s; }
         int sourceIndex() { return m_sourceIndex; }
         void sourceIndex(int si) { m_sourceIndex = si; }
         std::string getCosmeticTag() { return cosmeticTag; }
@@ -161,14 +173,14 @@ protected:
 
         GeomType geomType;
         ExtractionType extractType;     //obs
-        edgeClass classOfEdge;
+        EdgeClass classOfEdge;
         bool hlrVisible;
         bool reversed;
         int ref3D;                      //obs?
         TopoDS_Edge occEdge;            //projected Edge
         bool cosmetic;
         //TODO: all these attributes should be private
-        int m_source;         //0 - geom, 1 - cosmetic edge, 2 - centerline
+        SourceType m_source;
         int m_sourceIndex;
         std::string cosmeticTag;
         boost::uuids::uuid tag;
diff --git a/src/Mod/TechDraw/App/GeometryObject.cpp b/src/Mod/TechDraw/App/GeometryObject.cpp
index c9cc277c69..b56e54943f 100644
--- a/src/Mod/TechDraw/App/GeometryObject.cpp
+++ b/src/Mod/TechDraw/App/GeometryObject.cpp
@@ -99,16 +99,16 @@ const BaseGeomPtrVector GeometryObject::getVisibleFaceEdges(const bool smooth,
     for (auto& e : edgeGeom) {
         if (e->getHlrVisible()) {
             switch (e->getClassOfEdge()) {
-                case ecHARD:
-                case ecOUTLINE:
+                case EdgeClass::HARD:
+                case EdgeClass::OUTLINE:
                     result.push_back(e);
                     break;
-                case ecSMOOTH:
+                case EdgeClass::SMOOTH:
                     if (smoothOK) {
                         result.push_back(e);
                     }
                     break;
-                case ecSEAM:
+                case EdgeClass::SEAM:
                     if (seamOK) {
                         result.push_back(e);
                     }
@@ -251,9 +251,9 @@ void GeometryObject::projectShape(const TopoDS_Shape& inShape, const gp_Ax2& vie
 void GeometryObject::makeTDGeometry()
 {
 //    Base::Console().Message("GO::makeTDGeometry()\n");
-    extractGeometry(TechDraw::ecHARD,                   //always show the hard&outline visible lines
+    extractGeometry(EdgeClass::HARD,                   //always show the hard&outline visible lines
                         true);
-    extractGeometry(TechDraw::ecOUTLINE,
+    extractGeometry(EdgeClass::OUTLINE,
                         true);
 
     const DrawViewPart* dvp = static_cast<const DrawViewPart*>(m_parent);
@@ -262,26 +262,26 @@ void GeometryObject::makeTDGeometry()
     }
 
     if (dvp->SmoothVisible.getValue()) {
-        extractGeometry(TechDraw::ecSMOOTH, true);
+        extractGeometry(EdgeClass::SMOOTH, true);
     }
     if (dvp->SeamVisible.getValue()) {
-        extractGeometry(TechDraw::ecSEAM, true);
+        extractGeometry(EdgeClass::SEAM, true);
     }
     if ((dvp->IsoVisible.getValue()) && (dvp->IsoCount.getValue() > 0)) {
-        extractGeometry(TechDraw::ecUVISO, true);
+        extractGeometry(EdgeClass::UVISO, true);
     }
     if (dvp->HardHidden.getValue()) {
-        extractGeometry(TechDraw::ecHARD, false);
-        extractGeometry(TechDraw::ecOUTLINE, false);
+        extractGeometry(EdgeClass::HARD, false);
+        extractGeometry(EdgeClass::OUTLINE, false);
     }
     if (dvp->SmoothHidden.getValue()) {
-        extractGeometry(TechDraw::ecSMOOTH, false);
+        extractGeometry(EdgeClass::SMOOTH, false);
     }
     if (dvp->SeamHidden.getValue()) {
-        extractGeometry(TechDraw::ecSEAM, false);
+        extractGeometry(EdgeClass::SEAM, false);
     }
     if (dvp->IsoHidden.getValue() && (dvp->IsoCount.getValue() > 0)) {
-        extractGeometry(TechDraw::ecUVISO, false);
+        extractGeometry(EdgeClass::UVISO, false);
     }
 }
 
@@ -452,54 +452,54 @@ TopoDS_Shape GeometryObject::projectFace(const TopoDS_Shape& face, const gp_Ax2&
 }
 
 //!add edges meeting filter criteria for category, visibility
-void GeometryObject::extractGeometry(edgeClass category, bool hlrVisible)
+void GeometryObject::extractGeometry(EdgeClass category, bool hlrVisible)
 {
     //    Base::Console().Message("GO::extractGeometry(%d, %d)\n", category, hlrVisible);
     TopoDS_Shape filtEdges;
     if (hlrVisible) {
         switch (category) {
-            case ecHARD:
+            case EdgeClass::HARD:
                 filtEdges = visHard;
                 break;
-            case ecOUTLINE:
+            case EdgeClass::OUTLINE:
                 filtEdges = visOutline;
                 break;
-            case ecSMOOTH:
+            case EdgeClass::SMOOTH:
                 filtEdges = visSmooth;
                 break;
-            case ecSEAM:
+            case EdgeClass::SEAM:
                 filtEdges = visSeam;
                 break;
-            case ecUVISO:
+            case EdgeClass::UVISO:
                 filtEdges = visIso;
                 break;
             default:
                 Base::Console().Warning(
-                    "GeometryObject::ExtractGeometry - unsupported hlrVisible edgeClass: %d\n",
+                    "GeometryObject::ExtractGeometry - unsupported hlrVisible EdgeClass: %d\n",
                     static_cast<int>(category));
                 return;
         }
     }
     else {
         switch (category) {
-            case ecHARD:
+            case EdgeClass::HARD:
                 filtEdges = hidHard;
                 break;
-            case ecOUTLINE:
+            case EdgeClass::OUTLINE:
                 filtEdges = hidOutline;
                 break;
-            case ecSMOOTH:
+            case EdgeClass::SMOOTH:
                 filtEdges = hidSmooth;
                 break;
-            case ecSEAM:
+            case EdgeClass::SEAM:
                 filtEdges = hidSeam;
                 break;
-            case ecUVISO:
+            case EdgeClass::UVISO:
                 filtEdges = hidIso;
                 break;
             default:
                 Base::Console().Warning(
-                    "GeometryObject::ExtractGeometry - unsupported hidden edgeClass: %d\n",
+                    "GeometryObject::ExtractGeometry - unsupported hidden EdgeClass: %d\n",
                     static_cast<int>(category));
                 return;
         }
@@ -509,7 +509,7 @@ void GeometryObject::extractGeometry(edgeClass category, bool hlrVisible)
 }
 
 //! update edgeGeom and vertexGeom from Compound of edges
-void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass category,
+void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, EdgeClass category,
                                          bool hlrVisible)
 {
 //    Base::Console().Message("GO::addGeomFromCompound(%d, %d)\n", category, hlrVisible);
@@ -552,7 +552,7 @@ void GeometryObject::addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass ca
             //            throw Base::ValueError("GeometryObject::addGeomFromCompound - baseFactory failed");
         }
 
-        base->source(0);//object geometry
+        base->source(SourceType::GEOMETRY);
         base->sourceIndex(i - 1);
         base->setClassOfEdge(category);
         base->setHlrVisible(hlrVisible);
@@ -707,7 +707,7 @@ int GeometryObject::addCosmeticEdge(Base::Vector3d start, Base::Vector3d end, st
     TechDraw::BaseGeomPtr base = BaseGeom::baseFactory(occEdge);
     base->setCosmetic(true);
     base->setCosmeticTag(tagString);
-    base->source(1);//1-CosmeticEdge, 2-CenterLine
+    base->source(SourceType::COSMETICEDGE);
     base->setHlrVisible(true);
     int idx = edgeGeom.size();
     edgeGeom.push_back(base);
@@ -719,7 +719,7 @@ int GeometryObject::addCosmeticEdge(TechDraw::BaseGeomPtr base, std::string tagS
     //    Base::Console().Message("GO::addCosmeticEdge(%X, %s) 3\n", base, tagString.c_str());
     base->setCosmetic(true);
     base->setHlrVisible(true);
-    base->source(1);//1-CosmeticEdge, 2-CenterLine
+    base->source(SourceType::COSMETICEDGE);
     base->setCosmeticTag(tagString);
     base->sourceIndex(-1);
     int idx = edgeGeom.size();
@@ -733,7 +733,7 @@ int GeometryObject::addCenterLine(TechDraw::BaseGeomPtr base, std::string tag)
     //    Base::Console().Message("GO::addCenterLine()\n");
     base->setCosmetic(true);
     base->setCosmeticTag(tag);
-    base->source(2);
+    base->source(SourceType::CENTERLINE);
     //    base->sourceIndex(si);     //index into source;
     int idx = edgeGeom.size();
     edgeGeom.push_back(base);
diff --git a/src/Mod/TechDraw/App/GeometryObject.h b/src/Mod/TechDraw/App/GeometryObject.h
index a08a407804..f6d8612186 100644
--- a/src/Mod/TechDraw/App/GeometryObject.h
+++ b/src/Mod/TechDraw/App/GeometryObject.h
@@ -86,7 +86,7 @@ public:
     static TopoDS_Shape simpleProjection(const TopoDS_Shape& shape, const gp_Ax2& projCS);
     static TopoDS_Shape projectFace(const TopoDS_Shape& face, const gp_Ax2& CS);
     void makeTDGeometry();
-    void extractGeometry(edgeClass category, bool visible);
+    void extractGeometry(EdgeClass category, bool visible);
     void addFaceGeom(FacePtr f);
     void clearFaceGeom();
     void setIsoCount(int i) { m_isoCount = i; }
@@ -141,7 +141,7 @@ protected:
     TopoDS_Shape hidSeam;
     TopoDS_Shape hidIso;
 
-    void addGeomFromCompound(TopoDS_Shape edgeCompound, edgeClass category, bool visible);
+    void addGeomFromCompound(TopoDS_Shape edgeCompound, EdgeClass category, bool visible);
     TechDraw::DrawViewDetail* isParentDetail();
 
     //similar function in Geometry?
diff --git a/src/Mod/TechDraw/Gui/CommandAnnotate.cpp b/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
index b34e5dfc5f..04276a7bef 100644
--- a/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
+++ b/src/Mod/TechDraw/Gui/CommandAnnotate.cpp
@@ -1074,7 +1074,7 @@ void execLine2Points(Gui::Command* cmd)
     //check if editing existing edge
     if (!edgeNames.empty() && (edgeNames.size() == 1)) {
         TechDraw::CosmeticEdge* ce = baseFeat->getCosmeticEdgeBySelection(edgeNames.front());
-        if (!ce || ce->m_geometry->getGeomType() != TechDraw::GeomType::GENERIC) {
+        if (!ce || ce->m_geometry->getGeomType() != GeomType::GENERIC) {
             QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
                              QObject::tr("Selection is not a Cosmetic Line."));
             return;
@@ -1218,8 +1218,8 @@ void execCosmeticCircle(Gui::Command* cmd)
     if (!edgeNames.empty() && (edgeNames.size() == 1)) {
         TechDraw::CosmeticEdge* ce = baseFeat->getCosmeticEdgeBySelection(edgeNames.front());
         if (!ce
-            || !(ce->m_geometry->getGeomType() == TechDraw::GeomType::CIRCLE
-                || ce->m_geometry->getGeomType() == TechDraw::GeomType::ARCOFCIRCLE)) {
+            || !(ce->m_geometry->getGeomType() == GeomType::CIRCLE
+                || ce->m_geometry->getGeomType() == GeomType::ARCOFCIRCLE)) {
             QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong Selection"),
                              QObject::tr("Selection is not a Cosmetic Circle or a Cosmetic Arc of Circle."));
             return;
@@ -1275,10 +1275,6 @@ void execCosmeticCircle(Gui::Command* cmd)
 // TechDraw_CosmeticEraser
 //===========================================================================
 
-#define GEOMETRYEDGE 0
-#define COSMETICEDGE 1
-#define CENTERLINE 2
-
 DEF_STD_CMD_A(CmdTechDrawCosmeticEraser)
 
 CmdTechDrawCosmeticEraser::CmdTechDrawCosmeticEraser()
@@ -1345,15 +1341,15 @@ void CmdTechDrawCosmeticEraser::activated(int iMsg)
             if (geomType == "Edge") {
                 TechDraw::BaseGeomPtr bg = objFeat->getGeomByIndex(idx);
                 if (bg && bg->getCosmetic()) {
-                    int source = bg->source();
+                    SourceType source = bg->source();
                     std::string tag = bg->getCosmeticTag();
-                    if (source == COSMETICEDGE) {
+                    if (source == SourceType::COSMETICEDGE) {
                         ce2Delete.push_back(tag);
-                    } else if (source == CENTERLINE) {
+                    } else if (source == SourceType::CENTERLINE) {
                         cl2Delete.push_back(tag);
                     } else {
                         Base::Console().Message(
-                            "CMD::CosmeticEraser - edge: %d is confused - source: %d\n", idx, source);
+                            "CMD::CosmeticEraser - edge: %d is confused - source: %d\n", idx, static_cast<int>(source));
                     }
                 }
             } else if (geomType == "Vertex") {
diff --git a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
index 151f70be79..a00deaf48a 100644
--- a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
+++ b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
@@ -673,7 +673,7 @@ protected:
                 return emptyVector;
             }
 
-            if (geom->getGeomType() == TechDraw::GENERIC) {
+            if (geom->getGeomType() == GeomType::GENERIC) {
                 TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
                 if (gen1->points.size() < 2) {
                     return emptyVector;
@@ -681,13 +681,13 @@ protected:
                 return selLine;
                 //Base::Vector3d line = gen1->points.at(1) - gen1->points.at(0);
             }
-            else if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
+            else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
                 return selCircleArc;
             }
-            else if (geom->getGeomType() == TechDraw::ELLIPSE || geom->getGeomType() == TechDraw::ARCOFELLIPSE) {
+            else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) {
                 return selEllipseArc;
             }
-            else if (geom->getGeomType() == TechDraw::BSPLINE) {
+            else if (geom->getGeomType() == GeomType::BSPLINE) {
                 //TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
                 //if (spline->isCircle()) {
                 //    return isBSplineCircle;
@@ -981,7 +981,7 @@ protected:
         }
         if (availableDimension == AvailableDimension::SECOND) {
             createRadiusDiameterDimension(selCircleArc[0], false);
-            if (selCircleArc[0].geomEdgeType() != TechDraw::ARCOFCIRCLE) {
+            if (selCircleArc[0].geomEdgeType() != GeomType::ARCOFCIRCLE) {
                 availableDimension = AvailableDimension::RESET;
             }
         }
@@ -1015,7 +1015,7 @@ protected:
         }
         if (availableDimension == AvailableDimension::SECOND) {
             createRadiusDiameterDimension(selEllipseArc[0], false);
-            if (selEllipseArc[0].geomEdgeType() != TechDraw::ARCOFELLIPSE) {
+            if (selEllipseArc[0].geomEdgeType() != GeomType::ARCOFELLIPSE) {
                 availableDimension = AvailableDimension::RESET;
             }
         }
@@ -1074,7 +1074,7 @@ protected:
     void createRadiusDiameterDimension(ReferenceEntry ref, bool firstCstr) {
         int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
         TechDraw::BaseGeomPtr geom = partFeat->getGeomByIndex(GeoId);
-        bool isCircleGeom = (geom->getGeomType() == TechDraw::CIRCLE) || (geom->getGeomType() == TechDraw::ELLIPSE);
+        bool isCircleGeom = (geom->getGeomType() == GeomType::CIRCLE) || (geom->getGeomType() == GeomType::ELLIPSE);
 
         // Use same preference as in sketcher?
         ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/TechDraw/dimensioning");
diff --git a/src/Mod/TechDraw/Gui/CommandExtensionPack.cpp b/src/Mod/TechDraw/Gui/CommandExtensionPack.cpp
index 2aad6badfc..ad158a3324 100644
--- a/src/Mod/TechDraw/Gui/CommandExtensionPack.cpp
+++ b/src/Mod/TechDraw/Gui/CommandExtensionPack.cpp
@@ -113,7 +113,7 @@ void execHoleCircle(Gui::Command* cmd)
         std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
         TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
         if (GeoType == "Edge") {
-            if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
+            if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
                 TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
                 Circles.push_back(cgen);
             }
@@ -212,7 +212,7 @@ void execCircleCenterLines(Gui::Command* cmd)
         TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
         std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
         if (GeoType == "Edge") {
-            if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
+            if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
                 TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
                 // cgen->center is a scaled, rotated and inverted point
                 Base::Vector3d center = CosmeticVertex::makeCanonicalPointInverted(objFeat, cgen->center);
@@ -803,11 +803,11 @@ void CmdTechDrawExtensionChangeLineAttributes::activated(int iMsg)
         BaseGeomPtr baseGeo = objFeat->getGeomByIndex(num);
         if (baseGeo) {
             if (baseGeo->getCosmetic()) {
-                if (baseGeo->source() == 1) {
+                if (baseGeo->source() == SourceType::COSMETICEDGE) {
                     TechDraw::CosmeticEdge* cosEdgeTag = objFeat->getCosmeticEdgeBySelection(name);
                     _setLineAttributes(cosEdgeTag);
                 }
-                else if (baseGeo->source() == 2) {
+                else if (baseGeo->source() == SourceType::CENTERLINE) {
                     TechDraw::CenterLine* centerLineTag = objFeat->getCenterLineBySelection(name);
                     _setLineAttributes(centerLineTag);
                 }
@@ -1516,7 +1516,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
         if (geoType == "Edge") {
             TechDraw::BaseGeomPtr baseGeo = objFeat->getGeomByIndex(num);
             if (baseGeo) {
-                if (baseGeo->getGeomType() == TechDraw::GENERIC) {
+                if (baseGeo->getGeomType() == GeomType::GENERIC) {
                     // start and end points are geometry points and are scaled, rotated and inverted
                     // convert start and end to unscaled, unrotated.
                     Base::Vector3d P0 = CosmeticVertex::makeCanonicalPointInverted(objFeat, baseGeo->getStartPoint());
@@ -1530,7 +1530,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
                         App::Color oldColor;
                         std::vector<std::string> toDelete;
                         toDelete.push_back(uniTag);
-                        if (baseGeo->source() == 1) {
+                        if (baseGeo->source() == SourceType::COSMETICEDGE) {
                             // cosmetic edge
                             auto cosEdge = objFeat->getCosmeticEdge(uniTag);
                             oldStyle = cosEdge->m_format.getLineNumber();
@@ -1538,7 +1538,7 @@ void execExtendShortenLine(Gui::Command* cmd, bool extend)
                             oldColor = cosEdge->m_format.getColor();
                             objFeat->removeCosmeticEdge(toDelete);
                         }
-                        else if (baseGeo->source() == 2) {
+                        else if (baseGeo->source() == SourceType::CENTERLINE) {
                             // centerline
                             isCenterLine = true;
                             centerEdge = objFeat->getCenterLine(uniTag);
@@ -2121,7 +2121,7 @@ void _createThreadCircle(const std::string Name, TechDraw::DrawViewPart* objFeat
     TechDraw::BaseGeomPtr geom = objFeat->getGeomByIndex(GeoId);
     std::string GeoType = TechDraw::DrawUtil::getGeomTypeFromName(Name);
 
-    if (GeoType == "Edge" && geom->getGeomType() == TechDraw::CIRCLE) {
+    if (GeoType == "Edge" && geom->getGeomType() == GeomType::CIRCLE) {
         TechDraw::CirclePtr cgen = std::static_pointer_cast<TechDraw::Circle>(geom);
         // center is rotated and scaled
         Base::Vector3d center = CosmeticVertex::makeCanonicalPointInverted(objFeat, cgen->center);
@@ -2146,7 +2146,7 @@ void _createThreadLines(const std::vector<std::string>& SubNames, TechDraw::Draw
         int GeoId1 = TechDraw::DrawUtil::getIndexFromName(SubNames[1]);
         TechDraw::BaseGeomPtr geom0 = objFeat->getGeomByIndex(GeoId0);
         TechDraw::BaseGeomPtr geom1 = objFeat->getGeomByIndex(GeoId1);
-        if (geom0->getGeomType() != TechDraw::GENERIC || geom1->getGeomType() != TechDraw::GENERIC) {
+        if (geom0->getGeomType() != GeomType::GENERIC || geom1->getGeomType() != GeomType::GENERIC) {
             QMessageBox::warning(Gui::getMainWindow(), QObject::tr("TechDraw Thread Hole Side"),
                                  QObject::tr("Please select two straight lines"));
             return;
diff --git a/src/Mod/TechDraw/Gui/DimensionValidators.cpp b/src/Mod/TechDraw/Gui/DimensionValidators.cpp
index 96b23511d5..f45b399bc1 100644
--- a/src/Mod/TechDraw/Gui/DimensionValidators.cpp
+++ b/src/Mod/TechDraw/Gui/DimensionValidators.cpp
@@ -379,7 +379,7 @@ DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
         return isInvalid;
     }
 
-    if (geom->getGeomType() == TechDraw::GENERIC) {
+    if (geom->getGeomType() == GeomType::GENERIC) {
         TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom);
         if (gen1->points.size() < 2) {
             return isInvalid;
@@ -392,11 +392,11 @@ DimensionGeometryType TechDraw::isValidSingleEdge(ReferenceEntry ref)
         } else {
             return TechDraw::isDiagonal;
         }
-    } else if (geom->getGeomType() == TechDraw::CIRCLE || geom->getGeomType() == TechDraw::ARCOFCIRCLE) {
+    } else if (geom->getGeomType() == GeomType::CIRCLE || geom->getGeomType() == GeomType::ARCOFCIRCLE) {
         return isCircle;
-    } else if (geom->getGeomType() == TechDraw::ELLIPSE || geom->getGeomType() == TechDraw::ARCOFELLIPSE) {
+    } else if (geom->getGeomType() == GeomType::ELLIPSE || geom->getGeomType() == GeomType::ARCOFELLIPSE) {
         return isEllipse;
-    } else if (geom->getGeomType() == TechDraw::BSPLINE) {
+    } else if (geom->getGeomType() == GeomType::BSPLINE) {
         TechDraw::BSplinePtr spline = std::static_pointer_cast<TechDraw::BSpline>(geom);
         if (spline->isCircle()) {
             return isBSplineCircle;
@@ -529,7 +529,7 @@ DimensionGeometryType TechDraw::isValidMultiEdge(ReferenceVector refs)
     TechDraw::BaseGeomPtr geom0 = objFeat0->getGeomByIndex(GeoId0);
     TechDraw::BaseGeomPtr geom1 = objFeat0->getGeomByIndex(GeoId1);
 
-    if (geom0->getGeomType() == TechDraw::GENERIC && geom1->getGeomType() == TechDraw::GENERIC) {
+    if (geom0->getGeomType() == GeomType::GENERIC && geom1->getGeomType() == GeomType::GENERIC) {
         TechDraw::GenericPtr gen0 = std::static_pointer_cast<TechDraw::Generic>(geom0);
         TechDraw::GenericPtr gen1 = std::static_pointer_cast<TechDraw::Generic>(geom1);
         if (gen0->points.size() > 2 || gen1->points.size() > 2) {//the edge is a polyline
diff --git a/src/Mod/TechDraw/Gui/PathBuilder.cpp b/src/Mod/TechDraw/Gui/PathBuilder.cpp
index 2fdf03a0ee..2d5240baab 100644
--- a/src/Mod/TechDraw/Gui/PathBuilder.cpp
+++ b/src/Mod/TechDraw/Gui/PathBuilder.cpp
@@ -43,7 +43,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
         return path;
 
     switch (baseGeom->getGeomType()) {
-        case CIRCLE: {
+        case GeomType::CIRCLE: {
             TechDraw::CirclePtr geom = std::static_pointer_cast<TechDraw::Circle>(baseGeom);
 
             double x = geom->center.x - geom->radius;
@@ -52,7 +52,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
             path.addEllipse(Rez::guiX(x), Rez::guiX(y), Rez::guiX(geom->radius * 2),
                             Rez::guiX(geom->radius * 2));//topleft@(x, y) radx, rady
         } break;
-        case ARCOFCIRCLE: {
+        case GeomType::ARCOFCIRCLE: {
             TechDraw::AOCPtr geom = std::static_pointer_cast<TechDraw::AOC>(baseGeom);
             if (baseGeom->getReversed()) {      // OCC reversed flag
                 path.moveTo(Rez::guiX(geom->endPnt.x), Rez::guiX(geom->endPnt.y));
@@ -69,7 +69,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
                         Rez::guiX(geom->startPnt.x), Rez::guiX(geom->startPnt.y));
             }
         } break;
-        case TechDraw::ELLIPSE: {
+        case GeomType::ELLIPSE: {
             TechDraw::AOEPtr geom = std::static_pointer_cast<TechDraw::AOE>(baseGeom);
 
             // Calculate start and end points as ellipse with theta = 0 and pi
@@ -84,7 +84,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
             pathArc(path, Rez::guiX(geom->major), Rez::guiX(geom->minor), geom->angle, false, false,
                     Rez::guiX(startX), Rez::guiX(startY), Rez::guiX(endX), Rez::guiX(endY));
         } break;
-        case TechDraw::ARCOFELLIPSE: {
+        case GeomType::ARCOFELLIPSE: {
             TechDraw::AOEPtr geom = std::static_pointer_cast<TechDraw::AOE>(baseGeom);
             if (baseGeom->getReversed()) {
                 path.moveTo(Rez::guiX(geom->endPnt.x), Rez::guiX(geom->endPnt.y));
@@ -101,7 +101,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
                         Rez::guiX(geom->startPnt.y));
             }
         } break;
-        case TechDraw::BEZIER: {
+        case GeomType::BEZIER: {
             TechDraw::BezierSegmentPtr geom =
                 std::static_pointer_cast<TechDraw::BezierSegment>(baseGeom);
             if (baseGeom->getReversed()) {
@@ -158,7 +158,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
                 }
             }
         } break;
-        case TechDraw::BSPLINE: {
+        case GeomType::BSPLINE: {
             TechDraw::BSplinePtr geom = std::static_pointer_cast<TechDraw::BSpline>(baseGeom);
             if (baseGeom->getReversed()) {
                 // Move painter to the end of our last segment
@@ -221,7 +221,7 @@ QPainterPath PathBuilder::geomToPainterPath(BaseGeomPtr baseGeom, double rot) co
                 }
             }
         } break;
-        case TechDraw::GENERIC: {
+        case GeomType::GENERIC: {
             TechDraw::GenericPtr geom = std::static_pointer_cast<TechDraw::Generic>(baseGeom);
             if (baseGeom->getReversed()) {
                 if (!geom->points.empty()) {
diff --git a/src/Mod/TechDraw/Gui/QGIDrawingTemplate.cpp b/src/Mod/TechDraw/Gui/QGIDrawingTemplate.cpp
index d374af06c5..9cf2699e91 100644
--- a/src/Mod/TechDraw/Gui/QGIDrawingTemplate.cpp
+++ b/src/Mod/TechDraw/Gui/QGIDrawingTemplate.cpp
@@ -86,9 +86,7 @@ void QGIDrawingTemplate::draw()
     // Draw Edges
     // iterate through all the geometries
     for(; it != geoms.end(); ++it) {
-        switch((*it)->getGeomType()) {
-          case TechDraw::GENERIC: {
-
+        if((*it)->getGeomType() == TechDraw::GeomType::GENERIC) {
             TechDraw::GenericPtr geom = std::static_pointer_cast<TechDraw::Generic>(*it);
 
             path.moveTo(geom->points[0].x, geom->points[0].y);
@@ -97,10 +95,6 @@ void QGIDrawingTemplate::draw()
             for(++it; it != geom->points.end(); ++it) {
                 path.lineTo((*it).x, (*it).y);
             }
-            break;
-          }
-          default:
-            break;
         }
     }
 
diff --git a/src/Mod/TechDraw/Gui/QGIEdge.h b/src/Mod/TechDraw/Gui/QGIEdge.h
index 89f842e111..5e8f92b9b0 100644
--- a/src/Mod/TechDraw/Gui/QGIEdge.h
+++ b/src/Mod/TechDraw/Gui/QGIEdge.h
@@ -23,6 +23,7 @@
 #ifndef DRAWINGGUI_QGRAPHICSITEMEDGE_H
 #define DRAWINGGUI_QGRAPHICSITEMEDGE_H
 
+#include <Mod/TechDraw/App/Geometry.h>
 #include <Mod/TechDraw/TechDrawGlobal.h>
 
 #include "QGIPrimPath.h"
@@ -55,8 +56,8 @@ public:
 
     void setLinePen(QPen isoPen);
 
-    void setSource(int source) { m_source = source; }
-    int getSource() const { return m_source;}
+    void setSource(TechDraw::SourceType source) { m_source = source; }
+    TechDraw::SourceType getSource() const { return m_source;}
 
     void setCurrentPen() override;
 
@@ -75,7 +76,7 @@ protected:
     Qt::PenStyle getHiddenStyle();
 
 private:
-    int m_source{0};
+    TechDraw::SourceType m_source{TechDraw::SourceType::GEOMETRY};
 };
 
 }
diff --git a/src/Mod/TechDraw/Gui/QGIViewPart.cpp b/src/Mod/TechDraw/Gui/QGIViewPart.cpp
index 8ba0969136..1ecd5bb5b9 100644
--- a/src/Mod/TechDraw/Gui/QGIViewPart.cpp
+++ b/src/Mod/TechDraw/Gui/QGIViewPart.cpp
@@ -71,10 +71,6 @@ using namespace TechDrawGui;
 using namespace std;
 using DU = DrawUtil;
 
-#define GEOMETRYEDGE 0
-#define COSMETICEDGE 1
-#define CENTERLINE 2
-
 const float lineScaleFactor = Rez::guiX(1.);// temp fiddle for devel
 
 QGIViewPart::QGIViewPart()
@@ -365,18 +361,18 @@ void QGIViewPart::drawAllEdges()
         item->setNormalColor(PreferencesGui::getAccessibleQColor(PreferencesGui::normalQColor()));
         if ((*itGeom)->getCosmetic()) {
             // cosmetic edge - format appropriately
-            int source = (*itGeom)->source();
-            if (source == COSMETICEDGE) {
+            TechDraw::SourceType source = (*itGeom)->source();
+            if (source == TechDraw::SourceType::COSMETICEDGE) {
                 std::string cTag = (*itGeom)->getCosmeticTag();
                 showItem = formatGeomFromCosmetic(cTag, item);
             }
-            else if (source == CENTERLINE) {
+            else if (source == TechDraw::SourceType::CENTERLINE) {
                 std::string cTag = (*itGeom)->getCosmeticTag();
                 showItem = formatGeomFromCenterLine(cTag, item);
             }
             else {
                 Base::Console().Message("QGIVP::drawVP - cosmetic edge: %d is confused - source: %d\n",
-                                        iEdge, source);
+                                        iEdge, static_cast<int>(source));
             }
         } else {
             // geometry edge - apply format if applicable
@@ -407,7 +403,7 @@ void QGIViewPart::drawAllEdges()
             }
         }
 
-        if ((*itGeom)->getClassOfEdge()  == ecUVISO) {
+        if ((*itGeom)->getClassOfEdge() == EdgeClass::UVISO) {
             // we don't have a style option for iso-parametric lines so draw continuous
             item->setLinePen(m_dashedLineGenerator->getLinePen(1, vp->IsoWidth.getValue()));
             item->setWidth(Rez::guiX(vp->IsoWidth.getValue()));   //graphic
@@ -475,18 +471,18 @@ bool QGIViewPart::showThisEdge(BaseGeomPtr geom)
     auto dvp(static_cast<TechDraw::DrawViewPart*>(getViewObject()));
 
     if (geom->getHlrVisible()) {
-        if ((geom->getClassOfEdge()  == ecHARD) || (geom->getClassOfEdge()  == ecOUTLINE)
-            || ((geom->getClassOfEdge()  == ecSMOOTH) && dvp->SmoothVisible.getValue())
-            || ((geom->getClassOfEdge()  == ecSEAM) && dvp->SeamVisible.getValue())
-            || ((geom->getClassOfEdge()  == ecUVISO) && dvp->IsoVisible.getValue())) {
+        if ((geom->getClassOfEdge() == EdgeClass::HARD) || (geom->getClassOfEdge() == EdgeClass::OUTLINE)
+            || ((geom->getClassOfEdge() == EdgeClass::SMOOTH) && dvp->SmoothVisible.getValue())
+            || ((geom->getClassOfEdge() == EdgeClass::SEAM) && dvp->SeamVisible.getValue())
+            || ((geom->getClassOfEdge() == EdgeClass::UVISO) && dvp->IsoVisible.getValue())) {
             return true;
         }
     } else {
-        if (((geom->getClassOfEdge()  == ecHARD) && (dvp->HardHidden.getValue()))
-            || ((geom->getClassOfEdge()  == ecOUTLINE) && (dvp->HardHidden.getValue()))
-            || ((geom->getClassOfEdge()  == ecSMOOTH) && (dvp->SmoothHidden.getValue()))
-            || ((geom->getClassOfEdge()  == ecSEAM) && (dvp->SeamHidden.getValue()))
-            || ((geom->getClassOfEdge()  == ecUVISO) && (dvp->IsoHidden.getValue()))) {
+        if (((geom->getClassOfEdge() == EdgeClass::HARD) && (dvp->HardHidden.getValue()))
+            || ((geom->getClassOfEdge() == EdgeClass::OUTLINE) && (dvp->HardHidden.getValue()))
+            || ((geom->getClassOfEdge() == EdgeClass::SMOOTH) && (dvp->SmoothHidden.getValue()))
+            || ((geom->getClassOfEdge() == EdgeClass::SEAM) && (dvp->SeamHidden.getValue()))
+            || ((geom->getClassOfEdge() == EdgeClass::UVISO) && (dvp->IsoHidden.getValue()))) {
             return true;
         }
     }
diff --git a/src/Mod/TechDraw/Gui/TaskLineDecor.cpp b/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
index ad4bfc79b9..b8746bd021 100644
--- a/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
+++ b/src/Mod/TechDraw/Gui/TaskLineDecor.cpp
@@ -108,7 +108,7 @@ TechDraw::LineFormat *TaskLineDecor::getFormatAccessPtr(const std::string &edgeN
     BaseGeomPtr bg = m_partFeat->getEdge(edgeName);
     if (bg) {
         if (bg->getCosmetic()) {
-            if (bg->source() == SourceType::COSEDGE) {
+            if (bg->source() == SourceType::COSMETICEDGE) {
                 TechDraw::CosmeticEdge *ce = m_partFeat->getCosmeticEdgeBySelection(edgeName);
                 if (ce) {
                     return &ce->m_format;