// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

//#define DEBUG_RENDERING_FEEDBACK

using MS.Utility;
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using MS.Internal;
using MS.Internal.Ink;

using SR=MS.Internal.PresentationCore.SR;
using MS.Internal.PresentationCore;

// Primary root namespace for TabletPC/Ink/Handwriting/Recognition in .NET

namespace System.Windows.Ink
{
    /// <summary>
    /// The hit-testing API of Stroke
    /// </summary>
    public partial class Stroke : INotifyPropertyChanged
    {
        #region Public APIs

        #region Public Methods

        /// <summary>
        /// Computes the bounds of the stroke in the default rendering context
        /// </summary>
        /// <returns></returns>
        public virtual Rect GetBounds()
        {
            if (_cachedBounds.IsEmpty)
            {
                StrokeNodeIterator iterator = StrokeNodeIterator.GetIterator(this, this.DrawingAttributes);
                for (int i = 0; i < iterator.Count; i++)
                {
                    StrokeNode strokeNode = iterator[i];
                    _cachedBounds.Union(strokeNode.GetBounds());
                }
            }

            return _cachedBounds;
        }

        /// <summary>
        /// Render the Stroke under the specified DrawingContext. The draw method is a
        /// batch operationg that uses the rendering methods exposed off of DrawingContext
        /// </summary>
        /// <param name="context"></param>
        public void Draw(DrawingContext context)
        {
            ArgumentNullException.ThrowIfNull(context);

            //our code never calls this public API so we can assume that opacity
            //has not been set up

            //call our public Draw method with the strokes.DA
            this.Draw(context, this.DrawingAttributes);
        }


        /// <summary>
        /// Render the StrokeCollection under the specified DrawingContext. This draw method uses the
        /// passing in drawing attribute to override that on the stroke.
        /// </summary>
        /// <param name="drawingContext"></param>
        /// <param name="drawingAttributes"></param>
        public void Draw(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            ArgumentNullException.ThrowIfNull(drawingContext);

            ArgumentNullException.ThrowIfNull(drawingAttributes);

            //             context.VerifyAccess();

            //our code never calls this public API so we can assume that opacity
            //has not been set up

            if (drawingAttributes.IsHighlighter)
            {
                drawingContext.PushOpacity(StrokeRenderer.HighlighterOpacity);
                try
                {
                    this.DrawInternal(drawingContext, StrokeRenderer.GetHighlighterAttributes(this, this.DrawingAttributes), false);
                }
                finally
                {
                    drawingContext.Pop();
                }
            }
            else
            {
                this.DrawInternal(drawingContext, drawingAttributes, false);
            }
        }


        /// <summary>
        /// Clip with rect. Calculate the after-clipping Strokes. Only the "in-segments" are left after this operation.
        /// </summary>
        /// <param name="bounds">A Rect to clip with</param>
        /// <returns>The after-clipping strokes.</returns>
        public StrokeCollection GetClipResult(Rect bounds)
        {
            return this.GetClipResult(new Point[4] { bounds.TopLeft, bounds.TopRight, bounds.BottomRight, bounds.BottomLeft });
        }


        /// <summary>
        /// Clip with lasso. Calculate the after-clipping Strokes. Only the "in-segments" are left after this operation.
        /// </summary>
        /// <param name="lassoPoints">The lasso points to clip with</param>
        /// <returns>The after-clipping strokes</returns>
        public StrokeCollection GetClipResult(IEnumerable<Point> lassoPoints)
        {
            // Check the input parameters
            ArgumentNullException.ThrowIfNull(lassoPoints);

            if (IEnumerablePointHelper.GetCount(lassoPoints) == 0)
            {
                throw new ArgumentException(SR.EmptyArray);
            }

            Lasso lasso = new SingleLoopLasso();
            lasso.AddPoints(lassoPoints);
            return this.Clip(this.HitTest(lasso));
        }


        /// <summary>
        /// Erase with a rect. Calculate the after-erasing Strokes. Only the "out-segments" are left after this operation.
        /// </summary>
        /// <param name="bounds">A Rect to clip with</param>
        /// <returns>The after-erasing strokes</returns>
        public StrokeCollection GetEraseResult(Rect bounds)
        {
            return this.GetEraseResult(new Point[4] { bounds.TopLeft, bounds.TopRight, bounds.BottomRight, bounds.BottomLeft });
        }

        /// <summary>
        /// Erase with lasso points.
        /// </summary>
        /// <param name="lassoPoints">Lasso points to erase with</param>
        /// <returns>The after-erasing strokes</returns>
        public StrokeCollection GetEraseResult(IEnumerable<Point> lassoPoints)
        {
            // Check the input parameters
            ArgumentNullException.ThrowIfNull(lassoPoints);

            if (IEnumerablePointHelper.GetCount(lassoPoints) == 0)
            {
                throw new ArgumentException(SR.EmptyArray);
            }

            Lasso lasso = new SingleLoopLasso();
            lasso.AddPoints(lassoPoints);
            return this.Erase(this.HitTest(lasso));
        }

        /// <summary>
        /// Erase with an eraser with passed in shape
        /// </summary>
        /// <param name="eraserPath">The path to erase</param>
        /// <param name="eraserShape">Shape of the eraser</param>
        /// <returns></returns>
        public StrokeCollection GetEraseResult(IEnumerable<Point> eraserPath, StylusShape eraserShape)
        {
            // Check the input parameters
            ArgumentNullException.ThrowIfNull(eraserShape);
            ArgumentNullException.ThrowIfNull(eraserPath);

            return this.Erase(this.EraseTest(eraserPath, eraserShape));
        }


        /// <summary>
        /// Tap-hit. Hit tests with a point. Internally does Stroke.HitTest(Point, 1pxlRectShape).
        /// </summary>
        /// <param name="point">The location to do the hitest</param>
        /// <returns>True is this stroke is hit, false otherwise</returns>
        public bool HitTest(Point point)
        {
            return HitTest(new Point[]{point}, new EllipseStylusShape(TapHitPointSize, TapHitPointSize, TapHitRotation));
        }

        /// <summary>
        /// Tap-hit. Hit tests with a point.
        /// </summary>
        /// <param name="point">The location to do the hittest</param>
        /// <param name="diameter">diameter of the tip</param>
        /// <returns>true if hit, false otherwise</returns>
        public bool HitTest(Point point, double diameter)
        {
            if (Double.IsNaN(diameter) || diameter < DrawingAttributes.MinWidth || diameter > DrawingAttributes.MaxWidth)
            {
                throw new ArgumentOutOfRangeException("diameter", SR.InvalidDiameter);
            }
            return HitTest(new Point[]{point}, new EllipseStylusShape(diameter, diameter, TapHitRotation));
        }

        /// <summary>
        /// Check whether a certain percentage of the stroke is within the Rect passed in.
        /// </summary>
        /// <param name="bounds"></param>
        /// <param name="percentageWithinBounds"></param>
        /// <returns></returns>
        public bool HitTest(Rect bounds, int percentageWithinBounds)
        {
            if ((percentageWithinBounds < 0) || (percentageWithinBounds > 100))
            {
                throw new System.ArgumentOutOfRangeException("percentageWithinBounds");
            }

            if (percentageWithinBounds == 0)
            {
                return true;
            }

            StrokeInfo strokeInfo = null;
            try
            {
                strokeInfo = new StrokeInfo(this);

                StylusPointCollection stylusPoints = strokeInfo.StylusPoints;
                double target = strokeInfo.TotalWeight * percentageWithinBounds / 100.0f - PercentageTolerance;

                for (int i = 0; i < stylusPoints.Count; i++)
                {
                    if (true == bounds.Contains((Point)stylusPoints[i]))
                    {
                        target -= strokeInfo.GetPointWeight(i);
                        if (DoubleUtil.LessThanOrClose(target, 0d))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            finally
            {
                if (strokeInfo != null)
                {
                    //detach from event handlers, or else we leak.
                    strokeInfo.Detach();
                }
            }
        }

        /// <summary>
        /// Check whether a certain percentage of the stroke is within the lasso
        /// </summary>
        /// <param name="lassoPoints"></param>
        /// <param name="percentageWithinLasso"></param>
        /// <returns></returns>
        public bool HitTest(IEnumerable<Point> lassoPoints, int percentageWithinLasso)
        {
            ArgumentNullException.ThrowIfNull(lassoPoints);

            if ((percentageWithinLasso < 0) || (percentageWithinLasso > 100))
            {
                throw new System.ArgumentOutOfRangeException("percentageWithinLasso");
            }

            if (percentageWithinLasso == 0)
            {
                return true;
            }


            StrokeInfo strokeInfo = null;
            try
            {
                strokeInfo = new StrokeInfo(this);

                StylusPointCollection stylusPoints = strokeInfo.StylusPoints;
                double target = strokeInfo.TotalWeight * percentageWithinLasso / 100.0f - PercentageTolerance;

                Lasso lasso = new SingleLoopLasso();
                lasso.AddPoints(lassoPoints);

                for (int i = 0; i < stylusPoints.Count; i++)
                {
                    if (true == lasso.Contains((Point)stylusPoints[i]))
                    {
                        target -= strokeInfo.GetPointWeight(i);
                        if (DoubleUtil.LessThan(target, 0f))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            finally
            {
                if (strokeInfo != null)
                {
                    //detach from event handlers, or else we leak.
                    strokeInfo.Detach();
                }
            }
}

        /// <summary>
        ///
        /// </summary>
        /// <param name="path"></param>
        /// <param name="stylusShape"></param>
        /// <returns></returns>
        public bool HitTest(IEnumerable<Point> path, StylusShape stylusShape)
        {
            // Check the input parameters
            ArgumentNullException.ThrowIfNull(path);
            ArgumentNullException.ThrowIfNull(stylusShape);

            if (IEnumerablePointHelper.GetCount(path) == 0)
            {
                return false;
            }

            ErasingStroke erasingStroke = new ErasingStroke(stylusShape);
            erasingStroke.MoveTo(path);

            Rect erasingBounds = erasingStroke.Bounds;

            if (erasingBounds.IsEmpty)
            {
                return false;
            }

            if (erasingBounds.IntersectsWith(this.GetBounds()))
            {
                return erasingStroke.HitTest(StrokeNodeIterator.GetIterator(this, this.DrawingAttributes));
            }

            return false;
        }

        #endregion

        #endregion

        #region Protected APIs

        /// <summary>
        /// The core functionality to draw a stroke. The function can be called from the following code paths.
        ///     i) From StrokeVisual.OnRender
        ///         a. Highlighter strokes have been grouped and the correct opacity has been set on the container visual.
        ///         b. For a highlighter stroke with color.A != 255, the DA passed in is a copy with color.A set to 255.
        ///         c. _drawAsHollow can be true, i.e., Selected stroke is drawn as hollow
        ///     ii) From StrokeCollection.Draw.
        ///         a. Highlighter strokes have been grouped and the correct opacity has been pushed.
        ///         b. For a highlighter stroke with color.A != 255, the DA passed in is a copy with color.A set to 255.
        ///         c. _drawAsHollow is always false, i.e., Selected stroke is not drawn as hollow
        ///     iii) From Stroke.Draw
        ///         a. The correct opacity has been pushed for a highlighter stroke
        ///         b. For a highlighter stroke with color.A != 255, the DA passed in is a copy with color.A set to 255.
        ///         c. _drawAsHollow is always false, i.e., Selected stroke is not drawn as hollow
        /// We need to document the following:
        /// 1) our default implementation so developers can see what we've done here -
        ///    including how we handle IsHollow
        /// 2) the fact that opacity has already been set up correctly for the call.
        /// 3) that developers should not call base.DrawCore if they override this
        /// </summary>
        /// <param name="drawingContext">DrawingContext to draw on</param>
        /// <param name="drawingAttributes">DrawingAttributes to draw with</param>
        protected virtual void DrawCore(DrawingContext drawingContext, DrawingAttributes drawingAttributes)
        {
            ArgumentNullException.ThrowIfNull(drawingContext);

            ArgumentNullException.ThrowIfNull(drawingAttributes);

            if (_drawAsHollow == true)
            {
                // Draw as hollow. Our profiler result shows that the two-pass-rendering approach is about 5 times
                // faster that using GetOutlinePathGeometry.
                // also, the minimum display size for selected ink is our default width / height

                Matrix innerTransform, outerTransform;
                DrawingAttributes selectedDA = drawingAttributes.Clone();
                selectedDA.Height = Math.Max(selectedDA.Height, DrawingAttributes.DefaultHeight);
                selectedDA.Width = Math.Max(selectedDA.Width, DrawingAttributes.DefaultWidth);
                CalcHollowTransforms(selectedDA, out innerTransform, out outerTransform);

                // First pass drawing. Use drawingAttributes.Color to create a solid color brush. The stroke will be drawn as
                // 1 avalon-unit higher and wider (HollowLineSize = 1.0f)
                selectedDA.StylusTipTransform = outerTransform;
                SolidColorBrush brush = new SolidColorBrush(drawingAttributes.Color);
                brush.Freeze();
                drawingContext.DrawGeometry(brush, null, GetGeometry(selectedDA));

                //Second pass drawing with a white color brush. The stroke will be drawn as
                // 1 avalon-unit shorter and narrower (HollowLineSize = 1.0f) if the actual-width/height (considering StylusTipTransform)
                // is larger than HollowLineSize. Otherwise the same size stroke is drawn.
                selectedDA.StylusTipTransform = innerTransform;
                drawingContext.DrawGeometry(Brushes.White, null, GetGeometry(selectedDA));
            }
            else
            {
#if DEBUG_RENDERING_FEEDBACK
                //render debug feedback?
                Guid guid = new Guid("52053C24-CBDD-4547-AAA1-DEFEBF7FD1E1");
                if (this.ContainsPropertyData(guid))
                {
                    double thickness = (double)this.GetPropertyData(guid);

                    //first, draw the outline of the stroke
                    drawingContext.DrawGeometry(null,
                                                new Pen(Brushes.Black, thickness),
                                                GetGeometry());

                    Geometry g2;
                    Rect b2;
                    //next, overlay the connecting quad points
                    StrokeRenderer.CalcGeometryAndBounds(StrokeNodeIterator.GetIterator(this, drawingAttributes),
                                                         drawingAttributes,
                                                         drawingContext, thickness, true,
                                                         true, //calc bounds
                                                         out g2,
                                                         out b2);
                    
                }
                else
                {
#endif
                SolidColorBrush brush = new SolidColorBrush(drawingAttributes.Color);
                brush.Freeze();
                drawingContext.DrawGeometry(brush, null, GetGeometry(drawingAttributes));
#if DEBUG_RENDERING_FEEDBACK
                }
#endif
            }
        }

        /// <summary>
        /// Returns the Geometry of this stroke.
        /// </summary>
        /// <returns></returns>
        public Geometry GetGeometry()
        {
            return GetGeometry(this.DrawingAttributes);
        }

        /// <summary>
        /// Get the Geometry of the Stroke
        /// </summary>
        /// <param name="drawingAttributes"></param>
        /// <returns></returns>
        public Geometry GetGeometry(DrawingAttributes drawingAttributes)
        {
            ArgumentNullException.ThrowIfNull(drawingAttributes);

            bool geometricallyEqual = DrawingAttributes.GeometricallyEqual(drawingAttributes, this.DrawingAttributes);

            // need to recalculate the PathGeometry if the DA passed in is "geometrically" different from
            // this DA, or if the cached PathGeometry is dirty.
            if (false == geometricallyEqual || (true == geometricallyEqual && null == _cachedGeometry))
            {
                //Recalculate _pathGeometry;
                StrokeNodeIterator iterator = StrokeNodeIterator.GetIterator(this, drawingAttributes);
                Geometry geometry;
                Rect bounds;
                StrokeRenderer.CalcGeometryAndBounds(iterator,
                                                     drawingAttributes,
#if DEBUG_RENDERING_FEEDBACK
                                                     null, 0d, false,
#endif
                                                     true, //calc bounds
                                                     out geometry,
                                                     out bounds);

                // return the calculated value directly. We cannot cache the result since the DA passed in
                // is "geometrically" different from this.DrawingAttributes.
                if (false == geometricallyEqual)
                {
                    return geometry;
                }

                // Cache the value and set _isPathGeometryDirty to false;
                SetGeometry(geometry);
                SetBounds(bounds);

                return geometry;
            }

            // return a ref to our _cachedGeometry
            System.Diagnostics.Debug.Assert(_cachedGeometry != null && _cachedGeometry.IsFrozen);
            return _cachedGeometry;
        }

        #endregion

        #region Internal APIs

        /// <summary>
        /// our code - StrokeVisual.OnRender and StrokeCollection.Draw - always calls this
        /// so we can assume the correct opacity has already been pushed on dc. The flag drawAsHollow is set
        /// to true when this function is called from Renderer and this.IsSelected == true.
        /// </summary>
        [FriendAccessAllowed] // Built into Core, also used by Framework.
        internal void DrawInternal(DrawingContext dc, DrawingAttributes DrawingAttributes, bool drawAsHollow)
        {
            if (drawAsHollow == true)
            {
                // The Stroke.DrawCore may be overriden in the 3rd party code.
                // The out-side code could throw exception. We use try/finally block to protect our status.
                try
                {
                    _drawAsHollow = true;  // temporarily set the flag to be true
                    this.DrawCore(dc, DrawingAttributes);
                }
                finally
                {
                    _drawAsHollow = false;  // reset _drawAsHollow
                }
            }
            else
            {
                // IsSelected can be true or false, but _drawAsHollow must be false
                System.Diagnostics.Debug.Assert(false == _drawAsHollow);
                this.DrawCore(dc, DrawingAttributes);
            }
        }


        /// <summary>
        /// Used by Inkcanvas to draw selected stroke as hollow.
        /// </summary>
        [FriendAccessAllowed] // Built into Core, also used by Framework.
        internal bool IsSelected
        {
            get { return _isSelected; }
            set
            {
                if (value != _isSelected)
                {
                    _isSelected = value;

                    // Raise Invalidated event. This will cause Renderer to repaint and call back DrawCore
                    OnInvalidated(EventArgs.Empty);
                }
            }
        }

        /// <summary>
        /// Set the path geometry
        /// </summary>
        internal void SetGeometry(Geometry geometry)
        {
            System.Diagnostics.Debug.Assert(geometry != null);
            _cachedGeometry = geometry;
        }

        /// <summary>
        /// Set the bounds
        /// </summary>
        internal void SetBounds(Rect newBounds)
        {
            System.Diagnostics.Debug.Assert(newBounds.IsEmpty == false);
            _cachedBounds = newBounds;
        }

        /// <summary>Hit tests all segments within a contour generated with shape and path</summary>
        /// <param name="shape"></param>
        /// <param name="path"></param>
        /// <returns>StrokeIntersection array for these segments</returns>
        internal StrokeIntersection[] EraseTest(IEnumerable<Point> path, StylusShape shape)
        {
            System.Diagnostics.Debug.Assert(shape != null);
            System.Diagnostics.Debug.Assert(path != null);
            if (IEnumerablePointHelper.GetCount(path) == 0)
            {
                return Array.Empty<StrokeIntersection>();
            }

            ErasingStroke erasingStroke = new ErasingStroke(shape, path);
            List<StrokeIntersection> intersections = new List<StrokeIntersection>();
            erasingStroke.EraseTest(StrokeNodeIterator.GetIterator(this, this.DrawingAttributes), intersections);
            return intersections.ToArray();
        }

        /// <summary>
        /// Hit tests all segments within the lasso loops
        /// </summary>
        /// <returns> a StrokeIntersection array for these segments</returns>
        internal StrokeIntersection[] HitTest(Lasso lasso)
        {
            // Check the input parameters
            System.Diagnostics.Debug.Assert(lasso != null);
            if (lasso.IsEmpty)
            {
                return Array.Empty<StrokeIntersection>();
            }

            // The following will check whether all the points are within the lasso.
            // If yes, return the whole stroke as being hit.
            if (!lasso.Bounds.IntersectsWith(this.GetBounds()))
            {
                return Array.Empty<StrokeIntersection>();
            }
            return lasso.HitTest(StrokeNodeIterator.GetIterator(this, this.DrawingAttributes));
        }


        /// <summary>
        /// Calculate the after-erasing Strokes. Only the "out-segments" are left after this operation.
        /// </summary>
        /// <param name="cutAt">Array of intersections indicating the erasing locations</param>
        /// <returns></returns>
        internal StrokeCollection Erase(StrokeIntersection[] cutAt)
        {
            System.Diagnostics.Debug.Assert(cutAt != null);

            // Nothing needs to be erased
            if(cutAt.Length == 0)
            {
                StrokeCollection strokes = new StrokeCollection();
                strokes.Add(this.Clone()); //clip and erase always return clones for this condition
                return strokes;
            }

            // Two assertions are deferred to the private erase function to avoid duplicate code.
            // 1. AssertSortedNoOverlap
            // 2. Check whether the insegments are out of range with the packets
            StrokeFIndices[] hitSegments = StrokeIntersection.GetHitSegments(cutAt);
            return this.Erase(hitSegments);
        }

        /// <summary>
        /// Calculate the after-clipping Strokes. Only the "in-segments" are left after this operation.
        /// </summary>
        /// <param name="cutAt">Array of intersections indicating the clipping locations</param>
        /// <returns>The resulting StrokeCollection</returns>
        internal StrokeCollection Clip(StrokeIntersection[] cutAt)
        {
            System.Diagnostics.Debug.Assert(cutAt != null);

            // Nothing is inside
            if (cutAt.Length == 0)
            {
                return new StrokeCollection();
            }


            // Get the "in-segments"
            StrokeFIndices[] inSegments = StrokeIntersection.GetInSegments(cutAt);

            // For special case like cutAt is {BF, AL, BF, 0.67}, the inSegments are empty
            if (inSegments.Length == 0)
            {
                return new StrokeCollection();
            }

            // Two other validations are deferred to the private clip function to avoid duplicate code.
            // 1. ValidateSortedNoOverlap
            // 2. Check whether the insegments are out of range with the packets
            return this.Clip(inSegments);
        }


        internal double TapHitPointSize = 1.0;
        internal double TapHitRotation = 0;
        #endregion

        #region Private APIs

        /// <summary>
        /// Calculate the two transforms for two-pass rendering used to draw as hollow. The resulting outerTransform will make the
        /// first-pass-rendering 1 avalon-unit wider/heigher. The resulting innerTransform will make the second-pass-rendering 1 avalon-unit
        /// narrower/shorter.
        /// </summary>
        private static void CalcHollowTransforms(DrawingAttributes originalDa, out Matrix innerTransform, out Matrix outerTransform)
        {
            System.Diagnostics.Debug.Assert(DoubleUtil.IsZero(originalDa.StylusTipTransform.OffsetX) && DoubleUtil.IsZero(originalDa.StylusTipTransform.OffsetY));

            innerTransform = outerTransform = Matrix.Identity;
            Point w = originalDa.StylusTipTransform.Transform(new Point(originalDa.Width, 0));
            Point h = originalDa.StylusTipTransform.Transform(new Point(0, originalDa.Height));

            // the newWidth and newHeight are the actual width/height of the stylus shape considering StylusTipTransform.
            // The assumption is TylusTipTransform has no translation component.
            double newWidth = Math.Sqrt(w.X * w.X + w.Y * w.Y);
            double newHeight = Math.Sqrt(h.X * h.X + h.Y * h.Y);

            double xTransform = DoubleUtil.GreaterThan(newWidth, HollowLineSize) ?
                                (newWidth - HollowLineSize) / newWidth : 1.0f;
            double yTransform = DoubleUtil.GreaterThan(newHeight, HollowLineSize) ?
                                (newHeight - HollowLineSize) / newHeight : 1.0f;

            innerTransform.Scale(xTransform, yTransform);
            innerTransform *= originalDa.StylusTipTransform;

            outerTransform.Scale((newWidth + HollowLineSize) / newWidth,
                                 (newHeight + HollowLineSize) / newHeight);
            outerTransform *= originalDa.StylusTipTransform;
        }

        #region Private fields

        private Geometry                _cachedGeometry     = null;
        private bool                    _isSelected         = false;
        private bool                    _drawAsHollow       = false;
        private bool                    _cloneStylusPoints  = true;
        private bool                    _delayRaiseInvalidated  = false;
        private const double            HollowLineSize = 1.0f;
        private Rect                    _cachedBounds       = Rect.Empty;

        // The private PropertyChanged event
        private PropertyChangedEventHandler _propertyChanged;

        private const string DrawingAttributesName = "DrawingAttributes";
        private const string StylusPointsName = "StylusPoints";

        #endregion

        internal const double PercentageTolerance = 0.0001d;
        #endregion
    }
}
