Sketcher: After restore migration mechanism

===========================================================

The introduction of the ability of the geometry extensions to store information leads opens new
possibilities to the sketcher, which may require migration of previous versions of the sketcher.

A striking example is the migration of the GeomPoint+Construction to mark a B-Spline knot to a proper
geometry state based on the sketch geometr extension.

It also enables to make aware the geometry of the Blocked status, by restoring the geometr blocked
status.

This commit defines an scheleton for this mechanism.

src/Mod/Sketcher/App/SketchObject.cpp

@@ -147,6 +147,7 @@ SketchObject::SketchObject()
 
     internaltransaction=false;
     managedoperation=false;
+    afterRestoreMigration=false;
 }
 
 SketchObject::~SketchObject()
@@ -7339,6 +7340,9 @@ void SketchObject::onUndoRedoFinished()
 void SketchObject::onDocumentRestored()
 {
     try {
+        if(afterRestoreMigration)
+            migrateSketch();
+
         validateExternalLinks();
         rebuildExternalGeometry();
         Constraints.acceptGeometry(getCompleteGeometry());
@@ -7358,6 +7362,9 @@ void SketchObject::onDocumentRestored()
 void SketchObject::restoreFinished()
 {
     try {
+        if(afterRestoreMigration)
+            migrateSketch();
+
         validateExternalLinks();
         rebuildExternalGeometry();
         Constraints.acceptGeometry(getCompleteGeometry());
@@ -7372,6 +7379,90 @@ void SketchObject::restoreFinished()
     }
 }
 
+void SketchObject::migrateSketch(void)
+{
+    const std::vector< Part::Geometry * > &vals = getInternalGeometry();
+
+    for( auto c : Constraints.getValues()) {
+
+        // Assign correct Internal Geometry Type
+        switch(c->AlignmentType){
+            case Undef:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::None);
+                break;
+            }
+            case EllipseMajorDiameter:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::EllipseMajorDiameter);
+                break;
+            }
+            case EllipseMinorDiameter:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::EllipseMinorDiameter);
+                break;
+            }
+            case EllipseFocus1:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::EllipseFocus1);
+                break;
+            }
+            case EllipseFocus2:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::EllipseFocus2);
+                break;
+            }
+            case HyperbolaMajor:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::HyperbolaMajor);
+                break;
+            }
+            case HyperbolaMinor:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::HyperbolaMinor);
+                break;
+            }
+            case HyperbolaFocus:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::HyperbolaFocus);
+                break;
+            }
+            case ParabolaFocus:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::ParabolaFocus);
+                break;
+            }
+            case BSplineControlPoint:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::BSplineControlPoint);
+                break;
+            }
+            case BSplineKnotPoint:
+            {
+                auto gf = GeometryFacade::getFacade(vals[c->First]);
+                gf->setInternalType(InternalType::BSplineKnotPoint);
+                break;
+            }
+        }
+
+        // Assign Blocked geometry mode
+        if(c->Type == Block){
+            auto gf = GeometryFacade::getFacade(vals[c->First]);
+            gf->setBlocked();
+        }
+    }
+}
+
 void SketchObject::getGeoVertexIndex(int VertexId, int &GeoId, PointPos &PosId) const
 {
     if (VertexId < 0 || VertexId >= int(VertexId2GeoId.size())) {

src/Mod/Sketcher/App/SketchObject.h

@@ -450,6 +450,9 @@ protected:
 
     virtual void onUndoRedoFinished() override;
 
+    // migration functions
+    void migrateSketch(void);
+
 private:
     /// Flag to allow external geometry from other bodies than the one this sketch belongs to
     bool allowOtherBody;
@@ -488,6 +491,8 @@ private:
     bool internaltransaction;
 
     bool managedoperation; // indicates whether changes to properties are the deed of SketchObject or not (for input validation)
+
+    bool afterRestoreMigration;
 };
 
 typedef App::FeaturePythonT<SketchObject> SketchObjectPython;