Adjust project structure

src/Shared/HandyControl_Shared/Expression/Media/ArcGeometrySource.cs

@@ -0,0 +1,470 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Media;
+using HandyControl.Expression.Drawing;
+
+namespace HandyControl.Expression.Media
+{
+    internal class ArcGeometrySource : GeometrySource<IArcGeometrySourceParameters>
+    {
+        private double _absoluteThickness;
+
+        private double _relativeThickness;
+
+        private static bool AreCloseEnough(double angleA, double angleB)
+        {
+            return Math.Abs(angleA - angleB) < 0.001;
+        }
+
+        internal static double[] ComputeAngleRanges(double radiusX, double radiusY, double intersect,
+            double start, double end)
+        {
+            var values = new List<double>
+            {
+                start,
+                end,
+                intersect,
+                180.0 - intersect,
+                180.0 + intersect,
+                360.0 - intersect,
+                360.0 + intersect,
+                540.0 - intersect,
+                540.0 + intersect,
+                720.0 - intersect
+            };
+            values.Sort();
+            var index = values.IndexOf(start);
+            var num2 = values.IndexOf(end);
+            if (num2 == index)
+            {
+                num2++;
+            }
+            else if (start < end)
+            {
+                IncreaseDuplicatedIndex(values, ref index);
+                DecreaseDuplicatedIndex(values, ref num2);
+            }
+            else if (start > end)
+            {
+                DecreaseDuplicatedIndex(values, ref index);
+                IncreaseDuplicatedIndex(values, ref num2);
+            }
+
+            var list = new List<double>();
+            if (index < num2)
+                for (var i = index; i <= num2; i++)
+                    list.Add(values[i]);
+            else
+                for (var j = index; j >= num2; j--)
+                    list.Add(values[j]);
+            var num5 = EnsureFirstQuadrant((list[0] + list[1]) / 2.0);
+            if (radiusX < radiusY && num5 < intersect || radiusX > radiusY && num5 > intersect)
+                list.RemoveAt(0);
+            if (list.Count % 2 == 1) list.RemoveLast();
+            if (list.Count == 0)
+            {
+                var num6 = Math.Min(index, num2) - 1;
+                if (num6 < 0) num6 = Math.Max(index, num2) + 1;
+                list.Add(values[num6]);
+                list.Add(values[num6]);
+            }
+
+            return list.ToArray();
+        }
+
+        protected override Rect ComputeLogicalBounds(Rect layoutBounds, IGeometrySourceParameters parameters)
+        {
+            return GeometryHelper.GetStretchBound(base.ComputeLogicalBounds(layoutBounds, parameters),
+                parameters.Stretch, new Size(1.0, 1.0));
+        }
+
+        private static IList<Point> ComputeOneInnerCurve(double start, double end, Rect bounds, double offset)
+        {
+            var num = bounds.Width / 2.0;
+            var num2 = bounds.Height / 2.0;
+            var point = bounds.Center();
+            start = start * 3.1415926535897931 / 180.0;
+            end = end * 3.1415926535897931 / 180.0;
+            var num3 = 0.17453292519943295;
+            var num4 = (int) Math.Ceiling(Math.Abs(end - start) / num3);
+            num4 = Math.Max(2, num4);
+            var list = new List<Point>(num4);
+            var list2 = new List<Vector>(num4);
+            var lhs = new Point();
+            var item = new Point();
+            var vector = new Vector();
+            var vector2 = new Vector();
+            var vector3 = new Vector();
+            var vector4 = new Vector();
+            for (var i = 0; i < num4; i++)
+            {
+                var a = MathHelper.Lerp(start, end, i / (double) (num4 - 1));
+                var num10 = Math.Sin(a);
+                var num11 = Math.Cos(a);
+                lhs.X = point.X + num * num10;
+                lhs.Y = point.Y - num2 * num11;
+                vector.X = num * num11;
+                vector.Y = num2 * num10;
+                vector2.X = -num2 * num10;
+                vector2.Y = num * num11;
+                var d = num2 * num2 * num10 * num10 + num * num * num11 * num11;
+                var num6 = Math.Sqrt(d);
+                var num7 = 2.0 * num10 * num11 * (num2 * num2 - num * num);
+                vector3.X = -num2 * num11;
+                vector3.Y = -num * num10;
+                item.X = lhs.X + offset * vector2.X / num6;
+                item.Y = lhs.Y + offset * vector2.Y / num6;
+                vector4.X = vector.X + offset / num6 * (vector3.X - 0.5 * vector2.X / d * num7);
+                vector4.Y = vector.Y + offset / num6 * (vector3.Y - 0.5 * vector2.Y / d * num7);
+                list.Add(item);
+                list2.Add(-vector4.Normalized());
+            }
+
+            var list3 = new List<Point>(num4 * 3 + 1)
+            {
+                list[0]
+            };
+            for (var j = 1; j < num4; j++)
+            {
+                lhs = list[j - 1];
+                item = list[j];
+                var num13 = GeometryHelper.Distance(lhs, item) / 3.0;
+                list3.Add(lhs + list2[j - 1] * num13);
+                list3.Add(item - list2[j] * num13);
+                list3.Add(item);
+            }
+
+            return list3;
+        }
+
+        private static void DecreaseDuplicatedIndex(IList<double> values, ref int index)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            while (index > 0 && values[index] == values[index - 1]) index--;
+        }
+
+        internal static double EnsureFirstQuadrant(double angle)
+        {
+            angle = Math.Abs(angle % 180.0);
+            if (angle <= 90.0) return angle;
+            return 180.0 - angle;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static Size GetArcSize(Rect bound)
+        {
+            return new Size(bound.Width / 2.0, bound.Height / 2.0);
+        }
+
+        private static void IncreaseDuplicatedIndex(IList<double> values, ref int index)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            while (index < values.Count - 1 && values[index] == values[index + 1]) index++;
+        }
+
+        internal static double InnerCurveSelfIntersect(double radiusX, double radiusY, double thickness)
+        {
+            var angleA = 0.0;
+            var angleB = 1.5707963267948966;
+            var flag = radiusX <= radiusY;
+            var vector = new Vector();
+            while (!AreCloseEnough(angleA, angleB))
+            {
+                var d = (angleA + angleB) / 2.0;
+                var num4 = Math.Cos(d);
+                var num5 = Math.Sin(d);
+                vector.X = radiusY * num5;
+                vector.Y = radiusX * num4;
+                vector.Normalize();
+                if (flag)
+                {
+                    var num6 = radiusX * num5 - vector.X * thickness;
+                    if (num6 > 0.0)
+                        angleB = d;
+                    else if (num6 < 0.0) angleA = d;
+                }
+                else
+                {
+                    var num7 = radiusY * num4 - vector.Y * thickness;
+                    if (num7 < 0.0)
+                        angleB = d;
+                    else if (num7 > 0.0) angleA = d;
+                }
+            }
+
+            var num8 = (angleA + angleB) / 2.0;
+            if (AreCloseEnough(num8, 0.0)) return 0.0;
+            if (!AreCloseEnough(num8, 1.5707963267948966)) return num8 * 180.0 / 3.1415926535897931;
+            return 90.0;
+        }
+
+        private static double NormalizeAngle(double degree)
+        {
+            if (degree < 0.0 || degree > 360.0)
+            {
+                degree = degree % 360.0;
+                if (degree < 0.0) degree += 360.0;
+            }
+
+            return degree;
+        }
+
+        private void NormalizeThickness(IArcGeometrySourceParameters parameters)
+        {
+            var num = LogicalBounds.Width / 2.0;
+            var num2 = LogicalBounds.Height / 2.0;
+            var rhs = Math.Min(num, num2);
+            var arcThickness = parameters.ArcThickness;
+            if (parameters.ArcThicknessUnit == UnitType.Pixel)
+                arcThickness = MathHelper.SafeDivide(arcThickness, rhs, 0.0);
+            _relativeThickness = MathHelper.EnsureRange(arcThickness, 0.0, 1.0);
+            _absoluteThickness = rhs * _relativeThickness;
+        }
+
+        private bool SyncPieceWiseInnerCurves(PathFigure figure, int index, ref Point firstPoint,
+            params double[] angles)
+        {
+            var flag = false;
+            var length = angles.Length;
+            var logicalBounds = LogicalBounds;
+            var absoluteThickness = _absoluteThickness;
+            flag |= figure.Segments.EnsureListCount(index + length / 2, () => new PolyBezierSegment());
+            for (var i = 0; i < length / 2; i++)
+            {
+                var points = ComputeOneInnerCurve(angles[i * 2], angles[i * 2 + 1], logicalBounds,
+                    absoluteThickness);
+                if (i == 0) firstPoint = points[0];
+                flag |= PathSegmentHelper.SyncPolyBezierSegment(figure.Segments, index + i, points, 1,
+                    points.Count - 1);
+            }
+
+            return flag;
+        }
+
+        [SuppressMessage("ReSharper", "ConditionIsAlwaysTrueOrFalse")]
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+        protected override bool UpdateCachedGeometry(IArcGeometrySourceParameters parameters)
+        {
+            var flag = false;
+            NormalizeThickness(parameters);
+            var relativeMode = parameters.ArcThicknessUnit == UnitType.Percent;
+            var flag3 = MathHelper.AreClose(parameters.StartAngle, parameters.EndAngle);
+            var angle = NormalizeAngle(parameters.StartAngle);
+            var end = NormalizeAngle(parameters.EndAngle);
+            if (end < angle) end += 360.0;
+            var isFilled = _relativeThickness == 1.0;
+            var flag5 = _relativeThickness == 0.0;
+            if (flag3) return flag | UpdateZeroAngleGeometry(relativeMode, angle);
+            if (MathHelper.IsVerySmall((end - angle) % 360.0))
+            {
+                if (flag5 || isFilled) return flag | UpdateEllipseGeometry(isFilled);
+                return flag | UpdateFullRingGeometry(relativeMode);
+            }
+
+            if (isFilled) return flag | UpdatePieGeometry(angle, end);
+            if (flag5) return flag | UpdateOpenArcGeometry(angle, end);
+            return flag | UpdateRingArcGeometry(relativeMode, angle, end);
+        }
+
+        private bool UpdateEllipseGeometry(bool isFilled)
+        {
+            var flag = false;
+            var y = MathHelper.Lerp(LogicalBounds.Top, LogicalBounds.Bottom, 0.5);
+            var point = new Point(LogicalBounds.Left, y);
+            var point2 = new Point(LogicalBounds.Right, y);
+            flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
+                () => new PathGeometry());
+            flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
+            var dependencyObject = geometry.Figures[0];
+            flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
+            flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, isFilled);
+            flag |= dependencyObject.Segments.EnsureListCount(2, () => new ArcSegment());
+            flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty, point);
+            flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
+                () => new ArcSegment());
+            flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
+                () => new ArcSegment());
+            var size = new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0);
+            flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
+            flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, size);
+            flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
+            flag |= segment.SetIfDifferent(ArcSegment.PointProperty, point2);
+            flag |= segment2.SetIfDifferent(ArcSegment.IsLargeArcProperty, false);
+            flag |= segment2.SetIfDifferent(ArcSegment.SizeProperty, size);
+            flag |= segment2.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
+            return flag | segment2.SetIfDifferent(ArcSegment.PointProperty, point);
+        }
+
+        private bool UpdateFullRingGeometry(bool relativeMode)
+        {
+            var flag = false;
+            flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
+                () => new PathGeometry());
+            flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.EvenOdd);
+            flag |= geometry.Figures.EnsureListCount(2, () => new PathFigure());
+            flag |= PathFigureHelper.SyncEllipseFigure(geometry.Figures[0], LogicalBounds,
+                SweepDirection.Clockwise);
+            var logicalBounds = LogicalBounds;
+            var num = logicalBounds.Width / 2.0;
+            var num2 = logicalBounds.Height / 2.0;
+            if (relativeMode || MathHelper.AreClose(num, num2))
+            {
+                var bounds = LogicalBounds.Resize(1.0 - _relativeThickness);
+                return flag | PathFigureHelper.SyncEllipseFigure(geometry.Figures[1], bounds,
+                           SweepDirection.Counterclockwise);
+            }
+
+            flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsClosedProperty, true);
+            flag |= geometry.Figures[1].SetIfDifferent(PathFigure.IsFilledProperty, true);
+            var firstPoint = new Point();
+            var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
+            var angles = ComputeAngleRanges(num, num2, intersect, 360.0, 0.0);
+            flag |= SyncPieceWiseInnerCurves(geometry.Figures[1], 0, ref firstPoint, angles);
+            return flag | geometry.Figures[1].SetIfDifferent(PathFigure.StartPointProperty, firstPoint);
+        }
+
+        private bool UpdateOpenArcGeometry(double start, double end)
+        {
+            PathFigure figure;
+            ArcSegment segment;
+            var flag = false;
+            var cachedGeometry = CachedGeometry as PathGeometry;
+            if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
+                (figure = cachedGeometry.Figures[0]).Segments.Count != 1 ||
+                (segment = figure.Segments[0] as ArcSegment) == null)
+            {
+                figure = new PathFigure();
+                CachedGeometry = new PathGeometry
+                {
+                    Figures = {figure}
+                };
+                figure.Segments.Add(segment = new ArcSegment());
+                figure.IsClosed = false;
+                segment.SweepDirection = SweepDirection.Clockwise;
+                flag = true;
+            }
+
+            flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
+                GeometryHelper.GetArcPoint(start, LogicalBounds));
+            flag |= figure.SetIfDifferent(PathFigure.IsFilledProperty, false);
+            flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
+                GeometryHelper.GetArcPoint(end, LogicalBounds));
+            flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
+            return flag | segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
+        }
+
+        private bool UpdatePieGeometry(double start, double end)
+        {
+            PathFigure figure;
+            ArcSegment segment;
+            LineSegment segment2;
+            var flag = false;
+            var cachedGeometry = CachedGeometry as PathGeometry;
+            if (cachedGeometry == null || cachedGeometry.Figures.Count != 1 ||
+                (figure = cachedGeometry.Figures[0]).Segments.Count != 2 ||
+                (segment = figure.Segments[0] as ArcSegment) == null ||
+                (segment2 = figure.Segments[1] as LineSegment) == null)
+            {
+                figure = new PathFigure();
+                CachedGeometry = new PathGeometry
+                {
+                    Figures = {figure}
+                };
+                figure.Segments.Add(segment = new ArcSegment());
+                figure.Segments.Add(segment2 = new LineSegment());
+                figure.IsClosed = true;
+                segment.SweepDirection = SweepDirection.Clockwise;
+                flag = true;
+            }
+
+            flag |= figure.SetIfDifferent(PathFigure.StartPointProperty,
+                GeometryHelper.GetArcPoint(start, LogicalBounds));
+            flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
+                GeometryHelper.GetArcPoint(end, LogicalBounds));
+            flag |= segment.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(LogicalBounds));
+            flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
+            return flag | segment2.SetIfDifferent(LineSegment.PointProperty, LogicalBounds.Center());
+        }
+
+        private bool UpdateRingArcGeometry(bool relativeMode, double start, double end)
+        {
+            var flag = false;
+            flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
+                () => new PathGeometry());
+            flag |= geometry.SetIfDifferent(PathGeometry.FillRuleProperty, FillRule.Nonzero);
+            flag |= geometry.Figures.EnsureListCount(1, () => new PathFigure());
+            var dependencyObject = geometry.Figures[0];
+            flag |= dependencyObject.SetIfDifferent(PathFigure.IsClosedProperty, true);
+            flag |= dependencyObject.SetIfDifferent(PathFigure.IsFilledProperty, true);
+            flag |= dependencyObject.SetIfDifferent(PathFigure.StartPointProperty,
+                GeometryHelper.GetArcPoint(start, LogicalBounds));
+            flag |= dependencyObject.Segments.EnsureListCountAtLeast(3, () => new ArcSegment());
+            flag |= GeometryHelper.EnsureSegmentType(out var segment, dependencyObject.Segments, 0,
+                () => new ArcSegment());
+            flag |= segment.SetIfDifferent(ArcSegment.PointProperty,
+                GeometryHelper.GetArcPoint(end, LogicalBounds));
+            flag |= segment.SetIfDifferent(ArcSegment.SizeProperty,
+                new Size(LogicalBounds.Width / 2.0, LogicalBounds.Height / 2.0));
+            flag |= segment.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
+            flag |= segment.SetIfDifferent(ArcSegment.SweepDirectionProperty, SweepDirection.Clockwise);
+            flag |= GeometryHelper.EnsureSegmentType(out var segment2, dependencyObject.Segments, 1,
+                () => new LineSegment());
+            var logicalBounds = LogicalBounds;
+            var num = logicalBounds.Width / 2.0;
+            var num2 = logicalBounds.Height / 2.0;
+            if (relativeMode || MathHelper.AreClose(num, num2))
+            {
+                var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
+                flag |= segment2.SetIfDifferent(LineSegment.PointProperty,
+                    GeometryHelper.GetArcPoint(end, bound));
+                flag |= dependencyObject.Segments.EnsureListCount(3, () => new ArcSegment());
+                flag |= GeometryHelper.EnsureSegmentType(out var segment3, dependencyObject.Segments, 2,
+                    () => new ArcSegment());
+                flag |= segment3.SetIfDifferent(ArcSegment.PointProperty,
+                    GeometryHelper.GetArcPoint(start, bound));
+                flag |= segment3.SetIfDifferent(ArcSegment.SizeProperty, GetArcSize(bound));
+                flag |= segment3.SetIfDifferent(ArcSegment.IsLargeArcProperty, end - start > 180.0);
+                return flag | segment3.SetIfDifferent(ArcSegment.SweepDirectionProperty,
+                           SweepDirection.Counterclockwise);
+            }
+
+            var firstPoint = new Point();
+            var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
+            var angles = ComputeAngleRanges(num, num2, intersect, end, start);
+            flag |= SyncPieceWiseInnerCurves(dependencyObject, 2, ref firstPoint, angles);
+            return flag | segment2.SetIfDifferent(LineSegment.PointProperty, firstPoint);
+        }
+
+        private bool UpdateZeroAngleGeometry(bool relativeMode, double angle)
+        {
+            Point point2;
+            var flag = false;
+            var arcPoint = GeometryHelper.GetArcPoint(angle, LogicalBounds);
+            var logicalBounds = LogicalBounds;
+            var num = logicalBounds.Width / 2.0;
+            var num2 = logicalBounds.Height / 2.0;
+            if (relativeMode || MathHelper.AreClose(num, num2))
+            {
+                var bound = LogicalBounds.Resize(1.0 - _relativeThickness);
+                point2 = GeometryHelper.GetArcPoint(angle, bound);
+            }
+            else
+            {
+                var intersect = InnerCurveSelfIntersect(num, num2, _absoluteThickness);
+                var numArray = ComputeAngleRanges(num, num2, intersect, angle, angle);
+                var a = numArray[0] * 3.1415926535897931 / 180.0;
+                var vector = new Vector(num2 * Math.Sin(a), -num * Math.Cos(a));
+                point2 = GeometryHelper.GetArcPoint(numArray[0], LogicalBounds) -
+                         vector.Normalized() * _absoluteThickness;
+            }
+
+            flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
+                () => new LineGeometry());
+            flag |= geometry.SetIfDifferent(LineGeometry.StartPointProperty, arcPoint);
+            return flag | geometry.SetIfDifferent(LineGeometry.EndPointProperty, point2);
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/DrawingPropertyChangedEventArgs.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace HandyControl.Expression.Media
+{
+    internal class DrawingPropertyChangedEventArgs : EventArgs
+    {
+        public bool IsAnimated { get; set; }
+
+        public DrawingPropertyMetadata Metadata { get; set; }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/DrawingPropertyMetadata.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Windows;
+
+namespace HandyControl.Expression.Media
+{
+    internal class DrawingPropertyMetadata : FrameworkPropertyMetadata
+    {
+#pragma warning disable 414
+        private DrawingPropertyMetadataOptions options;
+#pragma warning restore 414
+
+        private PropertyChangedCallback propertyChangedCallback;
+
+        public static event EventHandler<DrawingPropertyChangedEventArgs> DrawingPropertyChanged;
+
+        static DrawingPropertyMetadata()
+        {
+            DrawingPropertyChanged += delegate (object sender, DrawingPropertyChangedEventArgs args) {
+                if ((sender is IShape shape) && args.Metadata.AffectsRender)
+                {
+                    InvalidateGeometryReasons reasons = InvalidateGeometryReasons.PropertyChanged;
+                    if (args.IsAnimated)
+                    {
+                        reasons |= InvalidateGeometryReasons.IsAnimated;
+                    }
+                    shape.InvalidateGeometry(reasons);
+                }
+            };
+        }
+
+        public DrawingPropertyMetadata(object defaultValue) : this(defaultValue, DrawingPropertyMetadataOptions.None, null)
+        {
+        }
+
+        public DrawingPropertyMetadata(PropertyChangedCallback propertyChangedCallback) : this(DependencyProperty.UnsetValue, DrawingPropertyMetadataOptions.None, propertyChangedCallback)
+        {
+        }
+
+        private DrawingPropertyMetadata(DrawingPropertyMetadataOptions options, object defaultValue) : base(defaultValue, (FrameworkPropertyMetadataOptions)options)
+        {
+        }
+
+        public DrawingPropertyMetadata(object defaultValue, DrawingPropertyMetadataOptions options) : this(defaultValue, options, null)
+        {
+        }
+
+        public DrawingPropertyMetadata(object defaultValue, DrawingPropertyMetadataOptions options, PropertyChangedCallback propertyChangedCallback) : base(defaultValue, (FrameworkPropertyMetadataOptions)options, AttachCallback(defaultValue, options, propertyChangedCallback))
+        {
+        }
+
+        private static PropertyChangedCallback AttachCallback(object defaultValue, DrawingPropertyMetadataOptions options, PropertyChangedCallback propertyChangedCallback)
+        {
+            DrawingPropertyMetadata metadata = new DrawingPropertyMetadata(options, defaultValue)
+            {
+                options = options,
+                propertyChangedCallback = propertyChangedCallback
+            };
+            return metadata.InternalCallback;
+        }
+
+        private void InternalCallback(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
+            if (DrawingPropertyChanged != null)
+            {
+                DrawingPropertyChangedEventArgs args = new DrawingPropertyChangedEventArgs
+                {
+                    Metadata = this,
+                    IsAnimated = DependencyPropertyHelper.GetValueSource(sender, e.Property).IsAnimated
+                };
+                DrawingPropertyChanged(sender, args);
+            }
+
+            propertyChangedCallback?.Invoke(sender, e);
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/DrawingPropertyMetadataOptions.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace HandyControl.Expression.Media
+{
+    [Flags]
+    internal enum DrawingPropertyMetadataOptions
+    {
+        AffectsMeasure = 1,
+        AffectsRender = 0x10,
+        None = 0
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/GeometryEffect.cs

@@ -0,0 +1,172 @@
+using System;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace HandyControl.Expression.Media
+{
+    [TypeConverter(typeof(GeometryEffectConverter))]
+    public abstract class GeometryEffect : Freezable
+    {
+        // ReSharper disable once InconsistentNaming
+        private static GeometryEffect defaultGeometryEffect;
+
+        public static readonly DependencyProperty GeometryEffectProperty =
+            DependencyProperty.RegisterAttached("GeometryEffect", typeof(GeometryEffect),
+                typeof(GeometryEffect),
+                new DrawingPropertyMetadata(DefaultGeometryEffect,
+                    DrawingPropertyMetadataOptions.AffectsRender, OnGeometryEffectChanged));
+
+        protected Geometry CachedGeometry;
+
+        private bool _effectInvalidated;
+
+        static GeometryEffect()
+        {
+            DrawingPropertyMetadata.DrawingPropertyChanged +=
+                delegate(object sender, DrawingPropertyChangedEventArgs args)
+                {
+                    if (sender is GeometryEffect effect && args.Metadata.AffectsRender)
+                        effect.InvalidateGeometry(InvalidateGeometryReasons.PropertyChanged);
+                };
+        }
+
+        public static GeometryEffect DefaultGeometryEffect =>
+            defaultGeometryEffect ?? (defaultGeometryEffect = new NoGeometryEffect());
+
+        public Geometry OutputGeometry =>
+            CachedGeometry;
+
+        protected internal DependencyObject Parent { get; private set; }
+
+        protected internal virtual void Attach(DependencyObject obj)
+        {
+            if (Parent != null) Detach();
+            _effectInvalidated = true;
+            CachedGeometry = null;
+            if (InvalidateParent(obj)) Parent = obj;
+        }
+
+        public new GeometryEffect CloneCurrentValue()
+        {
+            return (GeometryEffect) base.CloneCurrentValue();
+        }
+
+        protected override Freezable CreateInstanceCore()
+        {
+            return (Freezable) Activator.CreateInstance(GetType());
+        }
+
+        protected abstract GeometryEffect DeepCopy();
+
+        protected internal virtual void Detach()
+        {
+            _effectInvalidated = true;
+            CachedGeometry = null;
+            if (Parent != null)
+            {
+                InvalidateParent(Parent);
+                Parent = null;
+            }
+        }
+
+        public abstract bool Equals(GeometryEffect geometryEffect);
+
+        public static GeometryEffect GetGeometryEffect(DependencyObject obj)
+        {
+            return (GeometryEffect) obj.GetValue(GeometryEffectProperty);
+        }
+
+        public bool InvalidateGeometry(InvalidateGeometryReasons reasons)
+        {
+            if (_effectInvalidated) return false;
+            _effectInvalidated = true;
+            if (reasons != InvalidateGeometryReasons.ParentInvalidated) InvalidateParent(Parent);
+            return true;
+        }
+
+        private static bool InvalidateParent(DependencyObject parent)
+        {
+            if (parent is IShape shape)
+            {
+                shape.InvalidateGeometry(InvalidateGeometryReasons.ChildInvalidated);
+                return true;
+            }
+
+            if (parent is GeometryEffect effect)
+            {
+                effect.InvalidateGeometry(InvalidateGeometryReasons.ChildInvalidated);
+                return true;
+            }
+
+            return false;
+        }
+
+        private static void OnGeometryEffectChanged(DependencyObject obj,
+            DependencyPropertyChangedEventArgs e)
+        {
+            var oldValue = e.OldValue as GeometryEffect;
+            var newValue = e.NewValue as GeometryEffect;
+            if (!Equals(oldValue, newValue))
+            {
+                if (oldValue != null && obj.Equals(oldValue.Parent)) oldValue.Detach();
+                if (newValue != null)
+                {
+                    if (newValue.Parent != null)
+                    {
+                        obj.Dispatcher.BeginInvoke(new Action(() =>
+                        {
+                            var effect = newValue.CloneCurrentValue();
+                            obj.SetValue(GeometryEffectProperty, effect);
+                        }), DispatcherPriority.Send, null);
+                    }
+                    else
+                    {
+                        newValue.Attach(obj);
+                    }
+                }
+            }
+        }
+
+        public bool ProcessGeometry(Geometry input)
+        {
+            var flag = false;
+            if (_effectInvalidated)
+            {
+                flag |= UpdateCachedGeometry(input);
+                _effectInvalidated = false;
+            }
+
+            return flag;
+        }
+
+        public static void SetGeometryEffect(DependencyObject obj, GeometryEffect value)
+        {
+            obj.SetValue(GeometryEffectProperty, value);
+        }
+
+        protected abstract bool UpdateCachedGeometry(Geometry input);
+
+
+        private class NoGeometryEffect : GeometryEffect
+        {
+            protected override GeometryEffect DeepCopy()
+            {
+                return new NoGeometryEffect();
+            }
+
+            public override bool Equals(GeometryEffect geometryEffect)
+            {
+                if (geometryEffect != null) return geometryEffect is NoGeometryEffect;
+                return true;
+            }
+
+            protected override bool UpdateCachedGeometry(Geometry input)
+            {
+                CachedGeometry = input;
+                return false;
+            }
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/GeometryEffectConverter.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace HandyControl.Expression.Media
+{
+    public sealed class GeometryEffectConverter : TypeConverter
+    {
+        private static readonly Dictionary<string, GeometryEffect> RegisteredEffects;
+
+        static GeometryEffectConverter()
+        {
+            var dictionary = new Dictionary<string, GeometryEffect>
+            {
+                {
+                    "None",
+                    GeometryEffect.DefaultGeometryEffect
+                },
+                {
+                    "Sketch",
+                    new SketchGeometryEffect()
+                }
+            };
+            RegisteredEffects = dictionary;
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return typeof(string).IsAssignableFrom(sourceType);
+        }
+
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return typeof(string).IsAssignableFrom(destinationType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value is string key && RegisteredEffects.TryGetValue(key, out var effect))
+                return effect.CloneCurrentValue();
+            return null;
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value,
+            Type destinationType)
+        {
+            if (typeof(string).IsAssignableFrom(destinationType))
+            {
+                if (value is string) return value;
+                foreach (var pair in RegisteredEffects)
+                    if (pair.Value?.Equals(value as GeometryEffect) ?? value == null)
+                        return pair.Key;
+            }
+
+            return null;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/GeometrySource!1.cs

@@ -0,0 +1,88 @@
+using System.Windows;
+using System.Windows.Media;
+using HandyControl.Expression.Drawing;
+
+namespace HandyControl.Expression.Media
+{
+    public abstract class GeometrySource<TParameters> : IGeometrySource
+        where TParameters : IGeometrySourceParameters
+    {
+        private bool _geometryInvalidated;
+
+        protected Geometry CachedGeometry;
+
+        public bool InvalidateGeometry(InvalidateGeometryReasons reasons)
+        {
+            if ((reasons & InvalidateGeometryReasons.TemplateChanged) != 0) CachedGeometry = null;
+            if (!_geometryInvalidated)
+            {
+                _geometryInvalidated = true;
+                return true;
+            }
+
+            return false;
+        }
+
+        public bool UpdateGeometry(IGeometrySourceParameters parameters, Rect layoutBounds)
+        {
+            var force = false;
+            if (parameters is TParameters parameters1)
+            {
+                var rect = ComputeLogicalBounds(layoutBounds, parameters1);
+                force |= LayoutBounds != layoutBounds || LogicalBounds != rect;
+                if (_geometryInvalidated || force)
+                {
+                    LayoutBounds = layoutBounds;
+                    LogicalBounds = rect;
+                    force |= UpdateCachedGeometry(parameters1);
+                    force |= ApplyGeometryEffect(parameters1, force);
+                }
+            }
+
+            _geometryInvalidated = false;
+            return force;
+        }
+
+        public Geometry Geometry { get; private set; }
+
+        public Rect LayoutBounds { get; private set; }
+
+        public Rect LogicalBounds { get; private set; }
+
+        private bool ApplyGeometryEffect(IGeometrySourceParameters parameters, bool force)
+        {
+            var flag = false;
+            var cachedGeometry = CachedGeometry;
+            var geometryEffect = parameters.GetGeometryEffect();
+            if (geometryEffect != null)
+            {
+                if (force)
+                {
+                    flag = true;
+                    geometryEffect.InvalidateGeometry(InvalidateGeometryReasons.ParentInvalidated);
+                }
+
+                if (geometryEffect.ProcessGeometry(CachedGeometry))
+                {
+                    flag = true;
+                    cachedGeometry = geometryEffect.OutputGeometry;
+                }
+            }
+
+            if (!Equals(Geometry, cachedGeometry))
+            {
+                flag = true;
+                Geometry = cachedGeometry;
+            }
+
+            return flag;
+        }
+
+        protected virtual Rect ComputeLogicalBounds(Rect layoutBounds, IGeometrySourceParameters parameters)
+        {
+            return GeometryHelper.Inflate(layoutBounds, -parameters.GetHalfStrokeThickness());
+        }
+
+        protected abstract bool UpdateCachedGeometry(TParameters parameters);
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/IArcGeometrySourceParameters.cs

@@ -0,0 +1,13 @@
+namespace HandyControl.Expression.Media
+{
+    public interface IArcGeometrySourceParameters : IGeometrySourceParameters
+    {
+        double ArcThickness { get; }
+
+        UnitType ArcThicknessUnit { get; }
+
+        double EndAngle { get; }
+
+        double StartAngle { get; }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/IGeometrySource.cs

@@ -0,0 +1,17 @@
+using System.Windows;
+
+namespace HandyControl.Expression.Media
+{
+    public interface IGeometrySource
+    {
+        bool InvalidateGeometry(InvalidateGeometryReasons reasons);
+
+        bool UpdateGeometry(IGeometrySourceParameters parameters, Rect layoutBounds);
+
+        System.Windows.Media.Geometry Geometry { get; }
+
+        Rect LayoutBounds { get; }
+
+        Rect LogicalBounds { get; }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/IGeometrySourceExtensions.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Windows;
+
+namespace HandyControl.Expression.Media
+{
+    internal static class GeometrySourceExtensions
+    {
+        public static GeometryEffect GetGeometryEffect(this IGeometrySourceParameters parameters)
+        {
+            if (parameters is DependencyObject obj2)
+            {
+                var geometryEffect = GeometryEffect.GetGeometryEffect(obj2);
+                if (geometryEffect != null && obj2.Equals(geometryEffect.Parent)) return geometryEffect;
+            }
+
+            return null;
+        }
+
+        public static double GetHalfStrokeThickness(this IGeometrySourceParameters parameter)
+        {
+            if (parameter.Stroke != null)
+            {
+                var strokeThickness = parameter.StrokeThickness;
+                if (!double.IsNaN(strokeThickness) && !double.IsInfinity(strokeThickness))
+                    return Math.Abs(strokeThickness) / 2.0;
+            }
+
+            return 0.0;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/IGeometrySourceParameters.cs

@@ -0,0 +1,13 @@
+using System.Windows.Media;
+
+namespace HandyControl.Expression.Media
+{
+    public interface IGeometrySourceParameters
+    {
+        Stretch Stretch { get; }
+
+        Brush Stroke { get; }
+
+        double StrokeThickness { get; }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/IShape.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Windows;
+using System.Windows.Media;
+
+namespace HandyControl.Expression.Media
+{
+    public interface IShape
+    {
+        event EventHandler RenderedGeometryChanged;
+
+        void InvalidateGeometry(InvalidateGeometryReasons reasons);
+
+        Brush Fill { get; set; }
+
+        Thickness GeometryMargin { get; }
+
+        Geometry RenderedGeometry { get; }
+
+        Stretch Stretch { get; set; }
+
+        Brush Stroke { get; set; }
+
+        double StrokeThickness { get; set; }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/InvalidateGeometryReasons.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace HandyControl.Expression.Media
+{
+    [Flags]
+    public enum InvalidateGeometryReasons
+    {
+        ChildInvalidated = 4,
+        IsAnimated = 2,
+        ParentInvalidated = 8,
+        PropertyChanged = 1,
+        TemplateChanged = 0x10
+    }
+}

src/Shared/HandyControl_Shared/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;
+        }
+    }
+}

src/Shared/HandyControl_Shared/Expression/Media/UnitType.cs

@@ -0,0 +1,8 @@
+namespace HandyControl.Expression.Media
+{
+    public enum UnitType
+    {
+        Pixel,
+        Percent
+    }
+}