//-------------------------------------------------------------------------------
        //
        // Protected Methods
        //
        //-------------------------------------------------------------------------------

        #region Protected Methods

        /// <summary>
        /// Overrides SwitchToMode
        /// As the following expected results
        ///  1. From Ink To InkAndGesture
        ///     Packets between StylusDown and StylusUp are sent to the gesture reco. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
        ///  2. From Ink To GestureOnly
        ///     Packets between StylusDown and StylusUp are send to the gesture reco. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if it’s not a gesture.
        ///  3. From Ink To EraseByPoint
        ///     Stroke is discarded. PointErasing is performed after changing the mode.
        ///  4. From Ink To EraseByStroke
        ///      Stroke is discarded. StrokeErasing is performed after changing the mode.
        ///  5. From Ink To Select
        ///     Stroke is discarded. Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
        ///  6. From Ink To None
        ///     Stroke is discarded.
        ///  7. From InkAndGesture To Ink
        ///     Stroke is collected for all packets between StylusDown and StylusUp. Gesture event does not fire.
        ///  8. From InkAndGesture To GestureOnly
        ///     Packets between StylusDown and StylusUp are sent to the gesture reco. Stroke gets removed on StylusUp even if it’s not a gesture.
        ///  9. From InkAndGesture To EraseByPoint
        ///     Stroke is discarded. PointErasing is performed after changing the mode, gesture event does not fire.
        /// 10. From InkAndGesture To EraseByStroke
        ///     Stroke is discarded. StrokeErasing is performed after changing the mode, gesture event does not fire.
        /// 11. From InkAndGesture To Select
        ///     Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
        /// 12. From InkAndGesture To None
        ///     Stroke is discarded, no gesture is recognized.
        /// 13. From GestureOnly To InkAndGesture
        ///     Packets between StylusDown and StylusUp are sent to the gesture reco. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
        /// 14. From GestureOnly To Ink
        ///     Stroke is collected. Gesture event does not fire.
        /// 15. From GestureOnly To EraseByPoint
        ///     Stroke is discarded PointErasing is performed after changing the mode, gesture event does not fire
        /// 16. From GestureOnly To EraseByStroke
        ///     Stroke is discarded. StrokeErasing is performed after changing the mode, gesture event does not fire.
        /// 17. From GestureOnly To Select
        ///     Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
        /// 18. From GestureOnly To None
        ///     Stroke is discarded. Gesture event does not fire.
        /// </summary>
        /// <param name="mode"></param>
        protected override void OnSwitchToMode(InkCanvasEditingMode mode)
        {
            Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");

            switch (mode)
            {
            case InkCanvasEditingMode.Ink:
            case InkCanvasEditingMode.InkAndGesture:
            case InkCanvasEditingMode.GestureOnly:
            {
                // We are under one of those Ink modes now. Nothing to change here except raising the mode change event.
                InkCanvas.RaiseActiveEditingModeChanged(new RoutedEventArgs(InkCanvas.ActiveEditingModeChangedEvent, InkCanvas));
                break;
            }

            case InkCanvasEditingMode.EraseByPoint:
            case InkCanvasEditingMode.EraseByStroke:
            {
                // Discard the collected ink.
                Commit(false);

                // Change the Erase mode
                EditingCoordinator.ChangeStylusEditingMode(this, mode);
                break;
            }

            case InkCanvasEditingMode.Select:
            {
                // Make a copy of the current cached points.
                StylusPointCollection cachedPoints = _stylusPoints != null?
                                                     _stylusPoints.Clone() : null;

                // Discard the collected ink.
                Commit(false);

                // Change the Select mode
                IStylusEditing newBehavior = EditingCoordinator.ChangeStylusEditingMode(this, mode);

                if (cachedPoints != null
                    // NOTICE-2006/04/27-WAYNEZEN,
                    // EditingCoordinator.ChangeStylusEditingMode raises external event.
                    // The user code could take any arbitrary action for instance calling InkCanvas.ReleaseMouseCapture()
                    // So there is no guarantee that we could receive the newBehavior.
                    && newBehavior != null)
                {
                    // Now add the previous points to the lasso behavior
                    // The SelectionBehavior doesn't check userInitiated, pass false
                    // even if our _userInitiated flag is true
                    newBehavior.AddStylusPoints(cachedPoints, false /*userInitiated*/);
                }

                break;
            }

            case InkCanvasEditingMode.None:
            {
                // Discard the collected ink.
                Commit(false);

                // Change to the None mode
                EditingCoordinator.ChangeStylusEditingMode(this, mode);
                break;
            }

            default:
                Debug.Assert(false, "Unknown InkCanvasEditingMode!");
                break;
            }
        }