All: Reformat according to new standard

2025-11-11 13:49:01 +01:00
parent eafd18dac0
commit 25c3ba7338
2390 changed files with 154630 additions and 115818 deletions
--- a/src/Mod/Measure/App/AppMeasure.cpp
+++ b/src/Mod/Measure/App/AppMeasure.cpp
@@ -110,78 +110,104 @@ PyMOD_INIT_FUNC(Measure)

    // Add fundamental umf Measure Types

-    App::MeasureManager::addMeasureType("DISTANCE",
-                                        "Distance",
-                                        "Measure::MeasureDistance",
-                                        MeasureDistance::isValidSelection,
-                                        MeasureDistance::isPrioritizedSelection);
+    App::MeasureManager::addMeasureType(
+        "DISTANCE",
+        "Distance",
+        "Measure::MeasureDistance",
+        MeasureDistance::isValidSelection,
+        MeasureDistance::isPrioritizedSelection
+    );

-    App::MeasureManager::addMeasureType("DISTANCEFREE",
-                                        "Distance Free",
-                                        "Measure::MeasureDistanceDetached",
-                                        MeasureDistanceDetached::isValidSelection,
-                                        nullptr);
+    App::MeasureManager::addMeasureType(
+        "DISTANCEFREE",
+        "Distance Free",
+        "Measure::MeasureDistanceDetached",
+        MeasureDistanceDetached::isValidSelection,
+        nullptr
+    );

-    App::MeasureManager::addMeasureType("ANGLE",
-                                        "Angle",
-                                        "Measure::MeasureAngle",
-                                        MeasureAngle::isValidSelection,
-                                        MeasureAngle::isPrioritizedSelection);
+    App::MeasureManager::addMeasureType(
+        "ANGLE",
+        "Angle",
+        "Measure::MeasureAngle",
+        MeasureAngle::isValidSelection,
+        MeasureAngle::isPrioritizedSelection
+    );

-    App::MeasureManager::addMeasureType("LENGTH",
-                                        "Length",
-                                        "Measure::MeasureLength",
-                                        MeasureLength::isValidSelection,
-                                        nullptr);
+    App::MeasureManager::addMeasureType(
+        "LENGTH",
+        "Length",
+        "Measure::MeasureLength",
+        MeasureLength::isValidSelection,
+        nullptr
+    );

-    App::MeasureManager::addMeasureType("POSITION",
-                                        "Position",
-                                        "Measure::MeasurePosition",
-                                        MeasurePosition::isValidSelection,
-                                        nullptr);
+    App::MeasureManager::addMeasureType(
+        "POSITION",
+        "Position",
+        "Measure::MeasurePosition",
+        MeasurePosition::isValidSelection,
+        nullptr
+    );

-    App::MeasureManager::addMeasureType("AREA",
-                                        "Area",
-                                        "Measure::MeasureArea",
-                                        MeasureArea::isValidSelection,
-                                        nullptr);
+    App::MeasureManager::addMeasureType(
+        "AREA",
+        "Area",
+        "Measure::MeasureArea",
+        MeasureArea::isValidSelection,
+        nullptr
+    );

-    App::MeasureManager::addMeasureType("RADIUS",
-                                        "Radius",
-                                        "Measure::MeasureRadius",
-                                        MeasureRadius::isValidSelection,
-                                        MeasureRadius::isPrioritizedSelection);
+    App::MeasureManager::addMeasureType(
+        "RADIUS",
+        "Radius",
+        "Measure::MeasureRadius",
+        MeasureRadius::isValidSelection,
+        MeasureRadius::isPrioritizedSelection
+    );

    // load measure callbacks from Part module
    auto lengthList = Part::MeasureClient::reportLengthCB();
    for (auto& entry : lengthList) {
-        MeasureBaseExtendable<Part::MeasureLengthInfo>::addGeometryHandler(entry.m_module,
-                                                                           entry.m_callback);
+        MeasureBaseExtendable<Part::MeasureLengthInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }
    auto angleList = Part::MeasureClient::reportAngleCB();
    for (auto& entry : angleList) {
-        MeasureBaseExtendable<Part::MeasureAngleInfo>::addGeometryHandler(entry.m_module,
-                                                                          entry.m_callback);
+        MeasureBaseExtendable<Part::MeasureAngleInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }
    auto areaList = Part::MeasureClient::reportAreaCB();
    for (auto& entry : areaList) {
-        MeasureBaseExtendable<Part::MeasureAreaInfo>::addGeometryHandler(entry.m_module,
-                                                                         entry.m_callback);
+        MeasureBaseExtendable<Part::MeasureAreaInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }
    auto distanceList = Part::MeasureClient::reportDistanceCB();
    for (auto& entry : distanceList) {
-        MeasureBaseExtendable<Part::MeasureDistanceInfo>::addGeometryHandler(entry.m_module,
-                                                                             entry.m_callback);
+        MeasureBaseExtendable<Part::MeasureDistanceInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }
    auto positionList = Part::MeasureClient::reportPositionCB();
    for (auto& entry : positionList) {
-        MeasureBaseExtendable<Part::MeasurePositionInfo>::addGeometryHandler(entry.m_module,
-                                                                             entry.m_callback);
+        MeasureBaseExtendable<Part::MeasurePositionInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }
    auto radiusList = Part::MeasureClient::reportRadiusCB();
    for (auto& entry : radiusList) {
-        MeasureBaseExtendable<Part::MeasureRadiusInfo>::addGeometryHandler(entry.m_module,
-                                                                           entry.m_callback);
+        MeasureBaseExtendable<Part::MeasureRadiusInfo>::addGeometryHandler(
+            entry.m_module,
+            entry.m_callback
+        );
    }


--- a/src/Mod/Measure/App/AppMeasurePy.cpp
+++ b/src/Mod/Measure/App/AppMeasurePy.cpp
@@ -88,7 +88,8 @@ public:
            &Module::getLocatedTopoShape,
            "Part.TopoShape = Measure.getLocatedTopoShape(DocumentObject, longSubElement) Resolves "
            "the net placement of DocumentObject and returns the object's shape/subshape with the "
-            "net placement applied.  Link scaling operations along the path are also applied.");
+            "net placement applied.  Link scaling operations along the path are also applied."
+        );
        initialize("This is a module for measuring");  // register with Python
    }
    ~Module() override
--- a/src/Mod/Measure/App/MeasureAngle.cpp
+++ b/src/Mod/Measure/App/MeasureAngle.cpp
@@ -38,27 +38,27 @@ PROPERTY_SOURCE(Measure::MeasureAngle, Measure::MeasureBase)

 MeasureAngle::MeasureAngle()
 {
-    ADD_PROPERTY_TYPE(Element1,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "First element of the measurement");
+    ADD_PROPERTY_TYPE(Element1, (nullptr), "Measurement", App::Prop_None, "First element of the measurement");
    Element1.setScope(App::LinkScope::Global);
    Element1.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Element2,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Second element of the measurement");
+    ADD_PROPERTY_TYPE(
+        Element2,
+        (nullptr),
+        "Measurement",
+        App::Prop_None,
+        "Second element of the measurement"
+    );
    Element2.setScope(App::LinkScope::Global);
    Element2.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Angle,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Angle between the two elements");
+    ADD_PROPERTY_TYPE(
+        Angle,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Angle between the two elements"
+    );
    Angle.setUnit(Base::Unit::Angle);
 }

--- a/src/Mod/Measure/App/MeasureArea.cpp
+++ b/src/Mod/Measure/App/MeasureArea.cpp
@@ -36,19 +36,17 @@ PROPERTY_SOURCE(Measure::MeasureArea, Measure::MeasureBase)

 MeasureArea::MeasureArea()
 {
-    ADD_PROPERTY_TYPE(Elements,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Element to get the area from");
+    ADD_PROPERTY_TYPE(Elements, (nullptr), "Measurement", App::Prop_None, "Element to get the area from");
    Elements.setScope(App::LinkScope::Global);
    Elements.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Area,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Area of element");
+    ADD_PROPERTY_TYPE(
+        Area,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Area of element"
+    );
 }

 MeasureArea::~MeasureArea() = default;
--- a/src/Mod/Measure/App/MeasureBase.cpp
+++ b/src/Mod/Measure/App/MeasureBase.cpp
@@ -44,7 +44,8 @@ MeasureBase::MeasureBase()
        (Base::Placement()),
        nullptr,
        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output | App::Prop_NoRecompute),
-        "Visual placement of the measurement");
+        "Visual placement of the measurement"
+    );
 }


@@ -183,7 +184,8 @@ QString MeasureBase::getResultString()

    if (prop->isDerivedFrom<App::PropertyQuantity>()) {
        return QString::fromStdString(
-            static_cast<App::PropertyQuantity*>(prop)->getQuantityValue().getUserString());
+            static_cast<App::PropertyQuantity*>(prop)->getQuantityValue().getUserString()
+        );
    }


--- a/src/Mod/Measure/App/MeasureBase.h
+++ b/src/Mod/Measure/App/MeasureBase.h
@@ -133,16 +133,17 @@ public:

        auto handler = getGeometryHandler(mod);
        if (!handler) {
-            Base::Console().log("MeasureBaseExtendable::getMeasureInfo: No geometry handler "
-                                "available for submitted element type");
+            Base::Console().log(
+                "MeasureBaseExtendable::getMeasureInfo: No geometry handler "
+                "available for submitted element type"
+            );
            return nullptr;
        }

        return handler(subObjT);
    }

-    static void addGeometryHandlers(const std::vector<std::string>& modules,
-                                    GeometryHandler callback)
+    static void addGeometryHandlers(const std::vector<std::string>& modules, GeometryHandler callback)
    {
        // TODO: this will replace a callback with a later one.  Should we check that there isn't
        // already a handler defined for this module?
--- a/src/Mod/Measure/App/MeasureDistance.cpp
+++ b/src/Mod/Measure/App/MeasureDistance.cpp
@@ -45,58 +45,68 @@ PROPERTY_SOURCE(Measure::MeasureDistance, Measure::MeasureBase)

 MeasureDistance::MeasureDistance()
 {
-    ADD_PROPERTY_TYPE(Element1,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "First element of the measurement");
+    ADD_PROPERTY_TYPE(Element1, (nullptr), "Measurement", App::Prop_None, "First element of the measurement");
    Element1.setScope(App::LinkScope::Global);
    Element1.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Element2,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Second element of the measurement");
+    ADD_PROPERTY_TYPE(
+        Element2,
+        (nullptr),
+        "Measurement",
+        App::Prop_None,
+        "Second element of the measurement"
+    );
    Element2.setScope(App::LinkScope::Global);
    Element2.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Distance,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance between the two elements");
+    ADD_PROPERTY_TYPE(
+        Distance,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance between the two elements"
+    );
    Distance.setUnit(Base::Unit::Length);

-    ADD_PROPERTY_TYPE(DistanceX,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in X-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceX,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in X-direction"
+    );
    DistanceX.setUnit(Base::Unit::Length);
-    ADD_PROPERTY_TYPE(DistanceY,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in Y-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceY,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in Y-direction"
+    );
    DistanceY.setUnit(Base::Unit::Length);
-    ADD_PROPERTY_TYPE(DistanceZ,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in Z-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceZ,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in Z-direction"
+    );
    DistanceZ.setUnit(Base::Unit::Length);

-    ADD_PROPERTY_TYPE(Position1,
-                      (Base::Vector3d(0.0, 0.0, 0.0)),
-                      "Measurement",
-                      App::Prop_Hidden,
-                      "Position1");
-    ADD_PROPERTY_TYPE(Position2,
-                      (Base::Vector3d(0.0, 1.0, 0.0)),
-                      "Measurement",
-                      App::Prop_Hidden,
-                      "Position2");
+    ADD_PROPERTY_TYPE(
+        Position1,
+        (Base::Vector3d(0.0, 0.0, 0.0)),
+        "Measurement",
+        App::Prop_Hidden,
+        "Position1"
+    );
+    ADD_PROPERTY_TYPE(
+        Position2,
+        (Base::Vector3d(0.0, 1.0, 0.0)),
+        "Measurement",
+        App::Prop_Hidden,
+        "Position2"
+    );
 }

 MeasureDistance::~MeasureDistance() = default;
@@ -117,10 +127,9 @@ bool MeasureDistance::isValidSelection(const App::MeasureSelection& selection)
        }

        if (type != App::MeasureElementType::POINT && type != App::MeasureElementType::LINE
-            && type != App::MeasureElementType::LINESEGMENT
-            && type != App::MeasureElementType::CIRCLE && type != App::MeasureElementType::ARC
-            && type != App::MeasureElementType::CURVE && type != App::MeasureElementType::PLANE
-            && type != App::MeasureElementType::CYLINDER) {
+            && type != App::MeasureElementType::LINESEGMENT && type != App::MeasureElementType::CIRCLE
+            && type != App::MeasureElementType::ARC && type != App::MeasureElementType::CURVE
+            && type != App::MeasureElementType::PLANE && type != App::MeasureElementType::CYLINDER) {
            return false;
        }
    }
@@ -322,42 +331,42 @@ PROPERTY_SOURCE(Measure::MeasureDistanceDetached, Measure::MeasureBase)

 MeasureDistanceDetached::MeasureDistanceDetached()
 {
-    ADD_PROPERTY_TYPE(Distance,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance between the two elements");
+    ADD_PROPERTY_TYPE(
+        Distance,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance between the two elements"
+    );
    Distance.setUnit(Base::Unit::Length);

-    ADD_PROPERTY_TYPE(DistanceX,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in X-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceX,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in X-direction"
+    );
    DistanceX.setUnit(Base::Unit::Length);
-    ADD_PROPERTY_TYPE(DistanceY,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in Y-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceY,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in Y-direction"
+    );
    DistanceY.setUnit(Base::Unit::Length);
-    ADD_PROPERTY_TYPE(DistanceZ,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Distance in Z-direction");
+    ADD_PROPERTY_TYPE(
+        DistanceZ,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Distance in Z-direction"
+    );
    DistanceZ.setUnit(Base::Unit::Length);

-    ADD_PROPERTY_TYPE(Position1,
-                      (Base::Vector3d(0.0, 0.0, 0.0)),
-                      "Measurement",
-                      App::Prop_None,
-                      "Position1");
-    ADD_PROPERTY_TYPE(Position2,
-                      (Base::Vector3d(0.0, 1.0, 0.0)),
-                      "Measurement",
-                      App::Prop_None,
-                      "Position2");
+    ADD_PROPERTY_TYPE(Position1, (Base::Vector3d(0.0, 0.0, 0.0)), "Measurement", App::Prop_None, "Position1");
+    ADD_PROPERTY_TYPE(Position2, (Base::Vector3d(0.0, 1.0, 0.0)), "Measurement", App::Prop_None, "Position2");
 }

 MeasureDistanceDetached::~MeasureDistanceDetached() = default;
@@ -425,10 +434,12 @@ Base::Type MeasureDistanceType::getTypeId() const

 void MeasureDistanceType::init()
 {
-    initSubclass(MeasureDistanceType::classTypeId,
-                 "App::MeasureDistance",
-                 "App::DocumentObject",
-                 &(MeasureDistanceType::create));
+    initSubclass(
+        MeasureDistanceType::classTypeId,
+        "App::MeasureDistance",
+        "App::DocumentObject",
+        &(MeasureDistanceType::create)
+    );
 }

 void* MeasureDistanceType::create()
@@ -440,9 +451,11 @@ Base::Type MeasureDistanceType::classTypeId = Base::Type::BadType;


 // Migrate old MeasureDistance Type
-void MeasureDistanceDetached::handleChangedPropertyName(Base::XMLReader& reader,
-                                                        const char* TypeName,
-                                                        const char* PropName)
+void MeasureDistanceDetached::handleChangedPropertyName(
+    Base::XMLReader& reader,
+    const char* TypeName,
+    const char* PropName
+)
 {
    if (strcmp(PropName, "P1") == 0 && strcmp(TypeName, "App::PropertyVector") == 0) {
        Position1.Restore(reader);
--- a/src/Mod/Measure/App/MeasureDistance.h
+++ b/src/Mod/Measure/App/MeasureDistance.h
@@ -57,8 +57,7 @@ private:
 };


-class MeasureExport MeasureDistance
-    : public Measure::MeasureBaseExtendable<Part::MeasureDistanceInfo>
+class MeasureExport MeasureDistance: public Measure::MeasureBaseExtendable<Part::MeasureDistanceInfo>
 {
    PROPERTY_HEADER_WITH_OVERRIDE(Measure::MeasureDistance);

@@ -155,9 +154,11 @@ public:
    // Return the object we are measuring
    std::vector<App::DocumentObject*> getSubject() const override;

-    void handleChangedPropertyName(Base::XMLReader& reader,
-                                   const char* TypeName,
-                                   const char* PropName) override;
+    void handleChangedPropertyName(
+        Base::XMLReader& reader,
+        const char* TypeName,
+        const char* PropName
+    ) override;

 private:
    void onChanged(const App::Property* prop) override;
--- a/src/Mod/Measure/App/MeasureLength.cpp
+++ b/src/Mod/Measure/App/MeasureLength.cpp
@@ -38,19 +38,17 @@ PROPERTY_SOURCE(Measure::MeasureLength, Measure::MeasureBase)

 MeasureLength::MeasureLength()
 {
-    ADD_PROPERTY_TYPE(Elements,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Elements to get the length from");
+    ADD_PROPERTY_TYPE(Elements, (nullptr), "Measurement", App::Prop_None, "Elements to get the length from");
    Elements.setScope(App::LinkScope::Global);
    Elements.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Length,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Length of selection");
+    ADD_PROPERTY_TYPE(
+        Length,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Length of selection"
+    );
 }

 MeasureLength::~MeasureLength() = default;
--- a/src/Mod/Measure/App/MeasurePosition.cpp
+++ b/src/Mod/Measure/App/MeasurePosition.cpp
@@ -37,20 +37,18 @@ PROPERTY_SOURCE(Measure::MeasurePosition, Measure::MeasureBase)

 MeasurePosition::MeasurePosition()
 {
-    ADD_PROPERTY_TYPE(Element,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Element to get the position from");
+    ADD_PROPERTY_TYPE(Element, (nullptr), "Measurement", App::Prop_None, "Element to get the position from");
    Element.setScope(App::LinkScope::Global);
    Element.setAllowExternal(true);


-    ADD_PROPERTY_TYPE(Position,
-                      (0.0, 0.0, 0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "The absolute position");
+    ADD_PROPERTY_TYPE(
+        Position,
+        (0.0, 0.0, 0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "The absolute position"
+    );
 }

 MeasurePosition::~MeasurePosition() = default;
@@ -137,10 +135,8 @@ QString MeasurePosition::getResultString()
    int precision = 2;
    QString text;

-    QTextStream(&text) << "X: " << QString::number(value.x, 'f', precision) << " " << unit
-                       << Qt::endl
-                       << "Y: " << QString::number(value.y, 'f', precision) << " " << unit
-                       << Qt::endl
+    QTextStream(&text) << "X: " << QString::number(value.x, 'f', precision) << " " << unit << Qt::endl
+                       << "Y: " << QString::number(value.y, 'f', precision) << " " << unit << Qt::endl
                       << "Z: " << QString::number(value.z, 'f', precision) << " " << unit;
    return text;
 }
--- a/src/Mod/Measure/App/MeasurePosition.h
+++ b/src/Mod/Measure/App/MeasurePosition.h
@@ -42,8 +42,7 @@ namespace Measure
 {


-class MeasureExport MeasurePosition
-    : public Measure::MeasureBaseExtendable<Part::MeasurePositionInfo>
+class MeasureExport MeasurePosition: public Measure::MeasureBaseExtendable<Part::MeasurePositionInfo>
 {
    PROPERTY_HEADER_WITH_OVERRIDE(Measure::MeasurePosition);

--- a/src/Mod/Measure/App/MeasureRadius.cpp
+++ b/src/Mod/Measure/App/MeasureRadius.cpp
@@ -45,19 +45,17 @@ PROPERTY_SOURCE(Measure::MeasureRadius, Measure::MeasureBase)

 MeasureRadius::MeasureRadius()
 {
-    ADD_PROPERTY_TYPE(Element,
-                      (nullptr),
-                      "Measurement",
-                      App::Prop_None,
-                      "Element to get the radius from");
+    ADD_PROPERTY_TYPE(Element, (nullptr), "Measurement", App::Prop_None, "Element to get the radius from");
    Element.setScope(App::LinkScope::Global);
    Element.setAllowExternal(true);

-    ADD_PROPERTY_TYPE(Radius,
-                      (0.0),
-                      "Measurement",
-                      App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
-                      "Radius of selection");
+    ADD_PROPERTY_TYPE(
+        Radius,
+        (0.0),
+        "Measurement",
+        App::PropertyType(App::Prop_ReadOnly | App::Prop_Output),
+        "Radius of selection"
+    );
 }

 MeasureRadius::~MeasureRadius() = default;
--- a/src/Mod/Measure/App/Measurement.cpp
+++ b/src/Mod/Measure/App/Measurement.cpp
@@ -127,11 +127,12 @@ MeasureType Measurement::findType()
    for (; obj != objects.end(); ++obj, ++subEl) {
        TopoDS_Shape refSubShape;
        try {
-            refSubShape = Part::Feature::getShape(*obj,
-                                                  Part::ShapeOption::NeedSubElement
-                                                      | Part::ShapeOption::ResolveLink
-                                                      | Part::ShapeOption::Transform,
-                                                  (*subEl).c_str());
+            refSubShape = Part::Feature::getShape(
+                *obj,
+                Part::ShapeOption::NeedSubElement | Part::ShapeOption::ResolveLink
+                    | Part::ShapeOption::Transform,
+                (*subEl).c_str()
+            );

            if (refSubShape.IsNull()) {
                return MeasureType::Invalid;
@@ -324,14 +325,14 @@ MeasureType Measurement::getType()
    return measureType;
 }

-TopoDS_Shape
-Measurement::getShape(App::DocumentObject* obj, const char* subName, TopAbs_ShapeEnum hint) const
+TopoDS_Shape Measurement::getShape(App::DocumentObject* obj, const char* subName, TopAbs_ShapeEnum hint) const
 {
-    return Part::Feature::getShape(obj,
-                                   Part::ShapeOption::NeedSubElement
-                                       | Part::ShapeOption::ResolveLink
-                                       | Part::ShapeOption::Transform,
-                                   subName);
+    return Part::Feature::getShape(
+        obj,
+        Part::ShapeOption::NeedSubElement | Part::ShapeOption::ResolveLink
+            | Part::ShapeOption::Transform,
+        subName
+    );
 }


@@ -408,7 +409,8 @@ double Measurement::length() const
                    }
                    default: {
                        throw Base::RuntimeError(
-                            "Measurement - length - Curve type not currently handled");
+                            "Measurement - length - Curve type not currently handled"
+                        );
                    }
                }
            }
@@ -618,8 +620,7 @@ double Measurement::cylinderAxisDistance() const
        BRepAdaptor_Surface surface2(face2);

        if (surface1.GetType() == GeomAbs_Cylinder && surface2.GetType() == GeomAbs_Cylinder) {
-            distance =
-                gp_Lin(surface1.Cylinder().Axis()).Distance(gp_Lin(surface2.Cylinder().Axis()));
+            distance = gp_Lin(surface1.Cylinder().Axis()).Distance(gp_Lin(surface2.Cylinder().Axis()));
        }
    }
    else if (measureType == MeasureType::CircleToCylinder) {
@@ -740,7 +741,8 @@ double Measurement::angle(const Base::Vector3d& /*param*/) const
            }
            double aRad = axis1.Angle(axis2);
            return Base::toDegrees<double>(
-                std::min(aRad, std::fmod(aRad + std::numbers::pi, 2.0 * std::numbers::pi)));
+                std::min(aRad, std::fmod(aRad + std::numbers::pi, 2.0 * std::numbers::pi))
+            );
        }
    }
    throw Base::RuntimeError("Unexpected error for angle measurement");
@@ -831,10 +833,8 @@ Base::Vector3d Measurement::delta() const
        if (measureType == MeasureType::PointToPoint) {
            if (numRefs == 2) {
                // Keep separate case for two points to reduce need for complex algorithm
-                TopoDS_Shape shape1 =
-                    getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_VERTEX);
-                TopoDS_Shape shape2 =
-                    getShape(objects.at(1), subElements.at(1).c_str(), TopAbs_VERTEX);
+                TopoDS_Shape shape1 = getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_VERTEX);
+                TopoDS_Shape shape2 = getShape(objects.at(1), subElements.at(1).c_str(), TopAbs_VERTEX);

                const TopoDS_Vertex& vert1 = TopoDS::Vertex(shape1);
                const TopoDS_Vertex& vert2 = TopoDS::Vertex(shape2);
@@ -845,8 +845,7 @@ Base::Vector3d Measurement::delta() const
                return Base::Vector3d(diff.X(), diff.Y(), diff.Z());
            }
        }
-        else if (measureType == MeasureType::PointToEdge
-                 || measureType == MeasureType::PointToSurface
+        else if (measureType == MeasureType::PointToEdge || measureType == MeasureType::PointToSurface
                 || measureType == MeasureType::PointToCircle
                 || measureType == MeasureType::PointToCylinder) {
            // BrepExtema can calculate minimum distance between any set of topology sets.
@@ -870,8 +869,7 @@ Base::Vector3d Measurement::delta() const
        else if (measureType == MeasureType::Edges) {
            // Only case that is supported is straight line edge
            if (numRefs == 1) {
-                TopoDS_Shape shape =
-                    getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_EDGE);
+                TopoDS_Shape shape = getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_EDGE);
                const TopoDS_Edge& edge = TopoDS::Edge(shape);
                BRepAdaptor_Curve curve(edge);

@@ -883,10 +881,8 @@ Base::Vector3d Measurement::delta() const
                }
            }
            else if (numRefs == 2) {
-                TopoDS_Shape shape1 =
-                    getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_EDGE);
-                TopoDS_Shape shape2 =
-                    getShape(objects.at(1), subElements.at(1).c_str(), TopAbs_EDGE);
+                TopoDS_Shape shape1 = getShape(objects.at(0), subElements.at(0).c_str(), TopAbs_EDGE);
+                TopoDS_Shape shape2 = getShape(objects.at(1), subElements.at(1).c_str(), TopAbs_EDGE);

                BRepAdaptor_Curve curve1(TopoDS::Edge(shape1));
                BRepAdaptor_Curve curve2(TopoDS::Edge(shape2));
@@ -1026,11 +1022,12 @@ bool Measurement::planesAreParallel() const
    for (size_t i = 0; i < objects.size(); ++i) {
        TopoDS_Shape refSubShape;
        try {
-            refSubShape = Part::Feature::getShape(objects[i],
-                                                  Part::ShapeOption::NeedSubElement
-                                                      | Part::ShapeOption::ResolveLink
-                                                      | Part::ShapeOption::Transform,
-                                                  subElements[i].c_str());
+            refSubShape = Part::Feature::getShape(
+                objects[i],
+                Part::ShapeOption::NeedSubElement | Part::ShapeOption::ResolveLink
+                    | Part::ShapeOption::Transform,
+                subElements[i].c_str()
+            );

            if (refSubShape.IsNull()) {
                return false;
--- a/src/Mod/Measure/App/Measurement.h
+++ b/src/Mod/Measure/App/Measurement.h
@@ -111,8 +111,7 @@ public:
    double diameter() const;

    // Calculates the angle between two edges
-    double
-    angle(const Base::Vector3d& param = Base::Vector3d(0, 0, 0)) const;  // param is never used???
+    double angle(const Base::Vector3d& param = Base::Vector3d(0, 0, 0)) const;  // param is never used???

    // Calculate the center of mass
    Base::Vector3d massCenter() const;
@@ -134,9 +133,11 @@ public:
 protected:
    // Hint parameter helps sort out compound shapes by specifying a subelement type
    // use hint = TopAbs_COMPOUND to give no hint
-    TopoDS_Shape getShape(App::DocumentObject* obj,
-                          const char* subName,
-                          TopAbs_ShapeEnum hint = TopAbs_COMPOUND) const;
+    TopoDS_Shape getShape(
+        App::DocumentObject* obj,
+        const char* subName,
+        TopAbs_ShapeEnum hint = TopAbs_COMPOUND
+    ) const;

 private:
    MeasureType measureType;
--- a/src/Mod/Measure/App/Preferences.cpp
+++ b/src/Mod/Measure/App/Preferences.cpp
@@ -50,7 +50,8 @@ Base::Color Preferences::defaultLineColor()
 {
    Base::Color fcColor;
    fcColor.setPackedValue(
-        getPreferenceGroup("Appearance")->GetUnsigned("DefaultLineColor", 0x3CF00000));
+        getPreferenceGroup("Appearance")->GetUnsigned("DefaultLineColor", 0x3CF00000)
+    );
    return fcColor;
 }

@@ -58,7 +59,8 @@ Base::Color Preferences::defaultTextColor()
 {
    Base::Color fcColor;
    fcColor.setPackedValue(
-        getPreferenceGroup("Appearance")->GetUnsigned("DefaultTextColor", 0x00000000));
+        getPreferenceGroup("Appearance")->GetUnsigned("DefaultTextColor", 0x00000000)
+    );
    return fcColor;
 }

@@ -66,7 +68,8 @@ Base::Color Preferences::defaultTextBackgroundColor()
 {
    Base::Color fcColor;
    fcColor.setPackedValue(
-        getPreferenceGroup("Appearance")->GetUnsigned("DefaultTextBackgroundColor", 0x3CF00000));
+        getPreferenceGroup("Appearance")->GetUnsigned("DefaultTextBackgroundColor", 0x3CF00000)
+    );
    return fcColor;
 }

--- a/src/Mod/Measure/App/ShapeFinder.cpp
+++ b/src/Mod/Measure/App/ShapeFinder.cpp
@@ -55,9 +55,11 @@ using namespace Measure;
 //! ResolveResult is a class to hold the result of resolving a selection into the actual target
 //! object and traditional subElement name (Vertex1).

-ResolveResult::ResolveResult(const App::DocumentObject* realTarget,
-                             const std::string& shortSubName,
-                             const App::DocumentObject* targetParent)
+ResolveResult::ResolveResult(
+    const App::DocumentObject* realTarget,
+    const std::string& shortSubName,
+    const App::DocumentObject* targetParent
+)
    : m_target(App::SubObjectT(realTarget, shortSubName.c_str()))
    , m_targetParent(App::DocumentObjectT(targetParent))
 {}
@@ -80,14 +82,16 @@ App::DocumentObject& ResolveResult::getTargetParent() const

 //! returns the actual target object and subname pointed to by selectObj and selectLongSub (which
 //! is likely a result from getSelection or getSelectionEx)
-ResolveResult ShapeFinder::resolveSelection(const App::DocumentObject& selectObj,
-                                            const std::string& selectLongSub)
+ResolveResult ShapeFinder::resolveSelection(
+    const App::DocumentObject& selectObj,
+    const std::string& selectLongSub
+)
 {
    App::DocumentObject* targetParent {nullptr};
    std::string childName {};
    const char* subElement {nullptr};
-    App::DocumentObject* realTarget =
-        selectObj.resolve(selectLongSub.c_str(), &targetParent, &childName, &subElement);
+    App::DocumentObject* realTarget
+        = selectObj.resolve(selectLongSub.c_str(), &targetParent, &childName, &subElement);
    auto shortSub = getLastTerm(selectLongSub);
    return {realTarget, shortSub, targetParent};
 }
@@ -100,8 +104,7 @@ ResolveResult ShapeFinder::resolveSelection(const App::DocumentObject& selectObj
 // TODO: to truly locate the shape, we need to consider attachments - see
 // ShapeExtractor::getShapesFromXRoot()
 //       and ShapeFinder::getLinkAttachParent()
-TopoDS_Shape ShapeFinder::getLocatedShape(const App::DocumentObject& rootObject,
-                                          const std::string& leafSub)
+TopoDS_Shape ShapeFinder::getLocatedShape(const App::DocumentObject& rootObject, const std::string& leafSub)
 {
    auto resolved = resolveSelection(rootObject, leafSub);
    auto target = &resolved.getTarget();
@@ -110,9 +113,10 @@ TopoDS_Shape ShapeFinder::getLocatedShape(const App::DocumentObject& rootObject,
        return {};
    }

-    TopoDS_Shape shape =
-        Part::Feature::getShape(target,
-                                Part::ShapeOption::ResolveLink | Part::ShapeOption::Transform);
+    TopoDS_Shape shape = Part::Feature::getShape(
+        target,
+        Part::ShapeOption::ResolveLink | Part::ShapeOption::Transform
+    );
    if (isShapeReallyNull(shape)) {
        return {};
    }
@@ -131,8 +135,10 @@ TopoDS_Shape ShapeFinder::getLocatedShape(const App::DocumentObject& rootObject,


 //! convenient version of previous method
-Part::TopoShape ShapeFinder::getLocatedTopoShape(const App::DocumentObject& rootObject,
-                                                 const std::string& leafSub)
+Part::TopoShape ShapeFinder::getLocatedTopoShape(
+    const App::DocumentObject& rootObject,
+    const std::string& leafSub
+)
 {
    return {getLocatedShape(rootObject, leafSub)};
 }
@@ -142,10 +148,12 @@ Part::TopoShape ShapeFinder::getLocatedTopoShape(const App::DocumentObject& root
 //! the placements will need to be applied in the reverse order (ie top down) of what is delivered
 //! in plm stack.  leafSub is a dot separated longSubName which DOES NOT include rootObject.  the
 //! result does not include rootObject's transform.
-void ShapeFinder::crawlPlacementChain(std::vector<Base::Placement>& plmStack,
-                                      std::vector<Base::Matrix4D>& scaleStack,
-                                      const App::DocumentObject& rootObject,
-                                      const std::string& leafSub)
+void ShapeFinder::crawlPlacementChain(
+    std::vector<Base::Placement>& plmStack,
+    std::vector<Base::Matrix4D>& scaleStack,
+    const App::DocumentObject& rootObject,
+    const std::string& leafSub
+)
 {
    auto currentSub = leafSub;
    std::string previousSub {};
@@ -169,9 +177,11 @@ void ShapeFinder::crawlPlacementChain(std::vector<Base::Placement>& plmStack,

 //! return inShape with placement and scaler applied.  If inShape contains any infinite subshapes
 //! (such as Datum planes), the infinite shapes will not be included in the result.
-TopoDS_Shape ShapeFinder::transformShape(TopoDS_Shape& inShape,
-                                         const Base::Placement& placement,
-                                         const Base::Matrix4D& scaler)
+TopoDS_Shape ShapeFinder::transformShape(
+    TopoDS_Shape& inShape,
+    const Base::Placement& placement,
+    const Base::Matrix4D& scaler
+)
 {
    if (isShapeReallyNull(inShape)) {
        return {};
@@ -294,8 +304,10 @@ bool ShapeFinder::isShapeReallyNull(const TopoDS_Shape& shape)

 //! Returns the net transformation of a path from rootObject to leafSub. rootObject's transform
 //! is included in the result.
-std::pair<Base::Placement, Base::Matrix4D>
-ShapeFinder::getGlobalTransform(const App::DocumentObject& rootObject, const std::string& leafSub)
+std::pair<Base::Placement, Base::Matrix4D> ShapeFinder::getGlobalTransform(
+    const App::DocumentObject& rootObject,
+    const std::string& leafSub
+)
 {
    // we prune the last term if it is a vertex, edge or face
    std::string newSub = removeGeometryTerm(leafSub);
@@ -321,8 +333,9 @@ ShapeFinder::getGlobalTransform(const App::DocumentObject& rootObject, const std

 //! tries to get the global position and scale for a object with no information about the
 //! path through the tree from a root to cursor object.
-std::pair<Base::Placement, Base::Matrix4D>
-ShapeFinder::getGlobalTransform(const App::DocumentObject* cursorObject)
+std::pair<Base::Placement, Base::Matrix4D> ShapeFinder::getGlobalTransform(
+    const App::DocumentObject* cursorObject
+)
 {
    if (!cursorObject) {
        return {};
@@ -346,9 +359,10 @@ ShapeFinder::getGlobalTransform(const App::DocumentObject* cursorObject)

 //! combine a series of placement & scale transforms.  The input stacks are expected in leaf to root
 //! order, but the result is in the expected root to leaf order.
-std::pair<Base::Placement, Base::Matrix4D>
-ShapeFinder::sumTransforms(const std::vector<Base::Placement>& plmStack,
-                           const std::vector<Base::Matrix4D>& scaleStack)
+std::pair<Base::Placement, Base::Matrix4D> ShapeFinder::sumTransforms(
+    const std::vector<Base::Placement>& plmStack,
+    const std::vector<Base::Matrix4D>& scaleStack
+)
 {
    Base::Placement netPlm;
    Base::Matrix4D netScale;
@@ -398,9 +412,11 @@ std::string ShapeFinder::PlacementAsString(const Base::Placement& inPlacement)
 //! debug routine. return readable form of TopLoc_Location from OCC
 std::string ShapeFinder::LocationAsString(const TopLoc_Location& location)
 {
-    auto position = Base::Vector3d {location.Transformation().TranslationPart().X(),
-                                    location.Transformation().TranslationPart().Y(),
-                                    location.Transformation().TranslationPart().Z()};
+    auto position = Base::Vector3d {
+        location.Transformation().TranslationPart().X(),
+        location.Transformation().TranslationPart().Y(),
+        location.Transformation().TranslationPart().Z()
+    };
    gp_XYZ axisDir;
    double angle {0};
    auto isRotation = location.Transformation().GetRotation(axisDir, angle);
--- a/src/Mod/Measure/App/ShapeFinder.h
+++ b/src/Mod/Measure/App/ShapeFinder.h
@@ -47,9 +47,11 @@ class MeasureExport ResolveResult
 {
 public:
    ResolveResult();
-    ResolveResult(const App::DocumentObject* realTarget,
-                  const std::string& shortSubName,
-                  const App::DocumentObject* targetParent);
+    ResolveResult(
+        const App::DocumentObject* realTarget,
+        const std::string& shortSubName,
+        const App::DocumentObject* targetParent
+    );

    App::DocumentObject& getTarget() const;
    std::string getShortSub() const;
@@ -65,24 +67,35 @@ private:
 class MeasureExport ShapeFinder: public SubnameHelper
 {
 public:
-    static TopoDS_Shape getLocatedShape(const App::DocumentObject& rootObject,
-                                        const std::string& leafSub);
-    static Part::TopoShape getLocatedTopoShape(const App::DocumentObject& rootObject,
-                                               const std::string& leafSub);
+    static TopoDS_Shape getLocatedShape(
+        const App::DocumentObject& rootObject,
+        const std::string& leafSub
+    );
+    static Part::TopoShape getLocatedTopoShape(
+        const App::DocumentObject& rootObject,
+        const std::string& leafSub
+    );


-    static std::pair<Base::Placement, Base::Matrix4D>
-    getGlobalTransform(const App::DocumentObject& rootObject, const std::string& leafSub);
-    static std::pair<Base::Placement, Base::Matrix4D>
-    getGlobalTransform(const App::DocumentObject* cursorObject);
+    static std::pair<Base::Placement, Base::Matrix4D> getGlobalTransform(
+        const App::DocumentObject& rootObject,
+        const std::string& leafSub
+    );
+    static std::pair<Base::Placement, Base::Matrix4D> getGlobalTransform(
+        const App::DocumentObject* cursorObject
+    );

-    static void crawlPlacementChain(std::vector<Base::Placement>& plmStack,
-                                    std::vector<Base::Matrix4D>& scaleStack,
-                                    const App::DocumentObject& rootObj,
-                                    const std::string& leafSub);
+    static void crawlPlacementChain(
+        std::vector<Base::Placement>& plmStack,
+        std::vector<Base::Matrix4D>& scaleStack,
+        const App::DocumentObject& rootObj,
+        const std::string& leafSub
+    );

-    static ResolveResult resolveSelection(const App::DocumentObject& selectObj,
-                                          const std::string& selectLongSub);
+    static ResolveResult resolveSelection(
+        const App::DocumentObject& selectObj,
+        const std::string& selectLongSub
+    );

    static Base::Placement getPlacement(const App::DocumentObject* root);
    static Base::Matrix4D getScale(const App::DocumentObject* root);
@@ -91,34 +104,42 @@ public:
    static std::string PlacementAsString(const Base::Placement& inPlacement);
    static std::string LocationAsString(const TopLoc_Location& location);

-    static TopoDS_Shape transformShape(TopoDS_Shape& inShape,
-                                       const Base::Placement& placement,
-                                       const Base::Matrix4D& scaler);
+    static TopoDS_Shape transformShape(
+        TopoDS_Shape& inShape,
+        const Base::Placement& placement,
+        const Base::Matrix4D& scaler
+    );
    static TopoDS_Shape stripInfiniteShapes(const TopoDS_Shape& inShape);
    static bool isShapeReallyNull(const TopoDS_Shape& shape);

-    static std::pair<Base::Placement, Base::Matrix4D>
-    sumTransforms(const std::vector<Base::Placement>& plmStack,
-                  const std::vector<Base::Matrix4D>& scaleStack);
+    static std::pair<Base::Placement, Base::Matrix4D> sumTransforms(
+        const std::vector<Base::Placement>& plmStack,
+        const std::vector<Base::Matrix4D>& scaleStack
+    );
    static App::DocumentObject* getLinkAttachParent(const App::DocumentObject* attachedObject);
    static Base::Placement getAttachedPlacement(const App::DocumentObject* cursorObject);

    static std::string getFullPath(const App::DocumentObject* object);
    static std::vector<App::DocumentObject*> getGeometryRootObjects(const App::Document* doc);
-    static std::vector<std::list<App::DocumentObject*>>
-    getGeometryPathsFromOutList(const App::DocumentObject* object);
+    static std::vector<std::list<App::DocumentObject*>> getGeometryPathsFromOutList(
+        const App::DocumentObject* object
+    );


 private:
    static bool ignoreModule(const std::string& moduleName);
    static bool ignoreObject(const App::DocumentObject* object);
-    static bool ignoreLinkAttachedObject(const App::DocumentObject* object,
-                                         const App::DocumentObject* inlistObject);
-    static std::vector<App::DocumentObject*>
-    tidyInList(const std::vector<App::DocumentObject*>& inlist);
-    static std::vector<App::DocumentObject*>
-    tidyInListAttachment(const App::DocumentObject* owner,
-                         const std::vector<App::DocumentObject*>& inlist);
+    static bool ignoreLinkAttachedObject(
+        const App::DocumentObject* object,
+        const App::DocumentObject* inlistObject
+    );
+    static std::vector<App::DocumentObject*> tidyInList(
+        const std::vector<App::DocumentObject*>& inlist
+    );
+    static std::vector<App::DocumentObject*> tidyInListAttachment(
+        const App::DocumentObject* owner,
+        const std::vector<App::DocumentObject*>& inlist
+    );
 };

 }  // namespace Measure