diff --git a/src/Mod/TechDraw/App/DimensionFormatter.cpp b/src/Mod/TechDraw/App/DimensionFormatter.cpp
index 0b9b756d09..1bfa57eb61 100644
--- a/src/Mod/TechDraw/App/DimensionFormatter.cpp
+++ b/src/Mod/TechDraw/App/DimensionFormatter.cpp
@@ -91,9 +91,6 @@ std::string DimensionFormatter::formatValue(const qreal value,
 
     QString qMultiValueStr;
     QString qBasicUnit = Base::Tools::fromStdString(Base::UnitsApi::getBasicLengthUnit());
-    if (areaMeasure) {
-        qBasicUnit = qBasicUnit + QString::fromUtf8("²");
-    }
 
     QString formattedValue;
     if (isMultiValueSchema() && partial == 0) {
@@ -138,6 +135,10 @@ std::string DimensionFormatter::formatValue(const qreal value,
         else {
             double convertValue = Base::Quantity::parse(QString::fromLatin1("1") + qBasicUnit).getValue();
             userVal = asQuantity.getValue() / convertValue;
+            if (areaMeasure) {
+                userVal = userVal / convertValue; // divide again as area is length²
+                qBasicUnit = qBasicUnit + QString::fromUtf8("²");
+            }
         }
 
         if (isTooSmall(userVal, formatSpecifier)) {
diff --git a/src/Mod/TechDraw/App/DimensionReferences.cpp b/src/Mod/TechDraw/App/DimensionReferences.cpp
index 68a1176986..656af6ee88 100644
--- a/src/Mod/TechDraw/App/DimensionReferences.cpp
+++ b/src/Mod/TechDraw/App/DimensionReferences.cpp
@@ -265,15 +265,7 @@ Part::TopoShape ReferenceEntry::asTopoShapeEdge(const TopoDS_Edge &edge)
 
 Part::TopoShape ReferenceEntry::asTopoShapeFace(const TopoDS_Face &face)
 {
-//    Base::Console().Message("RE::asTopoShapeFace()\n");
-    TopoDS_Face unscaledFace = face;
-    if (!is3d()) {
-        // 2d reference - projected and scaled. scale might have changed, so we need to unscale
-        auto dvp = static_cast<TechDraw::DrawViewPart*>(getObject());
-        TopoDS_Shape unscaledShape = ShapeUtils::scaleShape(face, 1.0 / dvp->getScale());
-        unscaledFace = TopoDS::Face(unscaledShape);
-    }
-    return { unscaledFace };
+    return { face };
 }
 
 std::string ReferenceEntry::geomType() const
diff --git a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
index d4d69cc47b..53674ac223 100644
--- a/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
+++ b/src/Mod/TechDraw/Gui/CommandCreateDims.cpp
@@ -30,6 +30,7 @@
 #include <QMessageBox>
 #include <QKeyEvent>
 #include <QMouseEvent>
+#include <QPoint>
 #endif//#ifndef _PreComp_
 
 #include <App/Document.h>
@@ -178,7 +179,7 @@ public:
         : SelectionObserver(true)
         , specialDimension(SpecialDimension::None)
         , availableDimension(AvailableDimension::FIRST)
-        , previousPos(QPoint(0, 0))
+        , mousePos(QPoint(0, 0))
         , selPoints({})
         , selLine({})
         , selCircleArc({})
@@ -218,6 +219,10 @@ public:
 
     void activated() override
     {
+        auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
+        if (mdi) {
+            mdi->setDimensionsSelectability(false);
+        }
         Gui::Selection().setSelectionStyle(Gui::SelectionSingleton::SelectionStyle::GreedySelection);
         Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Insert Dimension"));
         handleInitialSelection();
@@ -225,6 +230,10 @@ public:
 
     void deactivated() override
     {
+        auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
+        if (mdi) {
+            mdi->setDimensionsSelectability(true);
+        }
         Gui::Selection().setSelectionStyle(Gui::SelectionSingleton::SelectionStyle::NormalSelection);
         Gui::Command::abortCommand();
     }
@@ -247,7 +256,7 @@ public:
             else if (availableDimension == AvailableDimension::FIFTH || availableDimension == AvailableDimension::RESET) {
                 availableDimension = AvailableDimension::FIRST;
             }
-            makeAppropriateDimension(previousPos);
+            makeAppropriateDimension();
             event->accept();
         }
         else if (event->key() == Qt::Key_Z && (QApplication::keyboardModifiers() & Qt::ControlModifier)) {
@@ -270,7 +279,7 @@ public:
 
     void mouseMoveEvent(QMouseEvent* event) override
     {
-        previousPos = event->pos();
+        mousePos = event->pos();
 
         if (dims.empty()){
             return;
@@ -280,13 +289,13 @@ public:
         Base::Vector3d dirMaster, delta;
         //Change distance dimension based on position of mouse.
         if (specialDimension == SpecialDimension::LineOr2PointsDistance){
-            updateDistanceType(event->pos());
+            updateDistanceType();
         }
         else if (specialDimension == SpecialDimension::ExtendDistance){
-            updateExtentDistanceType(event->pos());
+            updateExtentDistanceType();
         }
         else if (specialDimension == SpecialDimension::ChainDistance || specialDimension == SpecialDimension::CoordDistance){
-            updateChainDistanceType(event->pos());
+            updateChainDistanceType();
             textToMiddle = true;
             pointPair pp = dims[0]->getLinearPoints();
             dirMaster = pp.second() - pp.first();
@@ -301,7 +310,7 @@ public:
         int i = 0;
         for (auto* dim : dims) {
             auto dimType = static_cast<DimensionType>(dim->Type.getValue());
-            moveDimension(event->pos(), dim, textToMiddle, dirMaster, delta, dimType, i);
+            moveDimension(mousePos, dim, textToMiddle, dirMaster, delta, dimType, i);
 
             if (specialDimension == SpecialDimension::CoordDistance) {
                 i++;
@@ -321,7 +330,7 @@ public:
         }
         return qgivDimension->getDatumLabel();
     }
-    void moveDimension(QPoint& pos, DrawViewDimension* dim, bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
+    void moveDimension(QPoint pos, DrawViewDimension* dim, bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
         Base::Vector3d delta = Base::Vector3d(), DimensionType type = DimensionType::Distance, int i = 0)
     {
         if (!dim) { return; }
@@ -330,14 +339,14 @@ public:
 
         label->setPos(getDimPositionToBe(pos, label->pos(), textToMiddle, dir, delta, type, i));
     }
-    QPointF getDimPositionToBe(QPoint& pos, QPointF curPos = QPointF(), bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
+    QPointF getDimPositionToBe(QPoint pos, QPointF curPos = QPointF(), bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
         Base::Vector3d delta = Base::Vector3d(), DimensionType type = DimensionType::Distance, int i = 0)
     {
         auto* vpp = dynamic_cast<ViewProviderDrawingView*>(Gui::Application::Instance->getViewProvider(partFeat));
         if (!vpp) { return QPointF(); }
 
 
-        QPointF scenePos = viewPage->mapToScene(pos) - vpp->getQView()->pos();
+        QPointF scenePos = viewPage->mapToScene(pos) - vpp->getQView()->scenePos();
 
         if (textToMiddle) {
             // delta is for coord distances. i = 0 when it's a chain so delta is ignored.
@@ -383,86 +392,104 @@ public:
         }
     }
 
-    bool mousePressEvent(QMouseEvent* event) override
+    void setDimsSelectability(bool val)
     {
-        if (event->button() == Qt::RightButton && !dims.empty()) {
-            Gui::Selection().clearSelection();
-            clearAndRestartCommand();
-            event->accept();
-            return true;
+        for (auto dim : dims) {
+            setDimSelectability(dim, val);
+        }
+    }
+    void setDimSelectability(DrawViewDimension* d, bool val)
+    {
+        QGIDatumLabel* label = getDimLabel(d);
+        if (label) {
+            label->setSelectability(val);
         }
-        return TechDrawHandler::mousePressEvent(event);
     }
 
-    bool mouseReleaseEvent(QMouseEvent* event) override
+    void mouseReleaseEvent(QMouseEvent* event) override
     {
         // Base::Console().Warning("mouseReleaseEvent TH\n");
-        bool finalize = true;
-
-        if (removedRef.hasGeometry()) {
-            finalize = false;
-            //Base::Console().Warning("RmvSelection \n");
-            // Remove the reference from the vector
-            ReferenceVector& selVector = getSelectionVector(removedRef);
-            selVector.erase(std::remove(selVector.begin(), selVector.end(), removedRef), selVector.end());
-
-            if (!selectionEmpty()) {
-                availableDimension = AvailableDimension::FIRST;
-                makeAppropriateDimension(event->pos());
-            }
-            else {
+        if (event->button() == Qt::RightButton) {
+            if (!dims.empty()) {
+                Gui::Selection().clearSelection();
                 clearAndRestartCommand();
-            }
-            removedRef = ReferenceEntry();
-        }
-
-        if (addedRef.hasGeometry()) {
-            finalize = false;
-            //Base::Console().Warning("AddSelection\n");
-            //add the geometry to its type vector. Temporarily if not selAllowed
-            if (addedRef.getSubName() == "") {
-                // Behavior deactivated for now because I found it annoying.
-                // To reactivate replace addedRef.hasGeometry() by addedRef.getObject() above.
-                // This means user selected the view itself.
-                if (selectionEmpty()) {
-                    restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-                    createExtentDistanceDimension("DistanceX", event->pos());
-                }
+                event->accept();
             }
             else {
-                ReferenceVector& selVector = getSelectionVector(addedRef);
-                selVector.push_back(addedRef);
+                TechDrawHandler::mouseReleaseEvent(event);
+            }
+            return;
+        }
+        else  if (event->button() == Qt::LeftButton) {
+            mousePos = event->pos();
 
-                availableDimension = AvailableDimension::FIRST;
-                bool selAllowed = makeAppropriateDimension(event->pos());
+            bool finalize = true;
 
-                if (!selAllowed) {
-                    // remove from selection
-                    blockRemoveSel = true;
+            if (removedRef.hasGeometry()) {
+                finalize = false;
+                //Base::Console().Warning("RmvSelection \n");
+                // Remove the reference from the vector
+                ReferenceVector& selVector = getSelectionVector(removedRef);
+                selVector.erase(std::remove(selVector.begin(), selVector.end(), removedRef), selVector.end());
 
-                    Gui::Selection().rmvSelection(addedRef.getObject()->getDocument()->getName(), addedRef.getObject()->getNameInDocument(), addedRef.getSubName().c_str());
-                    blockRemoveSel = false;
+                if (!selectionEmpty()) {
+                    availableDimension = AvailableDimension::FIRST;
+                    makeAppropriateDimension();
+                }
+                else {
+                    clearAndRestartCommand();
+                }
+                removedRef = ReferenceEntry();
+            }
 
-                    if (selVector == selFaces) {
-                        // if sel face and not allowed, then a dimension is being created
-                        // and user clicked on a face to drop it.
-                        // Better would be to disable face selectability when needed.
-                        finalize = true;
+            if (addedRef.hasGeometry()) {
+                finalize = false;
+                //Base::Console().Warning("AddSelection\n");
+                //add the geometry to its type vector. Temporarily if not selAllowed
+                if (addedRef.getSubName() == "") {
+                    // Behavior deactivated for now because I found it annoying.
+                    // To reactivate replace addedRef.hasGeometry() by addedRef.getObject() above.
+                    // This means user selected the view itself.
+                    if (selectionEmpty()) {
+                        restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
+                        createExtentDistanceDimension("DistanceX");
                     }
                 }
+                else {
+                    ReferenceVector& selVector = getSelectionVector(addedRef);
+                    selVector.push_back(addedRef);
+
+                    availableDimension = AvailableDimension::FIRST;
+                    bool selAllowed = makeAppropriateDimension();
+
+                    if (!selAllowed) {
+                        // remove from selection
+                        blockRemoveSel = true;
+
+                        Gui::Selection().rmvSelection(addedRef.getObject()->getDocument()->getName(),
+                            addedRef.getObject()->getNameInDocument(), addedRef.getSubName().c_str());
+                        blockRemoveSel = false;
+
+                        if (selVector == selFaces) {
+                            // if sel face and not allowed, then a dimension is being created
+                            // and user clicked on a face to drop it.
+                            // Better would be to disable face selectability when needed.
+                            finalize = true;
+                        }
+                    }
+                }
+                addedRef = ReferenceEntry();
             }
-            addedRef = ReferenceEntry();
-        }
 
 
-        // Finalize if click on empty space.
-        if (finalize && !dims.empty()) {
-            finalizeCommand();
+            // Finalize if click on empty space.
+            if (finalize && !dims.empty()) {
+                finalizeCommand();
+            }
         }
-        return true;
     }
 
-    void onSelectionChanged(const Gui::SelectionChanges& msg)
+    void onSelectionChanged(const Gui::SelectionChanges& msg) override
     {
         //Base::Console().Warning("onSelectionChanged %d - --%s--\n", (int)msg.Type, msg.pSubName);
 
@@ -539,7 +566,7 @@ protected:
     SpecialDimension specialDimension;
     AvailableDimension availableDimension;
 
-    QPoint previousPos;
+    QPoint mousePos;
 
     ReferenceVector selPoints;
     ReferenceVector selLine;
@@ -578,7 +605,7 @@ protected:
         }
 
         // See if the selection is valid
-        bool selAllowed = makeAppropriateDimension(QPoint());
+        bool selAllowed = makeAppropriateDimension();
 
         if (!selAllowed) {
             clearRefVectors();
@@ -704,316 +731,322 @@ protected:
         return result;
     }
 
-    bool makeAppropriateDimension(QPoint& pos) {
+    bool makeAppropriateDimension() {
         bool selAllowed = false;
         //Base::Console().Warning("makeAppropriateDimension %d %d %d %d %d %d\n", selPoints.size(), selLine.size(), selCircleArc.size(), selEllipseArc.size(), selSplineAndCo.size(), selFaces.size());
 
         GeomSelectionSizes selection(selPoints.size(), selLine.size(), selCircleArc.size(), selEllipseArc.size(), selSplineAndCo.size(), selFaces.size());
         if (selection.hasFaces()) {
-            if (selection.has1Face()) { makeCts_Faces(selAllowed, pos); }
+            if (selection.has1Face()) { makeCts_Faces(selAllowed); }
             else { return false; }  // nothing else with face works
         }
         else if (selection.hasPoints()) {
             if (selection.has1Point()) { selAllowed = true; }
-            else if (selection.has2Points()) { makeCts_2Point(selAllowed, pos); }
-            else if (selection.has3Points()) { makeCts_3Point(selAllowed, pos); }
-            else if (selection.has4MorePoints()) { makeCts_4MorePoints(selAllowed, pos); }
-            else if (selection.has1Point1Line()) { makeCts_1Point1Line(selAllowed, pos); }
-            else if (selection.has1Point1Circle()) { makeCts_1Point1Circle(selAllowed, pos); }
-            else if (selection.has1Point1Ellipse()) { makeCts_1Point1Ellipse(selAllowed, pos); }
+            else if (selection.has2Points()) { makeCts_2Point(selAllowed); }
+            else if (selection.has3Points()) { makeCts_3Point(selAllowed); }
+            else if (selection.has4MorePoints()) { makeCts_4MorePoints(selAllowed); }
+            else if (selection.has1Point1Line()) { makeCts_1Point1Line(selAllowed); }
+            else if (selection.has1Point1Circle()) { makeCts_1Point1Circle(selAllowed); }
+            else if (selection.has1Point1Ellipse()) { makeCts_1Point1Ellipse(selAllowed); }
         }
         else if (selection.hasLines()) {
-            if (selection.has1Line()) { makeCts_1Line(selAllowed, pos); }
-            else if (selection.has2Lines()) { makeCts_2Line(selAllowed, pos); }
-            else if (selection.has1Line1Circle()) { makeCts_1Line1Circle(selAllowed, pos); }
-            else if (selection.has1Line1Ellipse()) { makeCts_1Line1Ellipse(selAllowed, pos); }
+            if (selection.has1Line()) { makeCts_1Line(selAllowed); }
+            else if (selection.has2Lines()) { makeCts_2Line(selAllowed); }
+            else if (selection.has1Line1Circle()) { makeCts_1Line1Circle(selAllowed); }
+            else if (selection.has1Line1Ellipse()) { makeCts_1Line1Ellipse(selAllowed); }
         }
         else if (selection.hasCirclesOrArcs()) {
-            if (selection.has1Circle()) { makeCts_1Circle(selAllowed, pos); }
-            else if (selection.has2Circles()) { makeCts_2Circle(selAllowed, pos); }
+            if (selection.has1Circle()) { makeCts_1Circle(selAllowed); }
+            else if (selection.has2Circles()) { makeCts_2Circle(selAllowed); }
         }
         else if (selection.hasEllipseAndCo()) {
-            if (selection.has1Ellipse()) { makeCts_1Ellipse(selAllowed, pos); }
-            if (selection.has2Ellipses()) { makeCts_2Ellipses(selAllowed, pos); }
+            if (selection.has1Ellipse()) { makeCts_1Ellipse(selAllowed); }
+            if (selection.has2Ellipses()) { makeCts_2Ellipses(selAllowed); }
         }
         else if (selection.hasSplineAndCo()) {
-            if (selection.has1Spline()) { makeCts_1Spline(selAllowed, pos); }
-            if (selection.has1SplineAndMore()) { makeCts_1SplineAndMore(selAllowed, pos); }
+            if (selection.has1Spline()) { makeCts_1Spline(selAllowed); }
+            if (selection.has1SplineAndMore()) { makeCts_1SplineAndMore(selAllowed); }
         }
+
+        // Make created constraints unselectable.
+        if (selAllowed) {
+            setDimsSelectability(false);
+        }
+
         return selAllowed;
     }
 
-    void makeCts_Faces(bool& selAllowed, QPoint& pos)
+    void makeCts_Faces(bool& selAllowed)
     {
         //area
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Area dimension"));
-            createAreaDimension(selFaces[0], pos);
+            createAreaDimension(selFaces[0]);
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_2Point(bool& selAllowed, QPoint& pos)
+    void makeCts_2Point(bool& selAllowed)
     {
         //distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension"));
-            createDistanceDimension("Distance", selPoints[0], selPoints[1], pos);
+            createDistanceDimension("Distance", { selPoints[0], selPoints[1] });
             specialDimension = SpecialDimension::LineOr2PointsDistance;
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_3Point(bool& selAllowed, QPoint& pos)
+    void makeCts_3Point(bool& selAllowed)
     {
         // chain distances, angle
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimensions"));
-            createChainDimension("DistanceX", pos);
+            createChainDimension("DistanceX");
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coordinate dimensions"));
-            createCoordDimension("DistanceX", pos);
+            createCoordDimension("DistanceX");
         }
         if (availableDimension == AvailableDimension::THIRD) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
-            create3pAngleDimension(selPoints[0], selPoints[1], selPoints[2], pos);
+            create3pAngleDimension({ selPoints[0], selPoints[1], selPoints[2] });
         }
         else if (availableDimension == AvailableDimension::FOURTH) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
-            create3pAngleDimension(selPoints[1], selPoints[2], selPoints[0], pos);
+            create3pAngleDimension({ selPoints[1], selPoints[2], selPoints[0] });
         }
         else if (availableDimension == AvailableDimension::FIFTH) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
-            create3pAngleDimension(selPoints[2], selPoints[0], selPoints[1], pos);
+            create3pAngleDimension({ selPoints[2], selPoints[0], selPoints[1] });
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_4MorePoints(bool& selAllowed, QPoint& pos)
+    void makeCts_4MorePoints(bool& selAllowed)
     {
         // chain distances
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimension"));
-            createChainDimension("DistanceX", pos);
+            createChainDimension("DistanceX");
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coordinate dimensions"));
-            createCoordDimension("DistanceX", pos);
+            createCoordDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Point1Line(bool& selAllowed, QPoint& pos)
+    void makeCts_1Point1Line(bool& selAllowed)
     {
         //distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add point to line Distance dimension"));
-            createDistanceDimension("Distance", selPoints[0], selLine[0], pos);
+            createDistanceDimension("Distance", { selPoints[0], selLine[0] });
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Point1Circle(bool& selAllowed, QPoint& pos)
+    void makeCts_1Point1Circle(bool& selAllowed)
     {
         //Distance, extent distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
-            createDistanceDimension("Distance", selPoints[0], selCircleArc[0], pos);
+            createDistanceDimension("Distance", { selPoints[0], selCircleArc[0] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Point1Ellipse(bool& selAllowed, QPoint& pos)
+    void makeCts_1Point1Ellipse(bool& selAllowed)
     {
         //Distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
-            createDistanceDimension("Distance", selPoints[0], selEllipseArc[0], pos);
+            createDistanceDimension("Distance", { selPoints[0], selEllipseArc[0] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Line(bool& selAllowed, QPoint& pos)
+    void makeCts_1Line(bool& selAllowed)
     {
         //distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
-            createDistanceDimension("Distance", selLine[0], ReferenceEntry(), pos);
+            createDistanceDimension("Distance", { selLine[0] });
             specialDimension = SpecialDimension::LineOr2PointsDistance;
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_2Line(bool& selAllowed, QPoint& pos)
+    void makeCts_2Line(bool& selAllowed)
     {
         //angle (if parallel: Distance (see in createAngleDimension)).
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Angle dimension"));
-            createAngleDimension(selLine[0], selLine[1], pos);
+            createAngleDimension(selLine[0], selLine[1]);
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Line1Circle(bool& selAllowed, QPoint& pos)
+    void makeCts_1Line1Circle(bool& selAllowed)
     {
         //distance, extent distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add circle to line Distance dimension"));
-            createDistanceDimension("Distance", selCircleArc[0], selLine[0], pos);
+            createDistanceDimension("Distance", { selCircleArc[0], selLine[0] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Line1Ellipse(bool& selAllowed, QPoint& pos)
+    void makeCts_1Line1Ellipse(bool& selAllowed)
     {
         //distance, extent distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add ellipse to line Distance dimension"));
-            createDistanceDimension("Distance", selEllipseArc[0], selLine[0], pos);
+            createDistanceDimension("Distance", { selEllipseArc[0], selLine[0] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Circle(bool& selAllowed, QPoint& pos)
+    void makeCts_1Circle(bool& selAllowed)
     {
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
-            createRadiusDiameterDimension(selCircleArc[0], pos, true);
+            createRadiusDiameterDimension(selCircleArc[0], true);
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
-            createRadiusDiameterDimension(selCircleArc[0], pos, false);
+            createRadiusDiameterDimension(selCircleArc[0], false);
             if (selCircleArc[0].geomEdgeType() != TechDraw::ARCOFCIRCLE) {
                 availableDimension = AvailableDimension::RESET;
             }
         }
         if (availableDimension == AvailableDimension::THIRD) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Arc Length dimension"));
-            createArcLengthDimension(selCircleArc[0], pos);
+            createArcLengthDimension(selCircleArc[0]);
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_2Circle(bool& selAllowed, QPoint& pos)
+    void makeCts_2Circle(bool& selAllowed)
     {
         //Distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add circle to circle Distance dimension"));
-            createDistanceDimension("Distance", selCircleArc[0], selCircleArc[1], pos);
+            createDistanceDimension("Distance", { selCircleArc[0], selCircleArc[1] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Ellipse(bool& selAllowed, QPoint& pos)
+    void makeCts_1Ellipse(bool& selAllowed)
     {
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
-            createRadiusDiameterDimension(selEllipseArc[0], pos, true);
+            createRadiusDiameterDimension(selEllipseArc[0], true);
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
-            createRadiusDiameterDimension(selEllipseArc[0], pos, false);
+            createRadiusDiameterDimension(selEllipseArc[0], false);
             if (selEllipseArc[0].geomEdgeType() != TechDraw::ARCOFELLIPSE) {
                 availableDimension = AvailableDimension::RESET;
             }
         }
         if (availableDimension == AvailableDimension::THIRD) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Arc Length dimension"));
-            createArcLengthDimension(selEllipseArc[0], pos);
+            createArcLengthDimension(selEllipseArc[0]);
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_2Ellipses(bool& selAllowed, QPoint& pos)
+    void makeCts_2Ellipses(bool& selAllowed)
     {
         //Distance
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add ellipse to ellipse Distance dimension"));
-            createDistanceDimension("Distance", selEllipseArc[0], selEllipseArc[1], pos);
+            createDistanceDimension("Distance", { selEllipseArc[0], selEllipseArc[1] });
             selAllowed = true;
         }
         if (availableDimension == AvailableDimension::SECOND) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1Spline(bool& selAllowed, QPoint& pos)
+    void makeCts_1Spline(bool& selAllowed)
     {
         //Edge length
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add edge length dimension"));
-            createArcLengthDimension(selSplineAndCo[0], pos);
+            createArcLengthDimension(selSplineAndCo[0]);
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void makeCts_1SplineAndMore(bool& selAllowed, QPoint& pos)
+    void makeCts_1SplineAndMore(bool& selAllowed)
     {
         //Extend
         if (availableDimension == AvailableDimension::FIRST) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
             selAllowed = true;
             availableDimension = AvailableDimension::RESET;
         }
     }
 
-    void createAreaDimension(ReferenceEntry ref, QPoint& pos)
+    void createAreaDimension(ReferenceEntry ref)
     {
         DrawViewDimension* dim = dimMaker(partFeat, "Area", { ref }, {});
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void createRadiusDiameterDimension(ReferenceEntry ref, QPoint& pos, bool firstCstr) {
+    void createRadiusDiameterDimension(ReferenceEntry ref, bool firstCstr) {
         bool isCircleGeom = true;
 
         int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
         TechDraw::BaseGeomPtr geom = partFeat->getGeomByIndex(GeoId);
-        isCircleGeom = geom->getGeomType() == TechDraw::CIRCLE || TechDraw::ELLIPSE;
+        isCircleGeom = (geom->getGeomType() == TechDraw::CIRCLE) || (geom->getGeomType() == TechDraw::ELLIPSE);
 
         // Use same preference as in sketcher?
         ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/TechDraw/dimensioning");
@@ -1032,61 +1065,57 @@ protected:
         }
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2, QPoint& pos) {
+    void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2) {
         if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != isAngle) {
             //isValidMultiEdge check if lines are parallel.
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension"));
-            createDistanceDimension("Distance", ref1, ref2, pos);
+            createDistanceDimension("Distance", { ref1, ref2 });
             return;
         }
 
         DrawViewDimension* dim = dimMaker(partFeat, "Angle", {ref1, ref2}, {});
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void create3pAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2, ReferenceEntry ref3, QPoint& pos)
+    void create3pAngleDimension(ReferenceVector refs)
     {
-        DrawViewDimension* dim = dimMaker(partFeat, "Angle3Pt", {ref1, ref2, ref3}, {});
+        DrawViewDimension* dim = dimMaker(partFeat, "Angle3Pt", refs, {});
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void createArcLengthDimension(ReferenceEntry ref, QPoint& pos)
+    void createArcLengthDimension(ReferenceEntry ref)
     {
         DrawViewDimension* dim = makeArcLengthDimension(ref);
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void createDistanceDimension(std::string type, ReferenceEntry ref1, ReferenceEntry ref2, QPoint& pos) {
-        ReferenceVector refs = { ref1 };
-        if (ref2.hasGeometry()) { // if valid
-            refs.push_back(ref2);
-        }
-
+    void createDistanceDimension(std::string type, ReferenceVector refs)
+    {
         DrawViewDimension* dim = dimMaker(partFeat, type, refs, {});
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void createExtentDistanceDimension(std::string type, QPoint& pos) {
+    void createExtentDistanceDimension(std::string type) {
         specialDimension = SpecialDimension::ExtendDistance;
 
         DrawViewDimension* dim = DrawDimHelper::makeExtentDim(partFeat, type, allRefs());
 
         dims.push_back(dim);
-        moveDimension(pos, dim);
+        moveDimension(mousePos, dim);
     }
 
-    void updateDistanceType(QPoint& pos)
+    void updateDistanceType()
     {
         if (dims.empty()) {
             return;
@@ -1098,7 +1127,7 @@ protected:
         Base::Vector3d pnt1 = Rez::guiX(pp.first());
         Base::Vector3d pnt2 = Rez::guiX(pp.second());
 
-        QPointF fpos = getDimPositionToBe(pos);
+        QPointF fpos = getDimPositionToBe(mousePos);
 
         double minX, minY, maxX, maxY;
         minX = min(pnt1.x, pnt2.x);
@@ -1127,14 +1156,15 @@ protected:
         specialDimension = SpecialDimension::LineOr2PointsDistance;
 
         if (selLine.size() == 1) {
-            createDistanceDimension(newType, selLine[0], ReferenceEntry(), pos);
+            createDistanceDimension(newType, { selLine[0] });
         }
         else {
-            createDistanceDimension(newType, selPoints[0], selPoints[1], pos);
+            createDistanceDimension(newType, { selPoints[0], selPoints[1] });
         }
+        setDimsSelectability(false);
     }
 
-    void updateExtentDistanceType(QPoint& pos)
+    void updateExtentDistanceType()
     {
         if (dims.empty()) {
             return;
@@ -1146,7 +1176,7 @@ protected:
         Base::Vector3d pnt1 = Rez::guiX(pp.first());
         Base::Vector3d pnt2 = Rez::guiX(pp.second());
 
-        QPointF fpos = getDimPositionToBe(pos);
+        QPointF fpos = getDimPositionToBe(mousePos);
 
         double minX, minY, maxX, maxY;
         minX = min(pnt1.x, pnt2.x);
@@ -1157,16 +1187,21 @@ protected:
         if (fpos.x() > minX && fpos.x() < maxX
             && (fpos.y() < minY || fpos.y() > maxY) && type != DimensionType::DistanceX) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add DistanceX extent dimension"));
-            createExtentDistanceDimension("DistanceX", pos);
+            createExtentDistanceDimension("DistanceX");
         }
         else if (fpos.y() > minY && fpos.y() < maxY
             && (fpos.x() < minX || fpos.x() > maxX) && type != DimensionType::DistanceY) {
             restartCommand(QT_TRANSLATE_NOOP("Command", "Add DistanceY extent dimension"));
-            createExtentDistanceDimension("DistanceY", pos);
+            createExtentDistanceDimension("DistanceY");
         }
+        else {
+            return;
+        }
+
+        setDimsSelectability(false);
     }
 
-    void updateChainDistanceType(QPoint& pos)
+    void updateChainDistanceType()
     {
         if (dims.empty()) {
             return;
@@ -1187,7 +1222,7 @@ protected:
             maxY = max(maxY, max(pnt1.y, pnt2.y));
         }
 
-        QPointF fpos = getDimPositionToBe(pos);
+        QPointF fpos = getDimPositionToBe(mousePos);
 
         auto type = static_cast<DimensionType>(dims[0]->Type.getValue());
 
@@ -1195,37 +1230,42 @@ protected:
             && (fpos.y() < minY || fpos.y() > maxY) && type != DimensionType::DistanceX) {
             if (specialDimension == SpecialDimension::ChainDistance) {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimensions"));
-                createChainDimension("DistanceX", pos);
+                createChainDimension("DistanceX");
             }
             else {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coord dimensions"));
-                createCoordDimension("DistanceX", pos);
+                createCoordDimension("DistanceX");
             }
         }
         else if (fpos.y() > minY && fpos.y() < maxY
             && (fpos.x() < minX || fpos.x() > maxX) && type != DimensionType::DistanceY) {
             if (specialDimension == SpecialDimension::ChainDistance) {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add vertical chain dimensions"));
-                createChainDimension("DistanceY", pos);
+                createChainDimension("DistanceY");
             }
             else {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add vertical coord dimensions"));
-                createCoordDimension("DistanceY", pos);
+                createCoordDimension("DistanceY");
             }
         }
         else if (((fpos.y() < minY || fpos.y() > maxY) && (fpos.x() < minX || fpos.x() > maxX)) && type != DimensionType::Distance) {
             if (specialDimension == SpecialDimension::ChainDistance) {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add oblique chain dimensions"));
-                createChainDimension("Distance", pos);
+                createChainDimension("Distance");
             }
             else {
                 restartCommand(QT_TRANSLATE_NOOP("Command", "Add oblique coord dimensions"));
-                createCoordDimension("Distance", pos);
+                createCoordDimension("Distance");
             }
         }
+        else {
+            return;
+        }
+
+        setDimsSelectability(false);
     }
 
-    void createChainDimension(std::string type, QPoint& pos)
+    void createChainDimension(std::string type)
     {
         specialDimension = SpecialDimension::ChainDistance;
         if (type == "Distance") {
@@ -1241,7 +1281,7 @@ protected:
         }
     }
 
-    void createCoordDimension(std::string type, QPoint& pos)
+    void createCoordDimension(std::string type)
     {
         specialDimension = SpecialDimension::CoordDistance;
         if (type == "Distance") {
@@ -1269,7 +1309,7 @@ protected:
         Gui::Command::abortCommand();
         Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Dimension"));
         specialDimension = SpecialDimension::None;
-        previousPos = QPoint(0,0);
+        mousePos = QPoint(0,0);
         clearRefVectors();
         partFeat = nullptr;
         dims.clear();
diff --git a/src/Mod/TechDraw/Gui/CommandExtensionDims.cpp b/src/Mod/TechDraw/Gui/CommandExtensionDims.cpp
index abe41eeb39..61c126598f 100644
--- a/src/Mod/TechDraw/Gui/CommandExtensionDims.cpp
+++ b/src/Mod/TechDraw/Gui/CommandExtensionDims.cpp
@@ -2377,7 +2377,7 @@ DrawViewDimension* TechDrawGui::makeArcLengthDimension(const ReferenceEntry& ref
     }
     GProp_GProps edgeProps;
     BRepGProp::LinearProperties(edge->getOCCEdge(), edgeProps);
-    double length = edgeProps.Mass();
+    double length = edgeProps.Mass() / dvp->getScale();
 
     Base::Vector3d startPt = edge->getStartPoint();
     Base::Vector3d endPt = edge->getEndPoint();
@@ -2385,7 +2385,6 @@ DrawViewDimension* TechDrawGui::makeArcLengthDimension(const ReferenceEntry& ref
     endPt.y = -endPt.y;
 
     std::stringstream startName, endName, formatSpec;
-    double scale = dvp->getScale();
     Base::Vector3d cvPoint = CosmeticVertex::makeCanonicalPoint(dvp, startPt);
     std::string startVertTag = dvp->addCosmeticVertex(cvPoint);
     int startVertNumber = dvp->add1CVToGV(startVertTag);
diff --git a/src/Mod/TechDraw/Gui/CommandExtensionDims.h b/src/Mod/TechDraw/Gui/CommandExtensionDims.h
index aebb200b29..aff7159c71 100644
--- a/src/Mod/TechDraw/Gui/CommandExtensionDims.h
+++ b/src/Mod/TechDraw/Gui/CommandExtensionDims.h
@@ -23,9 +23,12 @@
 #ifndef TECHDRAWGUI_CommandExtensionDims_H
 #define TECHDRAWGUI_CommandExtensionDims_H
 
+#include <Mod/TechDraw/TechDrawGlobal.h>
+
 namespace TechDraw
 {
     class ReferenceEntry;
+    class DrawViewDimension;
 }
 
 namespace TechDrawGui {
diff --git a/src/Mod/TechDraw/Gui/MDIViewPage.cpp b/src/Mod/TechDraw/Gui/MDIViewPage.cpp
index edbc80b1d5..f31241c2f7 100644
--- a/src/Mod/TechDraw/Gui/MDIViewPage.cpp
+++ b/src/Mod/TechDraw/Gui/MDIViewPage.cpp
@@ -110,6 +110,7 @@ MDIViewPage::MDIViewPage(ViewProviderPage* pageVp, Gui::Document* doc, QWidget*
     connect(m_printAllAction, &QAction::triggered, this, qOverload<>(&MDIViewPage::printAllPages));
 
     isSelectionBlocked = false;
+    isContextualMenuEnabled = true;
 
     QString tabText = QString::fromUtf8(pageVp->getDrawPage()->getNameInDocument());
     tabText += QString::fromUtf8("[*]");
@@ -461,14 +462,16 @@ PyObject* MDIViewPage::getPyObject()
 void MDIViewPage::contextMenuEvent(QContextMenuEvent* event)
 {
     //    Base::Console().Message("MDIVP::contextMenuEvent() - reason: %d\n", event->reason());
-    QMenu menu;
-    menu.addAction(m_toggleFrameAction);
-    menu.addAction(m_toggleKeepUpdatedAction);
-    menu.addAction(m_exportSVGAction);
-    menu.addAction(m_exportDXFAction);
-    menu.addAction(m_exportPDFAction);
-    menu.addAction(m_printAllAction);
-    menu.exec(event->globalPos());
+    if (isContextualMenuEnabled) {
+        QMenu menu;
+        menu.addAction(m_toggleFrameAction);
+        menu.addAction(m_toggleKeepUpdatedAction);
+        menu.addAction(m_exportSVGAction);
+        menu.addAction(m_exportDXFAction);
+        menu.addAction(m_exportPDFAction);
+        menu.addAction(m_printAllAction);
+        menu.exec(event->globalPos());
+    }
 }
 
 void MDIViewPage::toggleFrame() { m_vpPage->toggleFrameState(); }
@@ -1065,6 +1068,17 @@ void MDIViewPage::showStatusMsg(const char* string1, const char* string2, const
     }
 }
 
+void MDIViewPage::setDimensionsSelectability(bool val)
+{
+    for (auto scene : m_scene->items()) {
+        auto* dl = dynamic_cast<QGIDatumLabel*>(scene);
+        if (dl) {
+            dl->setSelectability(val);
+        }
+    }
+}
+
+
 // ----------------------------------------------------------------------------
 
 void MDIViewPagePy::init_type()
diff --git a/src/Mod/TechDraw/Gui/MDIViewPage.h b/src/Mod/TechDraw/Gui/MDIViewPage.h
index 6f58a19eba..175dcf98b6 100644
--- a/src/Mod/TechDraw/Gui/MDIViewPage.h
+++ b/src/Mod/TechDraw/Gui/MDIViewPage.h
@@ -109,6 +109,9 @@ public:
     void setScene(QGSPage* scene, QGVPage* view);
     void fixSceneDependencies();
 
+    void setDimensionsSelectability(bool val);
+    void enableContextualMenu(bool val) { isContextualMenuEnabled = val; }
+
 public Q_SLOTS:
     void viewAll() override;
     void saveSVG();
@@ -147,6 +150,7 @@ private:
     std::string m_objectName;
     std::string m_documentName;
     bool isSelectionBlocked;
+    bool isContextualMenuEnabled;
     QPointer<QGSPage> m_scene;
 
     QString m_currentPath;
diff --git a/src/Mod/TechDraw/Gui/QGIViewDimension.cpp b/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
index 86aaa7fc9a..d39918d11e 100644
--- a/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
+++ b/src/Mod/TechDraw/Gui/QGIViewDimension.cpp
@@ -93,8 +93,7 @@ QGIDatumLabel::QGIDatumLabel() : m_dragState(NoDrag)
     setCacheMode(QGraphicsItem::NoCache);
     setFlag(ItemSendsGeometryChanges, true);
     setFlag(ItemIsMovable, true);
-    setFlag(ItemIsSelectable, true);
-    setAcceptHoverEvents(true);
+    setSelectability(true);
     setFiltersChildEvents(true);
 
     m_dimText = new QGCustomText();
@@ -445,6 +444,13 @@ void QGIDatumLabel::setColor(QColor color)
     m_unitText->setColor(m_colNormal);
 }
 
+void QGIDatumLabel::setSelectability(bool val)
+{
+    setFlag(ItemIsSelectable, val);
+    setAcceptHoverEvents(val);
+    setAcceptedMouseButtons(val ? Qt::AllButtons : Qt::NoButton);
+}
+
 //**************************************************************
 QGIViewDimension::QGIViewDimension() : dvDimension(nullptr), hasHover(false), m_lineWidth(0.0)
 {
@@ -1258,7 +1264,7 @@ void QGIViewDimension::resetArrows() const
 }
 
 void QGIViewDimension::drawArrows(int count, const Base::Vector2d positions[], double angles[],
-                                  bool flipped) const
+                                  bool flipped, bool forcePoint) const
 {
     const int arrowCount = 2;
     QGIArrow* arrows[arrowCount] = {aHead1, aHead2};
@@ -1278,7 +1284,8 @@ void QGIViewDimension::drawArrows(int count, const Base::Vector2d positions[], d
             continue;
         }
 
-        arrow->setStyle(QGIArrow::getPrefArrowStyle());
+        // some dimensions must use point ends (area). The point style is 3.
+        arrow->setStyle(forcePoint ? 3 : QGIArrow::getPrefArrowStyle());
         auto vp = static_cast<ViewProviderDimension*>(getViewProvider(getViewObject()));
         auto arrowSize = vp->Arrowsize.getValue();
         arrow->setSize(arrowSize);
@@ -1406,7 +1413,7 @@ void QGIViewDimension::drawDimensionLine(QPainterPath& painterPath,
                                          const Base::Vector2d& targetPoint, double lineAngle,
                                          double startPosition, double jointPosition,
                                          const Base::BoundBox2d& labelRectangle, int arrowCount,
-                                         int standardStyle, bool flipArrows) const
+                                         int standardStyle, bool flipArrows, bool forcePointStyle) const
 {
     // Keep the convention start position <= 0
     jointPosition *= normalizeStartPosition(startPosition, lineAngle);
@@ -1426,7 +1433,7 @@ void QGIViewDimension::drawDimensionLine(QPainterPath& painterPath,
     arrowAngles[0] = lineAngle;
     arrowAngles[1] = lineAngle + M_PI;
 
-    drawArrows(arrowCount, arrowPositions, arrowAngles, flipArrows);
+    drawArrows(arrowCount, arrowPositions, arrowAngles, flipArrows, forcePointStyle);
 }
 
 void QGIViewDimension::drawDimensionArc(QPainterPath& painterPath, const Base::Vector2d& arcCenter,
@@ -2097,6 +2104,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
 
     Base::Vector2d labelCenter(labelRectangle.GetCenter());
     double labelAngle = 0.0;
+    bool forcePointStyle = true;
 
     if (standardStyle == ViewProviderDimension::STD_STYLE_ISO_REFERENCING
         || standardStyle == ViewProviderDimension::STD_STYLE_ASME_REFERENCING) {
@@ -2112,11 +2120,10 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
             jointDirection = getAsmeRefJointPoint(labelRectangle, left) - centerPoint;
         }
 
-        double lineAngles = jointDirection.Angle();
+        double lineAngle = jointDirection.Angle();
         double jointPositions = jointDirection.Length();
 
-        drawDimensionLine(areaPath, centerPoint, lineAngles, 0.0,
-                          jointPositions, labelRectangle, 1, standardStyle, flipArrow);
+        drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, jointPositions, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
 
         Base::Vector2d outsetPoint(standardStyle == ViewProviderDimension::STD_STYLE_ISO_REFERENCING
                                        ? getIsoRefOutsetPoint(labelRectangle, left)
@@ -2135,7 +2142,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
         lineAngle = lineAngle - M_PI;
         double labelPosition = -cos(devAngle) * ((labelCenter - centerPoint).Length());
 
-        drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow);
+        drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
     }
     else if (standardStyle == ViewProviderDimension::STD_STYLE_ASME_INLINED) {
         // Text must remain horizontal, but it may split the leader line
@@ -2143,7 +2150,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
         double lineAngle = labelDirection.Angle();
         double labelPosition = labelDirection.Length();
 
-        drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow);
+        drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
     }
     else {
         Base::Console().Error(
diff --git a/src/Mod/TechDraw/Gui/QGIViewDimension.h b/src/Mod/TechDraw/Gui/QGIViewDimension.h
index 34524c1410..f74a0cdd57 100644
--- a/src/Mod/TechDraw/Gui/QGIViewDimension.h
+++ b/src/Mod/TechDraw/Gui/QGIViewDimension.h
@@ -87,6 +87,7 @@ public:
     void setPrettyPre();
     void setPrettyNormal();
     void setColor(QColor color);
+    void setSelectability(bool val);
 
     QGCustomText* getDimText() { return m_dimText; }
     void setDimText(QGCustomText* newText) { m_dimText = newText; }
@@ -232,7 +233,7 @@ protected:
     void draw() override;
 
     void resetArrows() const;
-    void drawArrows(int count, const Base::Vector2d positions[], double angles[], bool flipped) const;
+    void drawArrows(int count, const Base::Vector2d positions[], double angles[], bool flipped, bool forcePoint = false) const;
 
     void drawSingleLine(QPainterPath &painterPath, const Base::Vector2d &lineOrigin, double lineAngle,
                         double startPosition, double endPosition) const;
@@ -245,7 +246,7 @@ protected:
 
     void drawDimensionLine(QPainterPath &painterPath, const Base::Vector2d &targetPoint, double lineAngle,
                            double startPosition, double jointPosition, const Base::BoundBox2d &labelRectangle,
-                           int arrowCount, int standardStyle, bool flipArrows) const;
+                           int arrowCount, int standardStyle, bool flipArrows, bool forcePointStyle = false) const;
     void drawDimensionArc(QPainterPath &painterPath, const Base::Vector2d &arcCenter, double arcRadius,
                           double endAngle, double startRotation, double jointAngle,
                           const Base::BoundBox2d &labelRectangle, int arrowCount,
diff --git a/src/Mod/TechDraw/Gui/QGVPage.h b/src/Mod/TechDraw/Gui/QGVPage.h
index f123a9d8f1..c39a9116e9 100644
--- a/src/Mod/TechDraw/Gui/QGVPage.h
+++ b/src/Mod/TechDraw/Gui/QGVPage.h
@@ -104,6 +104,7 @@ public:
 
     void activateHandler(TechDrawHandler* newHandler);
     void deactivateHandler();
+    bool isHandlerActive() { return toolHandler != nullptr; }
 
     bool isBalloonPlacing() const { return balloonPlacing; }
     void setBalloonPlacing(bool isPlacing) { balloonPlacing = isPlacing; }
diff --git a/src/Mod/TechDraw/Gui/TechDrawHandler.cpp b/src/Mod/TechDraw/Gui/TechDrawHandler.cpp
index cec5457435..182be5879b 100644
--- a/src/Mod/TechDraw/Gui/TechDrawHandler.cpp
+++ b/src/Mod/TechDraw/Gui/TechDrawHandler.cpp
@@ -26,6 +26,9 @@
 
 #include <QGuiApplication>
 #include <QPainter>
+#include <QKeyEvent>
+#include <QMouseEvent>
+#include <QTimer>
 
 #include <Inventor/events/SoKeyboardEvent.h>
 #endif  // #ifndef _PreComp_
@@ -55,6 +58,12 @@ TechDrawHandler::~TechDrawHandler()
 
 void TechDrawHandler::activate(QGVPage* vp)
 {
+    auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
+    if (!mdi) {
+        return;
+    }
+    mdi->enableContextualMenu(false);
+
     viewPage = vp;
 
     if (!Gui::ToolHandler::activate()) {
@@ -62,6 +71,22 @@ void TechDrawHandler::activate(QGVPage* vp)
     }
 }
 
+void TechDrawHandler::deactivate()
+{
+    Gui::ToolHandler::deactivate();
+
+    // The context menu event of MDIViewPage comes after the tool is deactivated.
+    // So to prevent the menu from appearing when the tool is cleared by right mouse click
+    // we set a small timer.
+    QTimer::singleShot(100, [this]() { // 100 milliseconds delay
+        auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
+        if (!mdi) {
+            return;
+        }
+        mdi->enableContextualMenu(true);
+    });
+}
+
 void TechDrawHandler::keyReleaseEvent(QKeyEvent* event)
 {
     // the default behaviour is to quit - specific handler categories may
@@ -72,7 +97,7 @@ void TechDrawHandler::keyReleaseEvent(QKeyEvent* event)
     }
 }
 
-bool TechDrawHandler::mousePressEvent(QMouseEvent* event)
+void TechDrawHandler::mouseReleaseEvent(QMouseEvent* event)
 {
     // the default behaviour is to quit - specific handler categories may
     // override this behaviour, for example to implement a continuous mode
@@ -80,7 +105,6 @@ bool TechDrawHandler::mousePressEvent(QMouseEvent* event)
         quit();
         event->accept();
     }
-    return true;
 }
 
 void TechDrawHandler::quit()
diff --git a/src/Mod/TechDraw/Gui/TechDrawHandler.h b/src/Mod/TechDraw/Gui/TechDrawHandler.h
index d1c911541b..3e3c8a81ea 100644
--- a/src/Mod/TechDraw/Gui/TechDrawHandler.h
+++ b/src/Mod/TechDraw/Gui/TechDrawHandler.h
@@ -39,12 +39,13 @@ public:
     virtual ~TechDrawHandler();
 
     void activate(QGVPage* vPage);
+    void deactivate() override;
 
     void quit() override;
 
     virtual void mouseMoveEvent(QMouseEvent* event) = 0;
-    virtual bool mousePressEvent(QMouseEvent* event);
-    virtual bool mouseReleaseEvent(QMouseEvent* event) = 0;
+    virtual void mousePressEvent(QMouseEvent* event) { Q_UNUSED(event) };
+    virtual void mouseReleaseEvent(QMouseEvent* event);
 
     virtual void keyPressEvent(QKeyEvent* event) = 0;
     virtual void keyReleaseEvent(QKeyEvent* event);