support for .NET framework 3.5

Still have bugs

Net35/HandyControl_Net35/Expression/Media/SketchGeometryEffect.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using HandyControl.Expression.Drawing;
+
+namespace HandyControl.Expression.Media
+{
+    public sealed class SketchGeometryEffect : GeometryEffect
+    {
+        private readonly long _randomSeed = DateTime.Now.Ticks;
+
+        protected override GeometryEffect DeepCopy()
+        {
+            return new SketchGeometryEffect();
+        }
+
+        private static void DisturbPoints(RandomEngine random, double scale, IList<Point> points,
+            IList<Vector> normals)
+        {
+            var count = points.Count;
+            for (var i = 1; i < count; i++)
+            {
+                var num3 = random.NextGaussian(0.0, 1.0 * scale);
+                var num4 = random.NextUniform(-0.5, 0.5) * scale;
+                var point = points[i];
+                var vector = normals[i];
+                var vector2 = normals[i];
+                var point2 = points[i];
+                var vector3 = normals[i];
+                var vector4 = normals[i];
+                points[i] = new Point(point.X + vector.X * num4 - vector2.Y * num3,
+                    point2.Y + vector3.X * num3 + vector4.Y * num4);
+            }
+        }
+
+        public override bool Equals(GeometryEffect geometryEffect)
+        {
+            return geometryEffect is SketchGeometryEffect;
+        }
+
+        private IEnumerable<SimpleSegment> GetEffectiveSegments(PathFigure pathFigure)
+        {
+            var startPoint = pathFigure.StartPoint;
+            foreach (var iteratorVariable1 in pathFigure.AllSegments())
+            foreach (var iteratorVariable2 in iteratorVariable1.PathSegment.GetSimpleSegments(
+                iteratorVariable1.StartPoint))
+            {
+                yield return iteratorVariable2;
+                startPoint = iteratorVariable2.Points.Last();
+            }
+
+            if (pathFigure.IsClosed) yield return SimpleSegment.Create(startPoint, pathFigure.StartPoint);
+        }
+
+        [SuppressMessage("ReSharper", "ConditionIsAlwaysTrueOrFalse")]
+        protected override bool UpdateCachedGeometry(Geometry input)
+        {
+            var flag = false;
+            var inputPath = input.AsPathGeometry();
+            if (inputPath != null) return flag | UpdateSketchGeometry(inputPath);
+            CachedGeometry = input;
+            return flag;
+        }
+
+        private bool UpdateSketchGeometry(PathGeometry inputPath)
+        {
+            var flag = false;
+            flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
+                () => new PathGeometry());
+            flag |= geometry.Figures.EnsureListCount(inputPath.Figures.Count, () => new PathFigure());
+            var random = new RandomEngine(_randomSeed);
+            for (var i = 0; i < inputPath.Figures.Count; i++)
+            {
+                var pathFigure = inputPath.Figures[i];
+                var isClosed = pathFigure.IsClosed;
+                var isFilled = pathFigure.IsFilled;
+                if (pathFigure.Segments.Count == 0)
+                {
+                    flag |= geometry.Figures[i]
+                        .SetIfDifferent(PathFigure.StartPointProperty, pathFigure.StartPoint);
+                    flag |= geometry.Figures[i].Segments.EnsureListCount(0);
+                }
+                else
+                {
+                    var list = new List<Point>(pathFigure.Segments.Count * 3);
+                    foreach (var segment in GetEffectiveSegments(pathFigure))
+                    {
+                        var resultPolyline = new List<Point>
+                        {
+                            segment.Points[0]
+                        };
+                        segment.Flatten(resultPolyline, 0.0, null);
+                        var polyline = new PolylineData(resultPolyline);
+                        if (resultPolyline.Count > 1 && polyline.TotalLength > 4.0)
+                        {
+                            var a = polyline.TotalLength / 8.0;
+                            var sampleCount = (int) Math.Max(2.0, Math.Ceiling(a));
+                            var interval = polyline.TotalLength / sampleCount;
+                            var scale = interval / 8.0;
+                            var samplePoints = new List<Point>(sampleCount);
+                            var sampleNormals = new List<Vector>(sampleCount);
+                            var sampleIndex = 0;
+                            PolylineHelper.PathMarch(polyline, 0.0, 0.0, delegate(MarchLocation location)
+                            {
+                                if (location.Reason == MarchStopReason.CompletePolyline) return double.NaN;
+                                if (location.Reason != MarchStopReason.CompleteStep) return location.Remain;
+                                if (sampleIndex++ == sampleCount) return double.NaN;
+                                samplePoints.Add(location.GetPoint(polyline.Points));
+                                sampleNormals.Add(location.GetNormal(polyline));
+                                return interval;
+                            });
+                            DisturbPoints(random, scale, samplePoints, sampleNormals);
+                            list.AddRange(samplePoints);
+                        }
+                        else
+                        {
+                            list.AddRange(resultPolyline);
+                            list.RemoveLast();
+                        }
+                    }
+
+                    if (!isClosed) list.Add(pathFigure.Segments.Last().GetLastPoint());
+                    flag |= PathFigureHelper.SyncPolylineFigure(geometry.Figures[i], list, isClosed,
+                        isFilled);
+                }
+            }
+
+            if (flag) CachedGeometry = PathGeometryHelper.FixPathGeometryBoundary(CachedGeometry);
+            return flag;
+        }
+    }
+}