Fixed path serialization

src/PixiEditor/Models/Serialization/Factories/EllipseSerializationFactory.cs

@@ -15,8 +15,10 @@ public class EllipseSerializationFactory : VectorShapeSerializationFactory<Ellip
         builder.AddVecD(original.Radius);
     }
 
-    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor,
-        float strokeWidth, out EllipseVectorData original)
+    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor,
+        float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out EllipseVectorData original)
     {
         VecD center = extractor.GetVecD();
         VecD radius = extractor.GetVecD();

src/PixiEditor/Models/Serialization/Factories/LineSerializationFactory.cs

@@ -15,8 +15,10 @@ internal class LineSerializationFactory : VectorShapeSerializationFactory<LineVe
         builder.AddVecD(original.End);
     }
 
-    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor,
-        float strokeWidth, out LineVectorData original)
+    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor,
+        float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out LineVectorData original)
     {
         VecD start = extractor.GetVecD();
         VecD end = extractor.GetVecD();

src/PixiEditor/Models/Serialization/Factories/PointsDataSerializationFactory.cs

@@ -13,8 +13,10 @@ internal class PointsDataSerializationFactory : VectorShapeSerializationFactory<
         builder.AddVecDList(original.Points);
     }
 
-    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor,
-        float strokeWidth, out PointsVectorData original)
+    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor,
+        float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out PointsVectorData original)
     {
         List<VecD> points = extractor.GetVecDList();
         original = new PointsVectorData(points)

src/PixiEditor/Models/Serialization/Factories/RectangleSerializationFactory.cs

@@ -16,8 +16,10 @@ internal class RectangleSerializationFactory : VectorShapeSerializationFactory<R
         builder.AddVecD(original.Size);
     }
 
-    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor,
-        float strokeWidth, out RectangleVectorData original)
+    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor,
+        float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out RectangleVectorData original)
     {
         VecD center = extractor.GetVecD();
         VecD size = extractor.GetVecD();

src/PixiEditor/Models/Serialization/Factories/VectorPathSerializationFactory.cs

@@ -3,24 +3,49 @@ using Drawie.Backend.Core.ColorsImpl;
 using Drawie.Backend.Core.Numerics;
 using Drawie.Backend.Core.Vector;
 using Drawie.Numerics;
+using PixiEditor.Views.Overlays.PathOverlay;
 
 namespace PixiEditor.Models.Serialization.Factories;
 
-internal class VectorPathSerializationFactory : VectorShapeSerializationFactory<PathVectorData> 
+internal class VectorPathSerializationFactory : VectorShapeSerializationFactory<PathVectorData>
 {
     public override string DeserializationId { get; } = "PixiEditor.PathData";
 
     protected override void AddSpecificData(ByteBuilder builder, PathVectorData original)
     {
-        builder.AddString(original.Path.ToSvgPathData());
+        if (original.Path == null)
+        {
+            return;
+        }
+
+        EditableVectorPath path = new EditableVectorPath(original.Path);
+
+        builder.AddInt((int)path.Path.FillType);
+        builder.AddInt(path.SubShapes.Count);
+
+        foreach (var subShape in path.SubShapes)
+        {
+            SerializeSubShape(builder, subShape);
+        }
     }
 
-    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor,
-        float strokeWidth, out PathVectorData original)
+    protected override bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor,
+        float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out PathVectorData original)
     {
-        string path = extractor.GetString();
+        VectorPath path;
+        if (IsOldSerializer(serializerData))
+        {
+            string svgPath = extractor.GetString();
+            path = VectorPath.FromSvgPath(svgPath);
+        }
+        else
+        {
+            path = DeserializePath(extractor).ToVectorPath();
+        }
 
-        original = new PathVectorData(VectorPath.FromSvgPath(path))
+        original = new PathVectorData(path)
         {
             StrokeColor = strokeColor,
             FillColor = fillColor,
@@ -30,4 +55,118 @@ internal class VectorPathSerializationFactory : VectorShapeSerializationFactory<
 
         return true;
     }
+
+    private void SerializeSubShape(ByteBuilder builder, SubShape subShape)
+    {
+        builder.AddInt(subShape.IsClosed ? 1 : 0);
+        builder.AddInt(subShape.Points.Count);
+
+        foreach (var point in subShape.Points)
+        {
+            builder.AddFloat(point.Position.X);
+            builder.AddFloat(point.Position.Y);
+
+            builder.AddInt(point.Verb.IsEmptyVerb() ? -1 : (int)point.Verb.VerbType);
+            builder.AddFloat(point.Verb.From.X);
+            builder.AddFloat(point.Verb.From.Y);
+            
+            builder.AddFloat(point.Verb.To.X);
+            builder.AddFloat(point.Verb.To.Y);
+
+            if (HasControlPoint1(point))
+            {
+                builder.AddFloat(point.Verb.ControlPoint1.Value.X);
+                builder.AddFloat(point.Verb.ControlPoint1.Value.Y);
+            }
+
+            if (HasControlPoint2(point))
+            {
+                builder.AddFloat(point.Verb.ControlPoint2.Value.X);
+                builder.AddFloat(point.Verb.ControlPoint2.Value.Y);
+            }
+
+            if (IsConic(point))
+            {
+                builder.AddFloat(point.Verb.ConicWeight);
+            }
+        }
+    }
+    
+    private EditableVectorPath DeserializePath(ByteExtractor extractor)
+    {
+        PathFillType fillType = (PathFillType)extractor.GetInt();
+        int subShapesCount = extractor.GetInt();
+        List<SubShape> subShapes = new List<SubShape>();
+
+        for (int i = 0; i < subShapesCount; i++)
+        {
+            SubShape subShape = DeserializeSubShape(extractor);
+            subShapes.Add(subShape);
+        }
+
+        return new EditableVectorPath(subShapes, fillType);
+    }
+    
+    private SubShape DeserializeSubShape(ByteExtractor extractor)
+    {
+        bool isClosed = extractor.GetInt() == 1;
+        int pointsCount = extractor.GetInt();
+        List<ShapePoint> points = new List<ShapePoint>();
+
+        for (int i = 0; i < pointsCount; i++)
+        {
+            VecF position = new VecF(extractor.GetFloat(), extractor.GetFloat());
+            PathVerb verbType = (PathVerb)extractor.GetInt();
+            
+            VecF from = new VecF(extractor.GetFloat(), extractor.GetFloat());
+            VecF to = new VecF(extractor.GetFloat(), extractor.GetFloat());
+            
+            VecF? controlPoint1 = verbType is PathVerb.Cubic or PathVerb.Quad or PathVerb.Conic
+                ? new VecF(extractor.GetFloat(), extractor.GetFloat())
+                : null;
+            VecF? controlPoint2 = verbType is PathVerb.Cubic or PathVerb.Quad
+                ? new VecF(extractor.GetFloat(), extractor.GetFloat())
+                : null;
+            float conicWeight = verbType == PathVerb.Conic ? extractor.GetFloat() : 0;
+
+            Verb verb = new Verb(verbType, from, to, controlPoint1, controlPoint2, conicWeight);
+            
+            points.Add(new ShapePoint(position, points.Count, verb));
+        }
+
+        return new SubShape(points, isClosed);
+    }
+
+    private bool HasControlPoint1(ShapePoint point)
+    {
+        return (point.Verb.VerbType is PathVerb.Conic or PathVerb.Cubic or PathVerb.Quad) &&
+               point.Verb.ControlPoint1.HasValue;
+    }
+
+    private bool HasControlPoint2(ShapePoint point)
+    {
+        return (point.Verb.VerbType is PathVerb.Cubic or PathVerb.Quad) &&
+               point.Verb.ControlPoint2.HasValue;
+    }
+
+    private bool IsConic(ShapePoint point)
+    {
+        return point.Verb.VerbType == PathVerb.Conic;
+    }
+
+    private bool IsOldSerializer((string serializerName, string serializerVersion) serializerData)
+    {
+        if (string.IsNullOrEmpty(serializerData.serializerName) ||
+            string.IsNullOrEmpty(serializerData.serializerVersion))
+        {
+            return false;
+        }
+
+        if (Version.TryParse(serializerData.serializerVersion, out Version version))
+        {
+            return version is { Major: 2, Minor: 0, Build: 0, Revision: < 35 };
+        }
+
+        return false;
+    }
 }

src/PixiEditor/Models/Serialization/Factories/VectorShapeSerializationFactory.cs

@@ -46,8 +46,10 @@ public abstract class VectorShapeSerializationFactory<T> : SerializationFactory<
             strokeWidth = extractor.GetFloat();
         }
 
-        return DeserializeVectorData(extractor, matrix, strokeColor, fillColor, strokeWidth, out original);
+        return DeserializeVectorData(extractor, matrix, strokeColor, fillColor, strokeWidth, serializerData, out original);
     }
     
-    protected abstract bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor, Color fillColor, float strokeWidth, out T original);
+    protected abstract bool DeserializeVectorData(ByteExtractor extractor, Matrix3X3 matrix, Color strokeColor,
+        Color fillColor, float strokeWidth, (string serializerName, string serializerVersion) serializerData,
+        out T original);
 }

src/PixiEditor/Properties/AssemblyInfo.cs

@@ -41,5 +41,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.0.34")]
-[assembly: AssemblyFileVersion("2.0.0.34")]
+[assembly: AssemblyVersion("2.0.0.35")]
+[assembly: AssemblyFileVersion("2.0.0.35")]

src/PixiEditor/Views/Overlays/PathOverlay/EditableVectorPath.cs

@@ -5,9 +5,9 @@ namespace PixiEditor.Views.Overlays.PathOverlay;
 
 public class EditableVectorPath
 {
-    private VectorPath path;
+    private VectorPath? path;
 
-    public VectorPath Path
+    public VectorPath? Path
     {
         get => path;
         set
@@ -23,6 +23,8 @@ public class EditableVectorPath
 
     public int TotalPoints => subShapes.Sum(x => x.Points.Count);
 
+    public PathFillType FillType { get; set; }
+
     public int ControlPointsCount
     {
         get
@@ -32,6 +34,12 @@ public class EditableVectorPath
         }
     }
 
+    public EditableVectorPath(IEnumerable<SubShape> subShapes, PathFillType fillType)
+    {
+        this.subShapes = new List<SubShape>(subShapes);
+        FillType = fillType;
+    }
+
     public EditableVectorPath(VectorPath path)
     {
         if (path != null)
@@ -47,8 +55,19 @@ public class EditableVectorPath
 
     public VectorPath ToVectorPath()
     {
-        VectorPath newPath = new VectorPath(Path);
-        newPath.Reset(); // preserve fill type and other properties
+        VectorPath newPath;
+        if (Path != null)
+        {
+            newPath = new VectorPath(Path);
+            newPath.Reset(); // preserve fill type and other properties
+        }
+        else
+        {
+            newPath = new VectorPath();
+        }
+        
+        newPath.FillType = FillType;
+
         foreach (var subShape in subShapes)
         {
             AddVerbToPath(CreateMoveToVerb(subShape), newPath);
@@ -127,7 +146,7 @@ public class EditableVectorPath
                     {
                         subShapes.Add(new SubShape(currentSubShapePoints, isSubShapeClosed));
                         currentSubShapePoints.Clear();
-                        
+
                         currentSubShapePoints.Add(new ShapePoint(data.points[0], 0, new Verb()));
                     }
                     else
@@ -143,6 +162,8 @@ public class EditableVectorPath
 
             globalVerbIndex++;
         }
+
+        FillType = from.FillType;
     }
 
     private void AddVerbToPath(Verb verb, VectorPath newPath)

src/PixiEditor/Views/Overlays/PathOverlay/ShapePoint.cs

@@ -78,6 +78,16 @@ public class Verb
         VerbType = null;
     }
     
+    public Verb(PathVerb verb, VecF from, VecF to, VecF? controlPoint1, VecF? controlPoint2, float conicWeight)
+    {
+        VerbType = verb;
+        From = from;
+        To = to;
+        ControlPoint1 = controlPoint1;
+        ControlPoint2 = controlPoint2;
+        ConicWeight = conicWeight;
+    }
+    
     public Verb((PathVerb verb, VecF[] points, float conicWeight) verbData)
     {
         VerbType = verbData.verb;