// 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_LASSO_FEEDBACK // DO NOT LEAVE ENABLED IN CHECKED IN CODE
//
// Description:
//      Defines an inkable canvas that represents the primary api for
//      editing ink
//

using MS.Utility;
using MS.Internal;
using MS.Internal.Commands;
using MS.Internal.Controls;
using MS.Internal.Ink;
using MS.Internal.KnownBoxes;
using System;
using System.Collections;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.IO;
using System.Windows;
using System.Collections.Generic;
using System.Security;
using System.Runtime.InteropServices;
using System.Windows.Media;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Input.StylusPlugIns;
using System.Windows.Controls;
using System.Windows.Markup; // IAddChild, ContentPropertyAttribute
using System.Windows.Threading;
using System.Windows.Automation.Peers;

using BuildInfo = MS.Internal.PresentationFramework.BuildInfo;
using SecurityHelper = MS.Internal.SecurityHelper;

namespace System.Windows.Controls
{
    /// <summary>
    /// InkCanvas is used to allow inking on a canvas
    /// </summary>
    [ContentProperty("Children")]
    public class InkCanvas : FrameworkElement, IAddChild
    {
        #region Constructors / Initialization

        /// <summary>
        /// The static constructor
        /// </summary>
        static InkCanvas()
        {
            Type ownerType = typeof(InkCanvas);

            //
            // We should add the following listener as the class handler which will be guarantied to receive the
            // notification before the handler on the instances. So we won't be trapped in the bad state due to the
            // event routing.
            // Listen to stylus events which will be redirected to the current StylusEditingBehavior

            //Down
            EventManager.RegisterClassHandler(ownerType, Stylus.StylusDownEvent,
                new StylusDownEventHandler(_OnDeviceDown<StylusDownEventArgs>));
            EventManager.RegisterClassHandler(ownerType, Mouse.MouseDownEvent,
                new MouseButtonEventHandler(_OnDeviceDown<MouseButtonEventArgs>));

            //Up
            EventManager.RegisterClassHandler(ownerType, Stylus.StylusUpEvent,
                new StylusEventHandler(_OnDeviceUp<StylusEventArgs>));
            EventManager.RegisterClassHandler(ownerType, Mouse.MouseUpEvent,
                new MouseButtonEventHandler(_OnDeviceUp<MouseButtonEventArgs>));



            EventManager.RegisterClassHandler(ownerType, Mouse.QueryCursorEvent,
                new QueryCursorEventHandler(_OnQueryCursor), true);

            // Set up the commanding handlers
            _RegisterClipboardHandlers();
            CommandHelpers.RegisterCommandHandler(ownerType, ApplicationCommands.Delete,
                new ExecutedRoutedEventHandler(_OnCommandExecuted), new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled));

            CommandHelpers.RegisterCommandHandler(ownerType, ApplicationCommands.SelectAll,
                Key.A, ModifierKeys.Control, new ExecutedRoutedEventHandler(_OnCommandExecuted), new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled));

            CommandHelpers.RegisterCommandHandler(ownerType, InkCanvas.DeselectCommand,
                new ExecutedRoutedEventHandler(_OnCommandExecuted), new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled),
                KeyGesture.CreateFromResourceStrings(InkCanvasDeselectKey, nameof(SR.InkCanvasDeselectKeyDisplayString)));

            //
            //set our clipping
            //
            ClipToBoundsProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));

            //
            //enable input focus
            //
            FocusableProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));

            // The default InkCanvas style
            Style defaultStyle = new Style(ownerType);
            // The background - Window Color
            defaultStyle.Setters.Add(new Setter(InkCanvas.BackgroundProperty,
                            new DynamicResourceExtension(SystemColors.WindowBrushKey)));
            // Default InkCanvas to having flicks disabled by default.
            defaultStyle.Setters.Add(new Setter(Stylus.IsFlicksEnabledProperty, false));
            // Default InkCanvas to having tap feedback disabled by default.
            defaultStyle.Setters.Add(new Setter(Stylus.IsTapFeedbackEnabledProperty, false));
            // Default InkCanvas to having touch feedback disabled by default.
            defaultStyle.Setters.Add(new Setter(Stylus.IsTouchFeedbackEnabledProperty, false));

            // Set MinWidth to 350d if Width is set to Auto
            Trigger trigger = new Trigger();
            trigger.Property = WidthProperty;
            trigger.Value = double.NaN;
            Setter setter = new Setter();
            setter.Property = MinWidthProperty;
            setter.Value = 350d;
            trigger.Setters.Add(setter);
            defaultStyle.Triggers.Add(trigger);

            // Set MinHeight to 250d if Height is set to Auto
            trigger = new Trigger();
            trigger.Property = HeightProperty;
            trigger.Value = double.NaN;
            setter = new Setter();
            setter.Property = MinHeightProperty;
            setter.Value = 250d;
            trigger.Setters.Add(setter);
            defaultStyle.Triggers.Add(trigger);

            // Seal the default style
            defaultStyle.Seal();

            StyleProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(defaultStyle));
            DefaultStyleKeyProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(typeof(InkCanvas)));

            FocusVisualStyleProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata((object)null /* default value */));
        }

        /// <summary>
        /// Public constructor.
        /// </summary>
        public InkCanvas() : base()
        {
            Initialize();
        }

        /// <summary>
        /// Private initialization method used by the constructors
        /// </summary>
        private void Initialize()
        {
            //
            // instance the DynamicRenderer and add it to the StylusPlugIns
            //
            _dynamicRenderer = new DynamicRenderer();
            _dynamicRenderer.Enabled = false;
            this.StylusPlugIns.Add(_dynamicRenderer);

            //
            // create and initialize an editing coordinator
            //
            _editingCoordinator = new EditingCoordinator(this);
            _editingCoordinator.UpdateActiveEditingState();


            // connect the attributes event handler after setting the stylus shape to avoid unnecessary
            //      calls into the RTI service
            DefaultDrawingAttributes.AttributeChanged += new PropertyDataChangedEventHandler(DefaultDrawingAttributes_Changed);

            //
            //
            // We must initialize this here (after adding DynamicRenderer to Sytlus).
            //
            this.InitializeInkObject();

            _rtiHighContrastCallback = new RTIHighContrastCallback(this);

            // Register rti high contrast callback. Then check whether we are under the high contrast already.
            HighContrastHelper.RegisterHighContrastCallback(_rtiHighContrastCallback);
            if ( SystemParameters.HighContrast )
            {
                _rtiHighContrastCallback.TurnHighContrastOn(SystemColors.WindowTextColor);
            }
        }

        /// <summary>
        /// Private helper used to change the Ink objects.  Used in the constructor
        /// and the Ink property.
        ///
        /// NOTE -- Caller is responsible for clearing any selection!  (We can't clear it
        ///         here because the Constructor calls this method and it would end up calling
        ///         looking like it could call a virtual method and FxCop doesn't like that!)
        ///
        /// </summary>
        private void InitializeInkObject()
        {
            // Update the RealTimeInking PlugIn for the Renderer changes.
            UpdateDynamicRenderer();

            // Initialize DefaultPacketDescription
            _defaultStylusPointDescription = new StylusPointDescription();
        }
        #endregion Constructors  / Initialization

        #region Protected Overrides

        /// <summary>
        /// MeasureOverride
        /// </summary>
        /// <param name="availableSize"></param>
        /// <returns></returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            // No need to invoke VerifyAccess since _localAdornerDecorator.Measure should check it.
            if ( _localAdornerDecorator == null )
            {
                ApplyTemplate();
            }

            _localAdornerDecorator.Measure(availableSize);

            return  _localAdornerDecorator.DesiredSize;
        }

        /// <summary>
        /// ArrangeOverride
        /// </summary>
        /// <param name="arrangeSize"></param>
        /// <returns></returns>
        protected override Size ArrangeOverride(Size arrangeSize)
        {
            // No need to invoke VerifyAccess since _localAdornerDecorator.Arrange should check it.

            if ( _localAdornerDecorator == null )
            {
                ApplyTemplate();
            }

            _localAdornerDecorator.Arrange(new Rect(arrangeSize));

            return arrangeSize;
        }


        /// <summary>
        /// HitTestCore implements precise hit testing against render contents
        /// </summary>
        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParams)
        {
            VerifyAccess();

            Rect r = new Rect(new Point(), RenderSize);
            if (r.Contains(hitTestParams.HitPoint))
            {
                return new PointHitTestResult(this, hitTestParams.HitPoint);
            }

            return null;
        }

        /// <summary>
        /// OnPropertyChanged
        /// </summary>
        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
        {
            base.OnPropertyChanged(e);

            if (e.IsAValueChange || e.IsASubPropertyChange)
            {
                if (e.Property == UIElement.RenderTransformProperty ||
                    e.Property == FrameworkElement.LayoutTransformProperty)
                {
                    EditingCoordinator.InvalidateTransform();

                    Transform transform = e.NewValue as Transform;
                    if (transform != null && !transform.HasAnimatedProperties)
                    {
                        TransformGroup transformGroup = transform as TransformGroup;
                        if ( transformGroup != null )
                        {
                            //walk down the tree looking for animated transforms
                            Stack<Transform> transforms = new Stack<Transform>();
                            transforms.Push(transform);
                            while ( transforms.Count > 0 )
                            {
                                transform = transforms.Pop();
                                if ( transform.HasAnimatedProperties )
                                {
                                    return;
                                }
                                transformGroup = transform as TransformGroup;
                                if ( transformGroup != null )
                                {
                                    for ( int i = 0; i < transformGroup.Children.Count; i++ )
                                    {
                                        transforms.Push(transformGroup.Children[i]);
                                    }
                                }
                            }
                        }

                        //
                        // only invalidate when there is not an animation on the xf,
                        // or we could wind up creating thousands of new cursors.  That's bad.
                        //
                        _editingCoordinator.InvalidateBehaviorCursor(_editingCoordinator.InkCollectionBehavior);
                        EditingCoordinator.UpdatePointEraserCursor();
                    }
                }
                if (e.Property == FrameworkElement.FlowDirectionProperty)
                {
                    //flow direction only affects the inking cursor.
                    _editingCoordinator.InvalidateBehaviorCursor(_editingCoordinator.InkCollectionBehavior);
                }
            }
        }

        /// <summary>
        /// Called when the Template's tree is about to be generated
        /// </summary>
        internal override void OnPreApplyTemplate()
        {
            // No need for calling VerifyAccess since we call the method on the base here.

            base.OnPreApplyTemplate();

            // Build our visual tree here.
            // <InkCanvas>
            //     <AdornerDecorator>
            //         <InkPresenter>
            //             <InnerCanvas />
            //             <ContainerVisual />              <!-- Ink Renderer static visual -->
            //             <HostVisual />                   <!-- Ink Dynamic Renderer -->
            //         </InkPresenter>
            //         <AdornerLayer>                       <!-- Create by AdornerDecorator automatically -->
            //             <InkCanvasSelectionAdorner />
            //             <InkCanvasFeedbackAdorner />     <!-- Dynamically hooked up when moving/sizing the selection -->
            //         </AdornerLayer>
            //     </AdornerDecorator>
            //  </InkCanvas>

            if ( _localAdornerDecorator == null )
            {
                //
                _localAdornerDecorator = new AdornerDecorator();
                InkPresenter inkPresenter = InkPresenter;

                // Build the visual tree top-down
                AddVisualChild(_localAdornerDecorator);
                _localAdornerDecorator.Child = inkPresenter;
                inkPresenter.Child = InnerCanvas;

                // Add the SelectionAdorner after Canvas is added.
                _localAdornerDecorator.AdornerLayer.Add(SelectionAdorner);
            }
        }

        /// <summary>
        /// Returns the Visual children count.
        /// </summary>
        protected override int VisualChildrenCount
        {
            get { return (_localAdornerDecorator == null) ? 0 : 1; }
        }

        /// <summary>
        /// Returns the child at the specified index.
        /// </summary>
        protected override Visual GetVisualChild(int index)
        {
            if (    (_localAdornerDecorator == null)
                ||  (index != 0))
            {
                throw new ArgumentOutOfRangeException("index", index, SR.Visual_ArgumentOutOfRange);
            }

            return _localAdornerDecorator;
        }

        /// <summary>
        /// UIAutomation support
        /// </summary>
        protected override AutomationPeer OnCreateAutomationPeer()
        {
            return new InkCanvasAutomationPeer(this);
        }

        #endregion Protected Overrides

        #region Public Properties

        /// <summary>
        ///     The DependencyProperty for the Background property.
        /// </summary>
        public static readonly DependencyProperty BackgroundProperty =
                Panel.BackgroundProperty.AddOwner(
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(
                                null,
                                FrameworkPropertyMetadataOptions.AffectsRender));

        /// <summary>
        ///     An object that describes the background.
        /// </summary>
        [Bindable(true), Category("Appearance")]
        public Brush Background
        {
            get { return (Brush) GetValue(BackgroundProperty); }
            set { SetValue(BackgroundProperty, value); }
        }

        /// <summary>
        /// Top DependencyProperty
        /// </summary>
        public static readonly DependencyProperty TopProperty =
                DependencyProperty.RegisterAttached("Top", typeof(double), typeof(InkCanvas),
                    new FrameworkPropertyMetadata(Double.NaN, new PropertyChangedCallback(OnPositioningChanged)),
                    new ValidateValueCallback(System.Windows.Shapes.Shape.IsDoubleFiniteOrNaN));

        /// <summary>
        /// Reads the attached property Top from the given element.
        /// </summary>
        /// <param name="element">The element from which to read the Top attached property.</param>
        /// <returns>The property's value.</returns>
        /// <seealso cref="InkCanvas.TopProperty" />
        [TypeConverter($"System.Windows.LengthConverter, PresentationFramework, Version={BuildInfo.WCP_VERSION}, Culture=neutral, PublicKeyToken={BuildInfo.WCP_PUBLIC_KEY_TOKEN}, Custom=null")]
        [AttachedPropertyBrowsableForChildren()]
        public static double GetTop(UIElement element)
        {
            ArgumentNullException.ThrowIfNull(element);
            return (double)element.GetValue(TopProperty);
        }

        /// <summary>
        /// Writes the attached property Top to the given element.
        /// </summary>
        /// <param name="element">The element to which to write the Top attached property.</param>
        /// <param name="length">The length to set</param>
        /// <seealso cref="InkCanvas.TopProperty" />
        public static void SetTop(UIElement element, double length)
        {
            ArgumentNullException.ThrowIfNull(element);
            element.SetValue(TopProperty, length);
        }

        /// <summary>
        /// The Bottom DependencyProperty
        /// </summary>
        public static readonly DependencyProperty BottomProperty =
                DependencyProperty.RegisterAttached("Bottom", typeof(double), typeof(InkCanvas),
                    new FrameworkPropertyMetadata(Double.NaN, new PropertyChangedCallback(OnPositioningChanged)),
                    new ValidateValueCallback(System.Windows.Shapes.Shape.IsDoubleFiniteOrNaN));

        /// <summary>
        /// Reads the attached property Bottom from the given element.
        /// </summary>
        /// <param name="element">The element from which to read the Bottom attached property.</param>
        /// <returns>The property's Length value.</returns>
        /// <seealso cref="InkCanvas.BottomProperty" />
        [TypeConverter($"System.Windows.LengthConverter, PresentationFramework, Version={BuildInfo.WCP_VERSION}, Culture=neutral, PublicKeyToken={BuildInfo.WCP_PUBLIC_KEY_TOKEN}, Custom=null")]
        [AttachedPropertyBrowsableForChildren()]
        public static double GetBottom(UIElement element)
        {
            ArgumentNullException.ThrowIfNull(element);
            return (double)element.GetValue(BottomProperty);
        }

        /// <summary>
        /// Writes the attached property Bottom to the given element.
        /// </summary>
        /// <param name="element">The element to which to write the Bottom attached property.</param>
        /// <param name="length">The Length to set</param>
        /// <seealso cref="InkCanvas.BottomProperty" />
        public static void SetBottom(UIElement element, double length)
        {
            ArgumentNullException.ThrowIfNull(element);
            element.SetValue(BottomProperty, length);
        }

        /// <summary>
        /// The Left DependencyProperty
        /// </summary>
        public static readonly DependencyProperty LeftProperty =
                DependencyProperty.RegisterAttached("Left", typeof(double), typeof(InkCanvas),
                    new FrameworkPropertyMetadata(Double.NaN, new PropertyChangedCallback(OnPositioningChanged)),
                    new ValidateValueCallback(System.Windows.Shapes.Shape.IsDoubleFiniteOrNaN));

        /// <summary>
        /// Reads the attached property Left from the given element.
        /// </summary>
        /// <param name="element">The element from which to read the Left attached property.</param>
        /// <returns>The property's value.</returns>
        /// <seealso cref="InkCanvas.LeftProperty" />
        [TypeConverter($"System.Windows.LengthConverter, PresentationFramework, Version={BuildInfo.WCP_VERSION}, Culture=neutral, PublicKeyToken={BuildInfo.WCP_PUBLIC_KEY_TOKEN}, Custom=null")]
        [AttachedPropertyBrowsableForChildren()]
        public static double GetLeft(UIElement element)
        {
            ArgumentNullException.ThrowIfNull(element);
            return (double)element.GetValue(LeftProperty);
        }

        /// <summary>
        /// Writes the attached property Left to the given element.
        /// </summary>
        /// <param name="element">The element to which to write the Left attached property.</param>
        /// <param name="length">The length to set</param>
        /// <seealso cref="InkCanvas.LeftProperty" />
        public static void SetLeft(UIElement element, double length)
        {
            ArgumentNullException.ThrowIfNull(element);
            element.SetValue(LeftProperty, length);
        }

        /// <summary>
        /// The Right DependencyProperty
        /// </summary>
        public static readonly DependencyProperty RightProperty =
                DependencyProperty.RegisterAttached("Right", typeof(double), typeof(InkCanvas),
                    new FrameworkPropertyMetadata(Double.NaN, new PropertyChangedCallback(OnPositioningChanged)),
                    new ValidateValueCallback(System.Windows.Shapes.Shape.IsDoubleFiniteOrNaN));

        /// <summary>
        /// Reads the attached property Right from the given element.
        /// </summary>
        /// <param name="element">The element from which to read the Right attached property.</param>
        /// <returns>The property's Length value.</returns>
        /// <seealso cref="InkCanvas.RightProperty" />
        [TypeConverter($"System.Windows.LengthConverter, PresentationFramework, Version={BuildInfo.WCP_VERSION}, Culture=neutral, PublicKeyToken={BuildInfo.WCP_PUBLIC_KEY_TOKEN}, Custom=null")]
        [AttachedPropertyBrowsableForChildren()]
        public static double GetRight(UIElement element)
        {
            ArgumentNullException.ThrowIfNull(element);
            return (double)element.GetValue(RightProperty);
        }

        /// <summary>
        /// Writes the attached property Right to the given element.
        /// </summary>
        /// <param name="element">The element to which to write the Right attached property.</param>
        /// <param name="length">The Length to set</param>
        /// <seealso cref="InkCanvas.RightProperty" />
        public static void SetRight(UIElement element, double length)
        {
            ArgumentNullException.ThrowIfNull(element);
            element.SetValue(RightProperty, length);
        }

        /// <summary>
        /// OnPositioningChanged
        /// </summary>
        /// <param name="d"></param>
        /// <param name="e"></param>
        private static void OnPositioningChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            UIElement uie = d as UIElement;
            if ( uie != null )
            {
                // Make sure the UIElement is a child of InkCanvasInnerCanvas.
                InkCanvasInnerCanvas p = VisualTreeHelper.GetParent(uie) as InkCanvasInnerCanvas;
                if ( p != null )
                {
                    if ( e.Property == InkCanvas.LeftProperty
                        || e.Property == InkCanvas.TopProperty )
                    {
                        // Invalidate measure for Left and/or Top.
                        p.InvalidateMeasure();
                    }
                    else
                    {
                        Debug.Assert(e.Property == InkCanvas.RightProperty || e.Property == InkCanvas.BottomProperty,
                            string.Format(System.Globalization.CultureInfo.InvariantCulture, "Unknown dependency property detected - {0}.", e.Property));

                        // Invalidate arrange for Right and/or Bottom.
                        p.InvalidateArrange();
                    }
                }
            }
        }

        /// <summary>
        ///     The DependencyProperty for the Strokes property.
        /// </summary>
        public static readonly DependencyProperty StrokesProperty =
                InkPresenter.StrokesProperty.AddOwner(
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(
                                new StrokeCollectionDefaultValueFactory(),
                                new PropertyChangedCallback(OnStrokesChanged)));

        /// <summary>
        /// Gets/Sets the Strokes property.
        /// </summary>
        public StrokeCollection Strokes
        {
            get { return (StrokeCollection)GetValue(StrokesProperty); }
            set { SetValue(StrokesProperty, value); }
        }

        private static void OnStrokesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            InkCanvas inkCanvas = (InkCanvas)d;
            StrokeCollection oldValue = (StrokeCollection)e.OldValue;
            StrokeCollection newValue = (StrokeCollection)e.NewValue;

            //
            // only change the prop if it's a different object.  We don't
            // want to be doing this for no reason
            //
            if ( !object.ReferenceEquals(oldValue, newValue) )
            {
                // Clear the selected strokes without raising event.
                inkCanvas.CoreChangeSelection(new StrokeCollection(), inkCanvas.InkCanvasSelection.SelectedElements, false);

                inkCanvas.InitializeInkObject();

                InkCanvasStrokesReplacedEventArgs args =
                    new InkCanvasStrokesReplacedEventArgs(newValue, oldValue); //new, previous

                //raise the StrokesChanged event through our protected virtual
                inkCanvas.OnStrokesReplaced(args);
            }
        }

        /// <summary>
        /// Returns the SelectionAdorner
        /// </summary>
        internal InkCanvasSelectionAdorner SelectionAdorner
        {
            get
            {
                // We have to create our visual at this point.
                if ( _selectionAdorner == null )
                {
                    // Create the selection Adorner.
                    _selectionAdorner = new InkCanvasSelectionAdorner(InnerCanvas);

                    // Bind the InkCanvas.ActiveEditingModeProperty
                    // to SelectionAdorner.VisibilityProperty.
                    Binding activeEditingModeBinding = new Binding();
                    activeEditingModeBinding.Path = new PropertyPath(InkCanvas.ActiveEditingModeProperty);
                    activeEditingModeBinding.Mode = BindingMode.OneWay;
                    activeEditingModeBinding.Source = this;
                    activeEditingModeBinding.Converter = new ActiveEditingMode2VisibilityConverter();
                    _selectionAdorner.SetBinding(UIElement.VisibilityProperty, activeEditingModeBinding);
                }

                return _selectionAdorner;
            }
        }

        /// <summary>
        /// Returns the FeedbackAdorner
        /// </summary>
        internal InkCanvasFeedbackAdorner FeedbackAdorner
        {
            get
            {
                VerifyAccess();

                if ( _feedbackAdorner == null )
                {
                    _feedbackAdorner = new InkCanvasFeedbackAdorner(this);
                }

                return _feedbackAdorner;
            }
        }

        /// <summary>
        /// Read/Write access to the EraserShape property.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsGestureRecognizerAvailable
        {
            get
            {
                //this property will verify access
                return this.GestureRecognizer.IsRecognizerAvailable;
            }
        }


        /// <summary>
        /// Emulate Panel's Children property.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public UIElementCollection Children
        {
            get
            {
                // No need to invoke VerifyAccess since the call is forwarded.

                return InnerCanvas.Children;
            }
        }

        /// <summary>
        /// The DependencyProperty for the DefaultDrawingAttributes property.
        /// </summary>
        public static readonly DependencyProperty DefaultDrawingAttributesProperty =
                DependencyProperty.Register(
                        "DefaultDrawingAttributes",
                        typeof(DrawingAttributes),
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(
                                new DrawingAttributesDefaultValueFactory(),
                                new PropertyChangedCallback(OnDefaultDrawingAttributesChanged)),
                        (ValidateValueCallback)delegate(object value)
                            { return value != null; });

        /// <summary>
        /// Gets/Sets the DefaultDrawingAttributes property.
        /// </summary>
        public DrawingAttributes DefaultDrawingAttributes
        {
            get { return (DrawingAttributes)GetValue(DefaultDrawingAttributesProperty); }
            set { SetValue(DefaultDrawingAttributesProperty, value); }
        }

        private static void OnDefaultDrawingAttributesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            InkCanvas inkCanvas = (InkCanvas)d;

            DrawingAttributes oldValue = (DrawingAttributes)e.OldValue;
            DrawingAttributes newValue = (DrawingAttributes)e.NewValue;

            // This can throw, so call it first
            inkCanvas.UpdateDynamicRenderer(newValue);

            // We only fire Changed event when there is an instance change.
            if ( !object.ReferenceEquals(oldValue, newValue) )
            {
                //we didn't throw, change our backing value
                oldValue.AttributeChanged -= new PropertyDataChangedEventHandler(inkCanvas.DefaultDrawingAttributes_Changed);
                DrawingAttributesReplacedEventArgs args =
                    new DrawingAttributesReplacedEventArgs(newValue, oldValue);

                newValue.AttributeChanged += new PropertyDataChangedEventHandler(inkCanvas.DefaultDrawingAttributes_Changed);
                inkCanvas.RaiseDefaultDrawingAttributeReplaced(args);
            }
        }

        /// <summary>
        /// Read/Write access to the EraserShape property.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public StylusShape EraserShape
        {
            get
            {
                VerifyAccess();
                if (_eraserShape == null)
                {
                    _eraserShape = new RectangleStylusShape(8f, 8f);
                }
                return _eraserShape;
            }
            set
            {
                VerifyAccess();
                ArgumentNullException.ThrowIfNull(value);

                // Invoke getter since this property is lazily created.
                StylusShape oldShape = EraserShape;

                _eraserShape = value;


                if ( oldShape.Width != _eraserShape.Width || oldShape.Height != _eraserShape.Height
                    || oldShape.Rotation != _eraserShape.Rotation || oldShape.GetType() != _eraserShape.GetType())
                {
                    EditingCoordinator.UpdatePointEraserCursor();
                }
            }
        }


        /// <summary>
        /// ActiveEditingMode
        /// </summary>
        internal static readonly DependencyPropertyKey ActiveEditingModePropertyKey =
                DependencyProperty.RegisterReadOnly(
                        "ActiveEditingMode",
                        typeof(InkCanvasEditingMode),
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(InkCanvasEditingMode.Ink));

        /// <summary>
        /// ActiveEditingModeProperty Dependency Property
        /// </summary>
        public static readonly DependencyProperty ActiveEditingModeProperty = ActiveEditingModePropertyKey.DependencyProperty;

        /// <summary>
        /// Gets the ActiveEditingMode
        /// </summary>
        public InkCanvasEditingMode ActiveEditingMode
        {
            get { return (InkCanvasEditingMode)GetValue(ActiveEditingModeProperty); }
        }

        /// <summary>
        /// The DependencyProperty for the EditingMode property.
        /// </summary>
        public static readonly DependencyProperty EditingModeProperty =
                DependencyProperty.Register(
                        "EditingMode",
                        typeof(InkCanvasEditingMode),
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(
                                InkCanvasEditingMode.Ink,
                                new PropertyChangedCallback(OnEditingModeChanged)),
                        new ValidateValueCallback(ValidateEditingMode));


        /// <summary>
        /// Gets/Sets EditingMode
        /// </summary>
        public InkCanvasEditingMode EditingMode
        {
            get { return (InkCanvasEditingMode)GetValue(EditingModeProperty); }
            set { SetValue(EditingModeProperty, value); }
        }


        private static void OnEditingModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ( (InkCanvas)d ).RaiseEditingModeChanged(
                                new RoutedEventArgs(InkCanvas.EditingModeChangedEvent, d));
        }

        /// <summary>
        /// The DependencyProperty for the EditingModeInverted property.
        /// </summary>
        public static readonly DependencyProperty EditingModeInvertedProperty =
                DependencyProperty.Register(
                        "EditingModeInverted",
                        typeof(InkCanvasEditingMode),
                        typeof(InkCanvas),
                        new FrameworkPropertyMetadata(
                                InkCanvasEditingMode.EraseByStroke,
                                new PropertyChangedCallback(OnEditingModeInvertedChanged)),
                        new ValidateValueCallback(ValidateEditingMode));

        /// <summary>
        /// Gets/Sets EditingMode
        /// </summary>
        public InkCanvasEditingMode EditingModeInverted
        {
            get { return (InkCanvasEditingMode)GetValue(EditingModeInvertedProperty); }
            set { SetValue(EditingModeInvertedProperty, value); }
        }

        private static void OnEditingModeInvertedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ( (InkCanvas)d ).RaiseEditingModeInvertedChanged(
                new RoutedEventArgs(InkCanvas.EditingModeInvertedChangedEvent, d));
        }

        private static bool ValidateEditingMode(object value)
        {
            return EditingModeHelper.IsDefined((InkCanvasEditingMode)value);
        }

        /// <summary>
        /// This flag indicates whether the developer is using a custom mouse cursor.
        ///
        /// If this flag is true, we will never change the current cursor on them. Not
        /// on edit mode change.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool UseCustomCursor
        {
            get
            {
                VerifyAccess();
                return _useCustomCursor;
            }
            set
            {
                VerifyAccess();

                if ( _useCustomCursor != value )
                {
                    _useCustomCursor = value;
                    UpdateCursor();
                }
            }
        }

        /// <summary>
        /// Gets or set if moving of selection is enabled
        /// </summary>
        /// <value>bool</value>
        public bool MoveEnabled
        {
            get
            {
                VerifyAccess();
                return _editingCoordinator.MoveEnabled;
            }
            set
            {
                VerifyAccess();
                bool oldValue = _editingCoordinator.MoveEnabled;

                if (oldValue != value)
                {
                    _editingCoordinator.MoveEnabled = value;
                }
            }
        }

        /// <summary>
        /// Gets or set if resizing selection is enabled
        /// </summary>
        /// <value>bool</value>
        public bool ResizeEnabled
        {
            get
            {
                VerifyAccess();
                return _editingCoordinator.ResizeEnabled;
            }
            set
            {
                VerifyAccess();
                bool oldValue = _editingCoordinator.ResizeEnabled;

                if (oldValue != value)
                {
                    _editingCoordinator.ResizeEnabled = value;
                }
            }
        }


        /// <summary>
        /// Read/Write access to the DefaultPacketDescription property.
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public StylusPointDescription DefaultStylusPointDescription
        {
            get
            {
                VerifyAccess();

                return _defaultStylusPointDescription;
            }
            set
            {
                VerifyAccess();

                //
                // no nulls allowed
                //
                ArgumentNullException.ThrowIfNull(value);

                _defaultStylusPointDescription = value;
            }
        }

        /// <summary>
        /// Read/Write the enabled ClipboardFormats
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public IEnumerable<InkCanvasClipboardFormat> PreferredPasteFormats
        {
            get
            {
                VerifyAccess();

                return ClipboardProcessor.PreferredFormats;
            }
            set
            {
                VerifyAccess();

                // Cannot be null
                ArgumentNullException.ThrowIfNull(value);

                ClipboardProcessor.PreferredFormats = value;
            }
        }

        #endregion Public Properties

        #region Public Events

        /// <summary>
        ///     The StrokeErased Routed Event
        /// </summary>
        public static readonly RoutedEvent StrokeCollectedEvent =
            EventManager.RegisterRoutedEvent("StrokeCollected", RoutingStrategy.Bubble, typeof(InkCanvasStrokeCollectedEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove StrokeCollected handler
        /// </summary>
        [Category("Behavior")]
        public event InkCanvasStrokeCollectedEventHandler StrokeCollected
        {
            add
            {
                AddHandler(InkCanvas.StrokeCollectedEvent, value);
            }

            remove
            {
                RemoveHandler(InkCanvas.StrokeCollectedEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">InkCanvasStrokeCollectedEventArgs to raise the event with</param>
        protected virtual void OnStrokeCollected(InkCanvasStrokeCollectedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);

            RaiseEvent(e);
        }

        /// <summary>
        /// Allows the InkCollectionBehavior to raise the StrokeCollected event via the protected virtual
        /// </summary>
        /// <param name="e">InkCanvasStrokeCollectedEventArgs to raise the event with</param>
        /// <param name="userInitiated">true only if 100% of the stylusPoints that makes up the stroke
        /// came from eventargs with the UserInitiated flag set to true</param>
        internal void RaiseGestureOrStrokeCollected(InkCanvasStrokeCollectedEventArgs e, bool userInitiated)
        {
            Debug.Assert(e != null, "EventArg can not be null");
            bool addStrokeToInkCanvas = true; // Initialize our flag.

            // The follow code raises Gesture event
            // The out-side code could throw exception in the their handlers. We use try/finally block to protect our status.
            try
            {
                //
                // perform gesture reco before raising this event
                // if we're in the right mode
                //
                //IMPORTANT: only call gesture recognition if userInitiated.  See SecurityNote.
                if (userInitiated)
                {
                    if ((this.ActiveEditingMode == InkCanvasEditingMode.InkAndGesture ||
                          this.ActiveEditingMode == InkCanvasEditingMode.GestureOnly) &&
                          this.GestureRecognizer.IsRecognizerAvailable)
                    {
                        StrokeCollection strokes = new StrokeCollection();
                        strokes.Add(e.Stroke);

                        //
                        // GestureRecognizer.Recognize demands unmanaged code, we assert it here
                        // as this codepath is only called in response to user input
                        //
                        ReadOnlyCollection<GestureRecognitionResult> results =
                            this.GestureRecognizer.CriticalRecognize(strokes);

                        if (results.Count > 0)
                        {
                            InkCanvasGestureEventArgs args =
                                new InkCanvasGestureEventArgs(strokes, results);

                            if (results[0].ApplicationGesture == ApplicationGesture.NoGesture)
                            {
                                //
                                // we set Cancel=true if we didn't detect a gesture
                                //
                                args.Cancel = true;
                            }
                            else
                            {
                                args.Cancel = false;
                            }

                            this.OnGesture(args);

                            //
                            // now that we've raised the Gesture event and the developer
                            // has had a chance to change args.Cancel, see what their intent is.
                            //
                            if (args.Cancel == false)
                            {
                                //bail out and don't add
                                //the stroke to InkCanvas.Strokes
                                addStrokeToInkCanvas = false; // Reset the flag.
                                return;
                            }
                        }
                    }
                }

                // Reset the flag.
                addStrokeToInkCanvas = false;

                //
                // only raise StrokeCollected if we're in InkCanvasEditingMode.Ink or InkCanvasEditingMode.InkAndGesture
                //
                if ( this.ActiveEditingMode == InkCanvasEditingMode.Ink ||
                    this.ActiveEditingMode == InkCanvasEditingMode.InkAndGesture )
                {
                    //add the stroke to the StrokeCollection and raise this event
                    this.Strokes.Add(e.Stroke);
                    this.OnStrokeCollected(e);
                }
            }
            finally
            {
                // If the gesture events are failed, we should still add Stroke to the InkCanvas so that the data won't be lost.
                if ( addStrokeToInkCanvas )
                {
                    this.Strokes.Add(e.Stroke);
                }
            }
        }

        /// <summary>
        ///     The Gesture Routed Event
        /// </summary>
        public static readonly RoutedEvent GestureEvent =
            EventManager.RegisterRoutedEvent("Gesture", RoutingStrategy.Bubble, typeof(InkCanvasGestureEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove Gesture handler
        /// </summary>
        [Category("Behavior")]
        public event InkCanvasGestureEventHandler Gesture
        {
            add
            {
                AddHandler(InkCanvas.GestureEvent, value);
            }

            remove
            {
                RemoveHandler(InkCanvas.GestureEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">InkCanvasGestureEventArgs to raise the event with</param>
        protected virtual void OnGesture(InkCanvasGestureEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);

            RaiseEvent(e);
        }

        /// <summary>
        /// Raised when the InkCanvas.Strokes StrokeCollection has been replaced with another one
        /// </summary>
        public event InkCanvasStrokesReplacedEventHandler StrokesReplaced;

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">InkCanvasStrokesChangedEventArgs to raise the event with</param>
        protected virtual void OnStrokesReplaced(InkCanvasStrokesReplacedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != this.StrokesReplaced)
            {
                StrokesReplaced(this, e);
            }
        }

        /// <summary>
        /// Raised when the InkCanvas.DefaultDrawingAttributes has been replaced with another one
        /// </summary>
        public event DrawingAttributesReplacedEventHandler DefaultDrawingAttributesReplaced;

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">DrawingAttributesReplacedEventArgs to raise the event with</param>
        protected virtual void OnDefaultDrawingAttributesReplaced(DrawingAttributesReplacedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != this.DefaultDrawingAttributesReplaced)
            {
                DefaultDrawingAttributesReplaced(this, e);
            }
        }

        /// <summary>
        /// Private helper for raising DDAReplaced.  Invalidates the inking cursor
        /// </summary>
        /// <param name="e"></param>
        private void RaiseDefaultDrawingAttributeReplaced(DrawingAttributesReplacedEventArgs e)
        {
            this.OnDefaultDrawingAttributesReplaced(e);

            // Invalidate the inking cursor
            _editingCoordinator.InvalidateBehaviorCursor(_editingCoordinator.InkCollectionBehavior);
        }

        /// <summary>
        ///     Event corresponds to ActiveEditingModeChanged
        /// </summary>
        public static readonly RoutedEvent ActiveEditingModeChangedEvent =
            EventManager.RegisterRoutedEvent("ActiveEditingModeChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove ActiveEditingModeChanged handler
        /// </summary>
        [Category("Behavior")]
        public event RoutedEventHandler ActiveEditingModeChanged
        {
            add
            {
                AddHandler(InkCanvas.ActiveEditingModeChangedEvent, value);
            }
            remove
            {
                RemoveHandler(InkCanvas.ActiveEditingModeChangedEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnActiveEditingModeChanged(RoutedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);

            RaiseEvent(e);
        }

        /// <summary>
        /// Private helper that raises ActiveEditingModeChanged
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        internal void RaiseActiveEditingModeChanged(RoutedEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            InkCanvasEditingMode mode = this.ActiveEditingMode;
            if (mode != _editingCoordinator.ActiveEditingMode)
            {
                //change our DP, then raise the event via our protected override
                SetValue(ActiveEditingModePropertyKey, _editingCoordinator.ActiveEditingMode);

                this.OnActiveEditingModeChanged(e);
            }
        }



        /// <summary>
        ///     Event corresponds to EditingModeChanged
        /// </summary>
        public static readonly RoutedEvent EditingModeChangedEvent =
            EventManager.RegisterRoutedEvent("EditingModeChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove EditingModeChanged handler
        /// </summary>
        [Category("Behavior")]
        public event RoutedEventHandler EditingModeChanged
        {
            add
            {
                AddHandler(InkCanvas.EditingModeChangedEvent, value);
            }

            remove
            {
                RemoveHandler(InkCanvas.EditingModeChangedEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnEditingModeChanged(RoutedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);

            RaiseEvent(e);
        }
        /// <summary>
        /// Private helper that raises EditingModeChanged but first
        /// talks to the InkEditor about it
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        private void RaiseEditingModeChanged(RoutedEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            _editingCoordinator.UpdateEditingState(false /* EditingMode */);

            this.OnEditingModeChanged(e);
        }

        //note: there is no need for an internal RaiseEditingModeInvertedChanging
        //since this isn't a dynamic property and therefore can not be set
        //outside of this class

        /// <summary>
        ///     Event corresponds to EditingModeInvertedChanged
        /// </summary>
        public static readonly RoutedEvent EditingModeInvertedChangedEvent =
            EventManager.RegisterRoutedEvent("EditingModeInvertedChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove EditingModeChanged handler
        /// </summary>
        [Category("Behavior")]
        public event RoutedEventHandler EditingModeInvertedChanged
        {
            add
            {
                AddHandler(InkCanvas.EditingModeInvertedChangedEvent, value);
            }

            remove
            {
                RemoveHandler(InkCanvas.EditingModeInvertedChangedEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnEditingModeInvertedChanged(RoutedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);

            RaiseEvent(e);
        }
        /// <summary>
        /// Private helper that raises EditingModeInvertedChanged but first
        /// talks to the InkEditor about it
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        private void RaiseEditingModeInvertedChanged(RoutedEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            _editingCoordinator.UpdateEditingState(true /* EditingModeInverted */);

            this.OnEditingModeInvertedChanged(e);
        }

        /// <summary>
        /// Occurs when the user has moved the selection, after they lift their stylus to commit the change.
        /// This event allows the developer to cancel the move.
        /// </summary>
        public event  InkCanvasSelectionEditingEventHandler SelectionMoving;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e"> InkCanvasSelectionEditingEventArgs to raise the event with</param>
        protected virtual void OnSelectionMoving( InkCanvasSelectionEditingEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionMoving)
            {
                SelectionMoving(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionMoving event via the protected virtual
        /// </summary>
        /// <param name="e"> InkCanvasSelectionEditingEventArgs to raise the event with</param>
        internal void RaiseSelectionMoving( InkCanvasSelectionEditingEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");
            this.OnSelectionMoving(e);
        }

        /// <summary>
        /// Occurs when the user has moved the selection, after they lift their stylus to commit the change.
        /// This event allows the developer to cancel the move.
        /// </summary>
        public event EventHandler SelectionMoved;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnSelectionMoved(EventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionMoved)
            {
                SelectionMoved(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionMoved event via the protected virtual
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        internal void RaiseSelectionMoved(EventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            this.OnSelectionMoved(e);
            // Update the cursor of SelectionEditor behavior.
            EditingCoordinator.SelectionEditor.OnInkCanvasSelectionChanged();
        }

        /// <summary>
        /// Occurs when the user has erased Strokes using the erase behavior
        ///
        /// This event allows the developer to cancel the erase -- therefore, the Stroke should not disappear until
        /// this event has finished.
        /// </summary>
        public event InkCanvasStrokeErasingEventHandler StrokeErasing;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">InkCanvasStrokeErasingEventArgs to raise the event with</param>
        protected virtual void OnStrokeErasing(InkCanvasStrokeErasingEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != StrokeErasing)
            {
                StrokeErasing(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the InkErasing event via the protected virtual
        /// </summary>
        /// <param name="e">InkCanvasStrokeErasingEventArgs to raise the event with</param>
        internal void RaiseStrokeErasing(InkCanvasStrokeErasingEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");
            this.OnStrokeErasing(e);
        }

        /// <summary>
        ///     The StrokeErased Routed Event
        /// </summary>
        public static readonly RoutedEvent StrokeErasedEvent =
            EventManager.RegisterRoutedEvent("StrokeErased", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(InkCanvas));

        /// <summary>
        ///     Add / Remove EditingModeChanged handler
        /// </summary>
        [Category("Behavior")]
        public event RoutedEventHandler StrokeErased
        {
            add
            {
                AddHandler(InkCanvas.StrokeErasedEvent, value);
            }

            remove
            {
                RemoveHandler(InkCanvas.StrokeErasedEvent, value);
            }
        }

        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnStrokeErased(RoutedEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            RaiseEvent(e);
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the InkErasing event via the protected virtual
        /// </summary>
        internal void RaiseInkErased()
        {
            this.OnStrokeErased(
                new RoutedEventArgs(InkCanvas.StrokeErasedEvent, this));
        }

        /// <summary>
        /// Occurs when the user has resized the selection, after they lift their stylus to commit the change.
        /// This event allows the developer to cancel the resize.
        /// </summary>
        public event  InkCanvasSelectionEditingEventHandler SelectionResizing;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e"> InkCanvasSelectionEditingEventArgs to raise the event with</param>
        protected virtual void OnSelectionResizing( InkCanvasSelectionEditingEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionResizing)
            {
                SelectionResizing(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionResizing event via the protected virtual
        /// </summary>
        /// <param name="e"> InkCanvasSelectionEditingEventArgs to raise the event with</param>
        internal void RaiseSelectionResizing( InkCanvasSelectionEditingEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");
            this.OnSelectionResizing(e);
        }

        /// <summary>
        /// Occurs when the selection has been resized via UI interaction.
        /// </summary>
        public event EventHandler SelectionResized;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnSelectionResized(EventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionResized)
            {
                SelectionResized(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionResized event via the protected virtual
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        internal void RaiseSelectionResized(EventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            this.OnSelectionResized(e);
            // Update the cursor of SelectionEditor behavior.
            EditingCoordinator.SelectionEditor.OnInkCanvasSelectionChanged();
        }

        /// <summary>
        /// Occurs when the selection has been changed, either using the lasso or programmatically.
        /// This event allows the developer to cancel the change.
        /// </summary>
        public event InkCanvasSelectionChangingEventHandler SelectionChanging;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">InkCanvasSelectionChangingEventArgs to raise the event with</param>
        protected virtual void OnSelectionChanging(InkCanvasSelectionChangingEventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionChanging)
            {
                SelectionChanging(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionChanging event via the protected virtual
        /// </summary>
        /// <param name="e">InkCanvasSelectionChangingEventArgs to raise the event with</param>
        private void RaiseSelectionChanging(InkCanvasSelectionChangingEventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");
            this.OnSelectionChanging(e);
        }

        /// <summary>
        /// Occurs when the selection has been changed
        /// </summary>
        public event EventHandler SelectionChanged;
        /// <summary>
        /// Protected virtual version for developers deriving from InkCanvas.
        /// This method is what actually throws the event.
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        protected virtual void OnSelectionChanged(EventArgs e)
        {
            // No need to invoke VerifyAccess since this method is thread free.

            ArgumentNullException.ThrowIfNull(e);
            if (null != SelectionChanged)
            {
                SelectionChanged(this, e);
            }
        }

        /// <summary>
        /// Allows the EditingBehaviors to raise the SelectionChanged event via the protected virtual
        /// </summary>
        /// <param name="e">EventArgs to raise the event with</param>
        internal void RaiseSelectionChanged(EventArgs e)
        {
            Debug.Assert(e != null, "EventArg can not be null");

            this.OnSelectionChanged(e);
            // Update the cursor of SelectionEditor behavior.
            EditingCoordinator.SelectionEditor.OnInkCanvasSelectionChanged();
        }

        /// <summary>
        /// The InkCanvas uses an inner Canvas to host children.  When the inner Canvas's children
        /// are changed, we need to call the protected virtual OnVisualChildrenChanged on the InkCanvas
        /// so that subclasses can be notified
        /// </summary>
        internal void RaiseOnVisualChildrenChanged(DependencyObject visualAdded, DependencyObject visualRemoved)
        {
            this.OnVisualChildrenChanged(visualAdded, visualRemoved);
        }

        #endregion Public Events

        #region Public Methods

        /// <summary>
        /// Returns the enabled gestures.  This method throws an exception if GestureRecognizerAvailable
        /// is false
        /// </summary>
        /// <returns></returns>
        public ReadOnlyCollection<ApplicationGesture> GetEnabledGestures()
        {
            // No need to invoke VerifyAccess since it's checked in GestureRecognizer.GetEnabledGestures.

            //gestureRecognizer throws appropriately if there is no gesture recognizer available
            return new ReadOnlyCollection<ApplicationGesture>(this.GestureRecognizer.GetEnabledGestures());
        }

        /// <summary>
        /// Sets the enabled gestures.  This method throws an exception if GestureRecognizerAvailable
        /// is false
        /// </summary>
        /// <returns></returns>
        public void SetEnabledGestures(IEnumerable<ApplicationGesture> applicationGestures)
        {
            // No need to invoke VerifyAccess since it's checked in GestureRecognizer.GetEnabledGestures.

            //gestureRecognizer throws appropriately if there is no gesture recognizer available
            this.GestureRecognizer.SetEnabledGestures(applicationGestures);
        }

        /// <summary>
        /// Get the selection bounds.
        /// </summary>
        /// <returns></returns>
        public Rect GetSelectionBounds()
        {
            VerifyAccess();

            return InkCanvasSelection.SelectionBounds;
        }

        /// <summary>
        /// provides access to the currently selected elements which are children of this InkCanvas
        /// </summary>
        public ReadOnlyCollection<UIElement> GetSelectedElements()
        {
            VerifyAccess();
            return InkCanvasSelection.SelectedElements;
        }

        /// <summary>
        /// provides read access to the currently selected strokes
        /// </summary>
        public StrokeCollection GetSelectedStrokes()
        {
            VerifyAccess();

            StrokeCollection sc = new StrokeCollection();
            sc.Add(InkCanvasSelection.SelectedStrokes);
            return sc;
        }

        /// <summary>
        /// Overload which calls the more complex version, passing null for selectedElements
        /// </summary>
        /// <param name="selectedStrokes">The strokes to select</param>
        public void Select(StrokeCollection selectedStrokes)
        {
            // No need to invoke VerifyAccess since this call is forwarded.
            Select(selectedStrokes, null);
        }

        /// <summary>
        /// Overload which calls the more complex version, passing null for selectedStrokes
        /// </summary>
        /// <param name="selectedElements">The elements to select</param>
        public void Select(IEnumerable<UIElement> selectedElements)
        {
            // No need to invoke VerifyAccess since this call is forwarded.
            Select(null, selectedElements);
        }

        /// <summary>
        /// Overload which calls the more complex version, passing null for selectedStrokes
        /// </summary>
        /// <param name="selectedStrokes">The strokes to select</param>
        /// <param name="selectedElements">The elements to select</param>
        public void Select(StrokeCollection selectedStrokes, IEnumerable<UIElement> selectedElements)
        {
            VerifyAccess();

            //
            // Try to switch to Select mode first. If we fail to change the mode, then just simply no-op.
            if ( EnsureActiveEditingMode(InkCanvasEditingMode.Select) )
            {
                //
                // validate
                //
                UIElement[] validElements = ValidateSelectedElements(selectedElements);
                StrokeCollection validStrokes = ValidateSelectedStrokes(selectedStrokes);

                //
                // this will raise the 'SelectionChanging' event ONLY if the selection
                // is actually different
                //
                ChangeInkCanvasSelection(validStrokes, validElements);
            }
        }

        /// <summary>
        /// Hit test on the selection
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public InkCanvasSelectionHitResult HitTestSelection(Point point)
        {
            VerifyAccess();

            // Ensure the visual tree.
            if ( _localAdornerDecorator == null )
            {
                ApplyTemplate();
            }

            return InkCanvasSelection.HitTestSelection(point);
        }

        /// <summary>
        /// Copy the current selection in the InkCanvas to the clipboard
        /// </summary>
        public void CopySelection()
        {
            VerifyAccess();
            PrivateCopySelection();
        }

        /// <summary>
        /// Copy the current selection in the InkCanvas to the clipboard and then delete it
        /// </summary>
        public void CutSelection()
        {
            VerifyAccess();

            // Copy first
            InkCanvasClipboardDataFormats copiedDataFormats = PrivateCopySelection();

            // Don't even bother if we don't have a selection.
            if ( copiedDataFormats != InkCanvasClipboardDataFormats.None )
            {
                // Then delete the current selection. Note the XAML format won't be avaliable under Partial
                // Trust. So, the selected element shouldn't be copied or removed.
                DeleteCurrentSelection(
                    /* We want to delete the selected Strokes if there is ISF and/or XAML data being copied */
                    (copiedDataFormats &
                        (InkCanvasClipboardDataFormats.ISF | InkCanvasClipboardDataFormats.XAML)) != 0,
                    /* We only want to delete the selected elements if there is XAML data being copied */
                    (copiedDataFormats & InkCanvasClipboardDataFormats.XAML) != 0);
            }
        }

        /// <summary>
        /// Paste the contents of the clipboard into the InkCanvas
        /// </summary>
        public void Paste()
        {
            // No need to call VerifyAccess since this call is forwarded.

            // We always paste the data to the default location which is (0,0).
            Paste(new Point(c_pasteDefaultLocation, c_pasteDefaultLocation));
        }

        /// <summary>
        /// Paste the contents of the clipboard to the specified location in the InkCanvas
        /// </summary>
        public void Paste(Point point)
        {
            VerifyAccess();

            if (double.IsNaN(point.X) ||
                double.IsNaN(point.Y) ||
                Double.IsInfinity(point.X)||
                Double.IsInfinity(point.Y) )
            {
                    throw new ArgumentException(SR.InvalidPoint, "point");
            }


            //
            // only do this if the user is not editing (input active)
            // or we will violate a dispatcher lock
            //
            if (!_editingCoordinator.UserIsEditing)
            {
                IDataObject dataObj = null;
                try
                {
                    dataObj = Clipboard.GetDataObject();
                }
                catch (ExternalException)
                {
                    //harden against ExternalException
                    return;
                }
                if (dataObj != null)
                {
                    PasteFromDataObject(dataObj, point);
                }
            }
        }

        /// <summary>
        /// Return true if clipboard contents can be pasted into the InkCanvas.
        /// </summary>
        public bool CanPaste()
        {
            VerifyAccess();

            bool ret = false;
            //
            // can't paste if the user is editing (input active)
            // or we will violate a dispatcher lock
            //
            if (_editingCoordinator.UserIsEditing)
            {
                return false;
            }

            ret = PrivateCanPaste();

            return ret;
        }

        #endregion Public Methods

        //------------------------------------------------------
        //
        //  IAddChild Interface
        //
        //------------------------------------------------------

        #region IAddChild Interface

        ///<summary>
        /// Called to Add the object as a Child.
        ///</summary>
        ///<param name="value">
        /// Object to add as a child
        ///</param>
        void IAddChild.AddChild(Object value)
        {
            //             VerifyAccess();

            ArgumentNullException.ThrowIfNull(value);

            ( (IAddChild)InnerCanvas ).AddChild(value);
        }

        ///<summary>
        /// Called when text appears under the tag in markup.
        ///</summary>
        ///<param name="textData">
        /// Text to Add to the Canvas
        ///</param>
        void IAddChild.AddText(string textData)
        {
            //             VerifyAccess();

            ( (IAddChild)InnerCanvas ).AddText(textData);
        }

        #endregion IAddChild Interface

        //------------------------------------------------------
        //
        //  Protected Properties
        //
        //------------------------------------------------------

        #region Protected Properties

        /// <summary>
        /// Returns enumerator to logical children.
        /// </summary>
        protected internal override IEnumerator LogicalChildren
        {
            get
            {
                //        VerifyAccess( );

                // Return the private logical children of the InnerCanvas
                return ( (InkCanvasInnerCanvas)InnerCanvas).PrivateLogicalChildren;
            }
        }

        /// <summary>
        /// Protected DynamicRenderer property.
        /// </summary>
        protected DynamicRenderer DynamicRenderer
        {
            get
            {
                VerifyAccess();
                return InternalDynamicRenderer;
            }
            set
            {
                VerifyAccess();
                if (!object.ReferenceEquals(value, _dynamicRenderer))
                {
                    int previousIndex = -1;
                    //remove the existing plugin
                    if (_dynamicRenderer != null)
                    {
                        //remove the plugin from the collection
                        previousIndex = this.StylusPlugIns.IndexOf(_dynamicRenderer);
                        if (-1 != previousIndex)
                        {
                            this.StylusPlugIns.RemoveAt(previousIndex);
                        }

                        //remove the plugin's visual from the InkPresenter
                        if (this.InkPresenter.ContainsAttachedVisual(_dynamicRenderer.RootVisual))
                        {
                            this.InkPresenter.DetachVisuals(_dynamicRenderer.RootVisual);
                        }
                    }

                    _dynamicRenderer = value;

                    if (_dynamicRenderer != null) //null is acceptable
                    {
                        //remove the plugin from the collection
                        if (!this.StylusPlugIns.Contains(_dynamicRenderer))
                        {
                            if (-1 != previousIndex)
                            {
                                //insert the new DR in the same location as the old one
                                this.StylusPlugIns.Insert(previousIndex, _dynamicRenderer);
                            }
                            else
                            {
                                this.StylusPlugIns.Add(_dynamicRenderer);
                            }
                        }

                        //refer to the same DrawingAttributes as the InkCanvas
                        _dynamicRenderer.DrawingAttributes = this.DefaultDrawingAttributes;

                        //attach the DynamicRenderer if it is not already
                        if (!(this.InkPresenter.ContainsAttachedVisual(_dynamicRenderer.RootVisual)) &&
                            _dynamicRenderer.Enabled &&
                            _dynamicRenderer.RootVisual != null)
                        {
                            this.InkPresenter.AttachVisuals(_dynamicRenderer.RootVisual, this.DefaultDrawingAttributes);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Protected read only access to the InkPresenter this InkCanvas uses
        /// </summary>
        protected InkPresenter InkPresenter
        {
            get
            {
                VerifyAccess();
                if ( _inkPresenter == null )
                {
                    _inkPresenter = new InkPresenter();

                    // Bind the InkPresenter.Strokes to InkCanvas.Strokes
                    Binding strokes = new Binding();
                    strokes.Path = new PropertyPath(InkCanvas.StrokesProperty);
                    strokes.Mode = BindingMode.OneWay;
                    strokes.Source = this;
                    _inkPresenter.SetBinding(InkPresenter.StrokesProperty, strokes);
                }
                return _inkPresenter;
            }
        }

        #endregion Protected Properties

        #region Internal Properties / Methods


        /// <summary>
        /// Deselect the current selection
        /// </summary>
        internal static readonly RoutedCommand DeselectCommand = new RoutedCommand("Deselect", typeof(InkCanvas));

        /// <summary>
        /// UserInitiatedCanPaste
        /// </summary>
        /// <returns></returns>
        private bool UserInitiatedCanPaste()
        {
            return PrivateCanPaste();
        }

        /// <summary>
        /// PrivateCanPaste
        /// </summary>
        /// <returns></returns>
        private bool PrivateCanPaste()
        {
            bool canPaste = false;
            IDataObject dataObj = null;
            try
            {
                dataObj = Clipboard.GetDataObject();
            }
            catch (ExternalException)
            {
                //harden against ExternalException
                return false;
            }
            if ( dataObj != null )
            {
                canPaste = ClipboardProcessor.CheckDataFormats(dataObj);
            }

            return canPaste;
        }

        /// <summary>
        /// This method pastes data from an IDataObject object
        /// </summary>
        internal void PasteFromDataObject(IDataObject dataObj, Point point)
        {
            // Reset the current selection
            ClearSelection(false);

            // Assume that there is nothing to be selected.
            StrokeCollection newStrokes = new StrokeCollection();
            List<UIElement> newElements = new List<UIElement>();

            // Paste the data from the data object.
            if ( !ClipboardProcessor.PasteData(dataObj, ref newStrokes, ref newElements) )
            {
                // Paste was failed.
                return;
            }
            else if ( newStrokes.Count == 0 && newElements.Count == 0 )
            {
                // Nothing has been received from the clipboard.
                return;
            }

            // We add elements here. Then we have to wait for the layout update.
            UIElementCollection children = Children;
            foreach ( UIElement element in newElements )
            {
                children.Add(element);
            }

            if ( newStrokes != null )
            {
                Strokes.Add(newStrokes);
            }

            try
            {
                // We should fire SelectionChanged event if the current editing mode is Select.
                CoreChangeSelection(newStrokes, newElements.ToArray(), EditingMode == InkCanvasEditingMode.Select);
            }
            finally
            {
                // Now move the selection to the desired location.
                Rect bounds = GetSelectionBounds( );
                InkCanvasSelection.CommitChanges(Rect.Offset(bounds, -bounds.Left + point.X, -bounds.Top + point.Y), false);

                if (EditingMode != InkCanvasEditingMode.Select)
                {
                    // Clear the selection without the event if the editing mode is not Select.
                    ClearSelection(false);
                }
            }
        }

        /// <summary>
        /// Copies the InkCanvas contents to a DataObject and returns it to the caller.
        ///  Can return NULL for DataObject.
        /// </summary>
        private InkCanvasClipboardDataFormats CopyToDataObject()
        {
             DataObject dataObj;
            dataObj = new DataObject();
            InkCanvasClipboardDataFormats copiedDataFormats = InkCanvasClipboardDataFormats.None;

            // Try to copy the data from the InkCanvas to the clipboard.
            copiedDataFormats = ClipboardProcessor.CopySelectedData(dataObj);

            if ( copiedDataFormats != InkCanvasClipboardDataFormats.None )
            {
                // Put our data object into the clipboard.
                Clipboard.SetDataObject(dataObj, true);
            }

            return copiedDataFormats;
        }

        /// <summary>
        /// Read-only property of the associated EditingCoordinator.
        /// </summary>
        internal EditingCoordinator EditingCoordinator
        {
            get
            {
                return _editingCoordinator;
            }
        }

        /// <summary>
        /// Internal access to the protected DynamicRenderer.  Can be null.
        /// </summary>
        internal DynamicRenderer InternalDynamicRenderer
        {
            get
            {
                return _dynamicRenderer;
            }
        }

        /// <summary>
        /// Return the inner Canvas.
        /// </summary>
        internal InkCanvasInnerCanvas InnerCanvas
        {
            get
            {
                // We have to create our visual at this point.
                if (_innerCanvas == null)
                {
                    // Create our InnerCanvas to change the logical parent of Canvas' children.
                    _innerCanvas = new InkCanvasInnerCanvas(this);

                    // Bind the inner Canvas' Background to InkCanvas' Background
                    Binding background = new Binding();
                    background.Path = new PropertyPath(InkCanvas.BackgroundProperty);
                    background.Mode = BindingMode.OneWay;
                    background.Source = this;
                    _innerCanvas.SetBinding(Panel.BackgroundProperty, background);
                }

                return _innerCanvas;
            }
        }

        /// <summary>
        /// Internal access to the current selection
        /// </summary>
        internal InkCanvasSelection InkCanvasSelection
        {
            get
            {
                if ( _selection == null )
                {
                    _selection = new InkCanvasSelection(this);
                }

                return _selection;
            }
        }


        /// <summary>
        /// Internal helper called by the LassoSelectionBehavior
        /// </summary>
        internal void BeginDynamicSelection(Visual visual)
        {
            EditingCoordinator.DebugCheckActiveBehavior(EditingCoordinator.LassoSelectionBehavior);

            _dynamicallySelectedStrokes = new StrokeCollection();

            InkPresenter.AttachVisuals(visual, new DrawingAttributes());
        }

        /// <summary>
        /// Internal helper called by LassoSelectionBehavior to update the display
        /// of dynamically added strokes
        /// </summary>
        internal void UpdateDynamicSelection(   StrokeCollection strokesToDynamicallySelect,
                                                StrokeCollection strokesToDynamicallyUnselect)
        {
            EditingCoordinator.DebugCheckActiveBehavior(EditingCoordinator.LassoSelectionBehavior);

            //
            // update our internal stroke collections used by dynamic selection
            //
            if (strokesToDynamicallySelect != null)
            {
                foreach (Stroke s in strokesToDynamicallySelect)
                {
                    _dynamicallySelectedStrokes.Add(s);
                    s.IsSelected = true;
                }
            }

            if (strokesToDynamicallyUnselect != null)
            {
                foreach (Stroke s in strokesToDynamicallyUnselect)
                {
                    System.Diagnostics.Debug.Assert(_dynamicallySelectedStrokes.Contains(s));
                    _dynamicallySelectedStrokes.Remove(s);
                    s.IsSelected = false;
                }
            }
        }

        /// <summary>
        /// Internal helper used by LassoSelectionBehavior
        /// </summary>
        internal StrokeCollection EndDynamicSelection(Visual visual)
        {
            EditingCoordinator.DebugCheckActiveBehavior(EditingCoordinator.LassoSelectionBehavior);

            InkPresenter.DetachVisuals(visual);

            StrokeCollection selectedStrokes = _dynamicallySelectedStrokes;
            _dynamicallySelectedStrokes = null;

            return selectedStrokes;
        }

        /// <summary>
        /// Clears the selection in the ink canvas
        /// and returns a bool indicating if the selection was actually cleared
        /// (developers can cancel selectionchanging)
        ///
        /// If the InkCanvas has no selection, selectionchanging is not raised
        /// and this method returns true
        ///
        /// used by InkEditor during editing operations
        /// </summary>
        /// <returns>true if selection was cleared even after raising selectionchanging</returns>
        internal bool ClearSelectionRaiseSelectionChanging()
        {
            if ( !InkCanvasSelection.HasSelection )
            {
                return true;
            }

            //
            // attempt to clear selection
            //
            ChangeInkCanvasSelection(new StrokeCollection(), new UIElement[]{});

            return !InkCanvasSelection.HasSelection;
        }

        /// <summary>
        /// ClearSelection
        ///     Called by:
        ///         PasteFromDataObject
        ///         EditingCoordinator.UpdateEditingState
        /// </summary>
        internal void ClearSelection(bool raiseSelectionChangedEvent)
        {
            if ( InkCanvasSelection.HasSelection )
            {
                // Reset the current selection
                CoreChangeSelection(new StrokeCollection(), new UIElement[] { }, raiseSelectionChangedEvent);
            }
        }


        /// <summary>
        /// Helper that creates selection for an InkCanvas.  Used by the SelectedStrokes and
        /// SelectedElements properties
        /// </summary>
        internal void ChangeInkCanvasSelection(StrokeCollection strokes, UIElement[] elements)
        {
            //validate in debug only for this internal static
            Debug.Assert(strokes != null
                        && elements != null,
                        "Invalid arguments in ChangeInkCanvasSelection");

            bool strokesAreDifferent;
            bool elementsAreDifferent;
            InkCanvasSelection.SelectionIsDifferentThanCurrent(strokes, out strokesAreDifferent, elements, out elementsAreDifferent);
            if ( strokesAreDifferent || elementsAreDifferent )
            {
                InkCanvasSelectionChangingEventArgs args = new InkCanvasSelectionChangingEventArgs(strokes, elements);

                StrokeCollection validStrokes = strokes;
                UIElement[] validElements = elements;

                this.RaiseSelectionChanging(args);

                //now that the event has been raised and all of the delegates
                //have had their way with it, process the result
                if ( !args.Cancel )
                {
                    //
                    // rock and roll, time to validate our arguments
                    // note: these event args are visible outside the apis,
                    // so we need to validate them again
                    //

                    // PERF-2006/05/02-WAYNEZEN,
                    // Check our internal flag. If the SelectedStrokes has been changed, we shouldn't do any extra work here.
                    if ( args.StrokesChanged )
                    {
                        validStrokes = ValidateSelectedStrokes(args.GetSelectedStrokes());
                        int countOldSelectedStrokes = strokes.Count;
                        for ( int i = 0; i < countOldSelectedStrokes; i++ )
                        {
                            // PERF-2006/05/02-WAYNEZEN,
                            // We only have to reset IsSelected for the elements no longer exists in the new collection.
                            if ( !validStrokes.Contains(strokes[i]) )
                            {
                                //
                                // Make sure we reset the IsSelected property which could have been
                                // set to true in the dynamic selection.
                                strokes[i].IsSelected = false;
                            }
                        }
                    }


                    // PERF-2006/05/02-WAYNEZEN,
                    // Check our internal flag. If the SelectedElements has been changed, we shouldn't do any extra work here.
                    if ( args.ElementsChanged )
                    {
                        validElements = ValidateSelectedElements(args.GetSelectedElements());
                    }

                    CoreChangeSelection(validStrokes, validElements, true);
                }
                else
                {
                    StrokeCollection currentSelectedStrokes = InkCanvasSelection.SelectedStrokes;
                    int countOldSelectedStrokes = strokes.Count;
                    for ( int i = 0; i < countOldSelectedStrokes; i++ )
                    {
                        // Make sure we reset the IsSelected property which could have been
                        // set to true in the dynamic selection but not being selected previously.
                        if ( !currentSelectedStrokes.Contains(strokes[i]) )
                        {
                            strokes[i].IsSelected = false;
                        }
                    }
                }
            }
        }


        /// <summary>
        /// Helper method used by ChangeInkCanvasSelection and directly by ClearSelectionWithoutSelectionChanging
        /// </summary>
        /// <param name="validStrokes">validStrokes</param>
        /// <param name="validElements">validElements</param>
        /// <param name="raiseSelectionChanged">raiseSelectionChanged</param>
        private void CoreChangeSelection(StrokeCollection validStrokes, IList<UIElement> validElements, bool raiseSelectionChanged)
        {
            InkCanvasSelection.Select(validStrokes, validElements, raiseSelectionChanged);
        }

#if DEBUG_LASSO_FEEDBACK
        internal ContainerVisual RendererRootContainer
        {
            get {return _inkContainerVisual;}
        }
#endif


        /// <summary>
        /// Private helper method used to retrieve a StrokeCollection which does AND operation on two input collections.
        /// </summary>
        /// <param name="subset">The possible subset</param>
        /// <param name="superset">The container set</param>
        /// <returns>True if subset is a subset of superset, false otherwise</returns>
        internal static StrokeCollection GetValidStrokes(StrokeCollection subset, StrokeCollection superset)
        {
            StrokeCollection validStrokes = new StrokeCollection();

            int subsetCount = subset.Count;

            // special case an empty subset as a guaranteed subset
            if ( subsetCount == 0 )
            {
                return validStrokes;
            }

            for ( int i = 0; i < subsetCount; i++ )
            {
                Stroke stroke = subset[i];
                if ( superset.Contains(stroke) )
                {
                    validStrokes.Add(stroke);
                }
            }

            return validStrokes;
        }

        /// <summary>
        /// Register the commanding handlers for the clipboard operations
        /// </summary>
        private static void _RegisterClipboardHandlers()
        {
            Type ownerType = typeof(InkCanvas);

            CommandHelpers.RegisterCommandHandler(ownerType, ApplicationCommands.Cut,
                new ExecutedRoutedEventHandler(_OnCommandExecuted), new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled),
                KeyGesture.CreateFromResourceStrings(KeyShiftDelete, nameof(SR.KeyShiftDeleteDisplayString)));
            CommandHelpers.RegisterCommandHandler(ownerType, ApplicationCommands.Copy,
                new ExecutedRoutedEventHandler(_OnCommandExecuted), new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled),
                KeyGesture.CreateFromResourceStrings(KeyCtrlInsert, nameof(SR.KeyCtrlInsertDisplayString)));

            // Use temp variables to reduce code under elevation
            ExecutedRoutedEventHandler pasteExecuteEventHandler = new ExecutedRoutedEventHandler(_OnCommandExecuted);
            CanExecuteRoutedEventHandler pasteQueryEnabledEventHandler = new CanExecuteRoutedEventHandler(_OnQueryCommandEnabled);
            InputGesture pasteInputGesture = KeyGesture.CreateFromResourceStrings(KeyShiftInsert, SR.KeyShiftInsertDisplayString);

            CommandHelpers.RegisterCommandHandler(ownerType, ApplicationCommands.Paste,
                pasteExecuteEventHandler, pasteQueryEnabledEventHandler, pasteInputGesture);
        }

        /// <summary>
        /// Private helper used to ensure that any stroke collection
        /// passed to the InkCanvas is valid.  Throws exceptions if the argument is invalid
        /// </summary>
        private StrokeCollection ValidateSelectedStrokes(StrokeCollection strokes)
        {
            //
            //  null is a valid input
            //
            if (strokes == null)
            {
                return new StrokeCollection();
            }
            else
            {
                return GetValidStrokes(strokes, this.Strokes);
            }
        }

        /// <summary>
        /// Private helper used to ensure that a UIElement argument passed in
        /// is valid.
        /// </summary>
        private UIElement[] ValidateSelectedElements(IEnumerable<UIElement> selectedElements)
        {
            if (selectedElements == null)
            {
                return new UIElement[]{};
            }

            List<UIElement> elements = new List<UIElement>();
            foreach (UIElement element in selectedElements)
            {
                //
                // Don't add the duplicated element.
                if ( !elements.Contains(element) )
                {
                    //
                    // check the common case first, e
                    //
                    if ( InkCanvasIsAncestorOf(element) )
                    {
                        elements.Add(element);
                    }
                }
            }

            return elements.ToArray();
        }

        /// <summary>
        /// Helper method used by DesignActivation to see if an element
        /// has this InkCanvas as an Ancestor
        /// </summary>
        private bool InkCanvasIsAncestorOf(UIElement element)
        {
            if (this != element && this.IsAncestorOf(element))
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// Handler called whenever changes are made to properties of the DefaultDrawingAttributes
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        /// <remarks>For example, when a developer changes the Color property on the DefaultDrawingAttributes,
        /// this event will fire - allowing the InkCanvas a chance to notify the BasicRTI Service.
        /// Also - we do not currently call through the DefaultDrawingAttributes setter since
        /// parameter validation in the setter may detect if the reference isn't changing, and ignore
        /// the call. Also - there is no need for extra parameter validation.</remarks>
        private void DefaultDrawingAttributes_Changed(object sender, PropertyDataChangedEventArgs args)
        {
            // note that sender should be the same as _defaultDrawingAttributes
            // If a developer writes code to change the DefaultDrawingAttributes inside of the event
            //      handler before the InkCanvas receives the notification (multi-cast delegate scenario) -
            //      The DefaultDrawingAttributes should still be updated, and in that case we would
            //      update the RTI DAC twice. Typically, however, this will just refresh the
            //      attributes in the RTI thread.
            System.Diagnostics.Debug.Assert(object.ReferenceEquals(sender, DefaultDrawingAttributes));

            InvalidateSubProperty(DefaultDrawingAttributesProperty);

            // Be sure to update the RealTimeInking PlugIn with the drawing attribute changes.
            UpdateDynamicRenderer();

            // Invalidate the inking cursor
            _editingCoordinator.InvalidateBehaviorCursor(_editingCoordinator.InkCollectionBehavior);
        }

        /// <summary>
        /// Helper method used to set up the DynamicRenderer.
        /// </summary>
        internal void UpdateDynamicRenderer()
        {
            UpdateDynamicRenderer(DefaultDrawingAttributes);
        }
        /// <summary>
        /// Helper method used to set up the DynamicRenderer.
        /// </summary>
        private void UpdateDynamicRenderer(DrawingAttributes newDrawingAttributes)
        {
            ApplyTemplate();

            if (this.DynamicRenderer != null)
            {
                this.DynamicRenderer.DrawingAttributes = newDrawingAttributes;

                if (!this.InkPresenter.AttachedVisualIsPositionedCorrectly(this.DynamicRenderer.RootVisual, newDrawingAttributes))
                {
                    if (this.InkPresenter.ContainsAttachedVisual(this.DynamicRenderer.RootVisual))
                    {
                        this.InkPresenter.DetachVisuals(this.DynamicRenderer.RootVisual);
                    }

                    // Only hook up if we are enabled.  As we change editing modes this routine will be called
                    // to clean up things.
                    if (this.DynamicRenderer.Enabled && this.DynamicRenderer.RootVisual != null)
                    {
                        this.InkPresenter.AttachVisuals(this.DynamicRenderer.RootVisual, newDrawingAttributes);
                    }
                }
            }
        }

        private bool EnsureActiveEditingMode(InkCanvasEditingMode newEditingMode)
        {
            bool ret = true;

            if ( ActiveEditingMode != newEditingMode )
            {
                if ( EditingCoordinator.IsStylusInverted )
                {
                    EditingModeInverted = newEditingMode;
                }
                else
                {
                    EditingMode = newEditingMode;
                }

                // Verify whether user has cancelled the change in EditingModeChanging event.
                ret = ( ActiveEditingMode == newEditingMode );
            }

            return ret;
        }

        // The ClipboardProcessor instance which deals with the operations relevant to the clipboard.
        private ClipboardProcessor ClipboardProcessor
        {
            get
            {
                if ( _clipboardProcessor == null )
                {
                    _clipboardProcessor = new ClipboardProcessor(this);
                }

                return _clipboardProcessor;
            }
        }

        //lazy instance the gesture recognizer
        private GestureRecognizer GestureRecognizer
        {
            get
            {
                if (_gestureRecognizer == null)
                {
                    _gestureRecognizer = new GestureRecognizer();
                }
                return _gestureRecognizer;
            }
        }

        /// <summary>
        /// Delete the current selection
        /// </summary>
        private void DeleteCurrentSelection(bool removeSelectedStrokes, bool removeSelectedElements)
        {
            Debug.Assert(removeSelectedStrokes || removeSelectedElements, "At least either Strokes or Elements should be removed!");

            // Now delete the current selection.
            StrokeCollection strokes = GetSelectedStrokes();
            IList<UIElement> elements = GetSelectedElements();

            // Clear the selection first.
            CoreChangeSelection(
                removeSelectedStrokes ? new StrokeCollection() : strokes,
                removeSelectedElements ? new List<UIElement>() : elements,
                true);

            // Remove the ink.
            if ( removeSelectedStrokes && strokes != null && strokes.Count != 0 )
            {
                Strokes.Remove(strokes);
            }

            // Remove the elements.
            if ( removeSelectedElements )
            {
                UIElementCollection children = Children;
                foreach ( UIElement element in elements )
                {
                    children.Remove(element);
                }
            }
        }

        /// <summary>
        /// A class handler of the Commands
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private static void _OnCommandExecuted(object sender, ExecutedRoutedEventArgs args)
        {
            ICommand command = args.Command;
            InkCanvas inkCanvas = sender as InkCanvas;

            Debug.Assert(inkCanvas != null);

            if ( inkCanvas.IsEnabled && !inkCanvas.EditingCoordinator.UserIsEditing )
            {
                if ( command == ApplicationCommands.Delete )
                {
                    inkCanvas.DeleteCurrentSelection(true, true);
                }
                else if ( command == ApplicationCommands.Cut )
                {
                    inkCanvas.CutSelection();
                }
                else if ( command == ApplicationCommands.Copy )
                {
                    inkCanvas.CopySelection();
                }
                else if ( command == ApplicationCommands.SelectAll )
                {
                    if ( inkCanvas.ActiveEditingMode == InkCanvasEditingMode.Select )
                    {
                        IEnumerable<UIElement> children = null;
                        UIElementCollection uiElementCollection = inkCanvas.Children;
                        if ( uiElementCollection.Count > 0 )
                        {
                            //UIElementCollection doesn't implement IEnumerable<UIElement>
                            //for some reason
                            UIElement[] uiElementArray = new UIElement[uiElementCollection.Count];
                            for ( int i = 0; i < uiElementCollection.Count; i++ )
                            {
                                uiElementArray[i] = uiElementCollection[i];
                            }
                            children = uiElementArray;
                        }
                        inkCanvas.Select(inkCanvas.Strokes, children);
                    }
                }
                else if ( command == ApplicationCommands.Paste )
                {
                    try
                    {
                        inkCanvas.Paste();
                    }
                    // Eat it and do nothing if one of the following exceptions is caught.
                    catch ( System.Runtime.InteropServices.COMException )
                    {
                        // The window may be destroyed which could cause the opening failed..
                    }
                    catch ( XamlParseException )
                    {
                        // The Xaml parser fails
                    }
                    catch ( ArgumentException )
                    {
                        // The ISF decoder fails
                    }
                }
                else if ( command == InkCanvas.DeselectCommand )
                {
                    inkCanvas.ClearSelectionRaiseSelectionChanging();
                }
            }
        }

        /// <summary>
        /// A class handler for querying the enabled status of the commands.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private static void _OnQueryCommandEnabled(object sender, CanExecuteRoutedEventArgs args)
        {
            RoutedCommand command = (RoutedCommand)(args.Command);
            InkCanvas inkCanvas = sender as InkCanvas;

            Debug.Assert(inkCanvas != null);

            if ( inkCanvas.IsEnabled
                //
                // If user is editing, we should disable all commands.
                && !inkCanvas.EditingCoordinator.UserIsEditing )
            {
                if ( command == ApplicationCommands.Delete
                    || command == ApplicationCommands.Cut
                    || command == ApplicationCommands.Copy
                    || command == InkCanvas.DeselectCommand )
                {
                    args.CanExecute = inkCanvas.InkCanvasSelection.HasSelection;
                }
                else if ( command == ApplicationCommands.Paste )
                {
                    try
                    {
                        args.CanExecute = args.UserInitiated
                                            ? inkCanvas.UserInitiatedCanPaste() /* Call UserInitiatedCanPaste when the query is initiated by user */
                                            : inkCanvas.CanPaste() /* Call the public CanPaste if not */;
                    }
                    catch ( System.Runtime.InteropServices.COMException )
                    {
                        // The window may be destroyed which could cause the opening failed..
                        // Eat the exception and do nothing.
                        args.CanExecute = false;
                    }
                }
                else if ( command == ApplicationCommands.SelectAll )
                {
                    //anything to select?
                    args.CanExecute = ( inkCanvas.ActiveEditingMode == InkCanvasEditingMode.Select
                                            && (inkCanvas.Strokes.Count > 0 || inkCanvas.Children.Count > 0));
                }
            }
            else
            {
                //
                // Return false for CanExecute if InkCanvas is disabled.
                args.CanExecute = false;
            }

            //
            // Mark Handled as true so that the clipboard commands stops routing to InkCanvas' ancestors.
            if ( command == ApplicationCommands.Cut || command == ApplicationCommands.Copy
                || command == ApplicationCommands.Paste )
            {
                args.Handled = true;
            }
        }

        private InkCanvasClipboardDataFormats PrivateCopySelection()
        {
            InkCanvasClipboardDataFormats copiedDataFormats = InkCanvasClipboardDataFormats.None;

            // Don't even bother if we don't have a selection or UserIsEditing has been set.
            if ( InkCanvasSelection.HasSelection && !_editingCoordinator.UserIsEditing)
            {
                copiedDataFormats = CopyToDataObject();
            }

            return copiedDataFormats;
        }


        /// <summary>
        /// _OnDeviceDown
        /// </summary>
        /// <typeparam name="TEventArgs"></typeparam>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void _OnDeviceDown<TEventArgs>(object sender, TEventArgs e)
            where TEventArgs : InputEventArgs
        {
            ( (InkCanvas)sender ).EditingCoordinator.OnInkCanvasDeviceDown(sender, e);
        }

        /// <summary>
        /// _OnDeviceUp
        /// </summary>
        /// <typeparam name="TEventArgs"></typeparam>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void _OnDeviceUp<TEventArgs>(object sender, TEventArgs e)
            where TEventArgs : InputEventArgs
        {
            ((InkCanvas)sender).EditingCoordinator.OnInkCanvasDeviceUp(sender, e);
        }

        /// <summary>
        /// _OnQueryCursor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void _OnQueryCursor(object sender, QueryCursorEventArgs e)
        {
            InkCanvas inkCanvas = (InkCanvas)sender;

            if ( inkCanvas.UseCustomCursor )
            {
                // If UseCustomCursor is set, we bail out. Let the base class (FrameworkElement) to do the rest.
                return;
            }

            // We should behave like our base - honor ForceCursor property.
            if ( !e.Handled || inkCanvas.ForceCursor )
            {
                Cursor cursor = inkCanvas.EditingCoordinator.GetActiveBehaviorCursor();

                // If cursor is null, we don't handle the event and leave it as whatever the default is.
                if ( cursor != null )
                {
                    e.Cursor = cursor;
                    e.Handled = true;
                }
            }
        }

        /// <summary>
        /// Update the current cursor if mouse is over InkCanvas. Called by
        ///     EditingCoordinator.InvalidateBehaviorCursor
        ///     EditingCoordinator.UpdateEditingState
        ///     InkCanvas.set_UseCustomCursor
        /// </summary>
        internal void UpdateCursor()
        {
            if ( IsMouseOver )
            {
                Mouse.UpdateCursor();
            }
        }

        #endregion Private Properties / Methods

        //------------------------------------------------------
        //
        //  Private Classes
        //
        //------------------------------------------------------

        #region Private Classes


        /// <summary>
        /// A helper class for RTI high contrast support
        /// </summary>
        private class RTIHighContrastCallback : HighContrastCallback
        {
            //------------------------------------------------------
            //
            //  Cnostructors
            //
            //------------------------------------------------------

            #region Constructors

            internal RTIHighContrastCallback(InkCanvas inkCanvas)
            {
                _thisInkCanvas = inkCanvas;
            }

            private RTIHighContrastCallback() { }

            #endregion Constructors

            //------------------------------------------------------
            //
            //  Internal Methods
            //
            //------------------------------------------------------

            #region Internal Methods

            /// <summary>
            /// TurnHighContrastOn
            /// </summary>
            /// <param name="highContrastColor"></param>
            internal override void TurnHighContrastOn(Color highContrastColor)
            {
                // The static strokes already have been taken care of by InkPresenter.
                // We only update the RTI renderer here.
                DrawingAttributes highContrastDa = _thisInkCanvas.DefaultDrawingAttributes.Clone();
                highContrastDa.Color = highContrastColor;
                _thisInkCanvas.UpdateDynamicRenderer(highContrastDa);
            }

            /// <summary>
            /// TurnHighContrastOff
            /// </summary>
            internal override void TurnHighContrastOff()
            {
                // The static strokes already have been taken care of by InkPresenter.
                // We only update the RTI renderer here.
                _thisInkCanvas.UpdateDynamicRenderer(_thisInkCanvas.DefaultDrawingAttributes);
            }

            #endregion Internal Methods

            //------------------------------------------------------
            //
            //  Internal Properties
            //
            //------------------------------------------------------

            #region Internal Properties

            /// <summary>
            /// Returns the dispatcher if the object is associated to a UIContext.
            /// </summary>
            internal override Dispatcher Dispatcher
            {
                get
                {
                    return _thisInkCanvas.Dispatcher;
                }
            }

            #endregion Internal Properties

            //------------------------------------------------------
            //
            //  Private Fields
            //
            //------------------------------------------------------

            #region Private Fields

            private InkCanvas _thisInkCanvas;

            #endregion Private Fields
        }

        /// <summary>
        /// This is a binding converter which translates the InkCanvas.ActiveEditingMode to UIElement.Visibility.
        /// </summary>
        private class ActiveEditingMode2VisibilityConverter : IValueConverter
        {
            public object Convert(object o, Type type, object parameter, System.Globalization.CultureInfo culture)
            {
                InkCanvasEditingMode activeMode = (InkCanvasEditingMode)o;

                // If the current EditingMode is the mode which menuitem is expecting, return true for IsChecked.
                if ( activeMode != InkCanvasEditingMode.None )
                {
                    return Visibility.Visible;
                }
                else
                {
                    return Visibility.Collapsed;
                }
            }

            public object ConvertBack(object o, Type type, object parameter, System.Globalization.CultureInfo culture)
            {
                // Non-reversed convertion
                return null;
            }
        }

        #endregion Private Classes

        #region Private Members

        /// <summary>
        /// The element that represents the selected ink strokes, if any exist.  Will frequently be null.
        /// </summary>
        private InkCanvasSelection          _selection = null;
        private InkCanvasSelectionAdorner   _selectionAdorner = null;
        private InkCanvasFeedbackAdorner    _feedbackAdorner = null;

        /// <summary>
        /// The internal Canvas used to hold elements
        /// </summary>
        private InkCanvasInnerCanvas        _innerCanvas = null;

        /// <summary>
        /// The internal private AdornerDecorator
        /// </summary>
        private AdornerDecorator            _localAdornerDecorator = null;

        /// <summary>
        /// Runtime Selection StrokeCollection
        /// </summary>
        private StrokeCollection            _dynamicallySelectedStrokes;

        /// <summary>
        /// Our editing logic
        /// </summary>
        private EditingCoordinator          _editingCoordinator;

        /// <summary>
        /// Defines the default StylusPointDescription
        /// </summary>
        private StylusPointDescription     _defaultStylusPointDescription;


        /// <summary>
        /// Defines the shape of the eraser tip
        /// </summary>
        private StylusShape                 _eraserShape;

        /// <summary>
        /// Determines if EditingBehaviors should use their own cursor or a custom one specified.
        /// </summary>
        private bool                        _useCustomCursor = false;


        //
        // Rendering support.
        //
        private InkPresenter                _inkPresenter;

        //
        // The RealTimeInking PlugIn that handles our off UIContext rendering.
        //
        private DynamicRenderer             _dynamicRenderer;

        //
        // Clipboard Helper
        //
        private ClipboardProcessor          _clipboardProcessor;

        //
        // Gesture support
        //
        private GestureRecognizer           _gestureRecognizer;

        //
        // HighContrast support
        //
        private RTIHighContrastCallback     _rtiHighContrastCallback;

        private const double                    c_pasteDefaultLocation = 0.0;

        private const string InkCanvasDeselectKey   = "Esc";
        private const string KeyCtrlInsert = "Ctrl+Insert";
        private const string KeyShiftInsert = "Shift+Insert";
        private const string KeyShiftDelete = "Shift+Delete";

        #endregion Private Members
    }
}


