重新想象 Windows 8 Store Apps (51) - 输入: 涂鸦板

<Page

    x:Class="XamlDemo.Input.Ink.Simple"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:local="using:XamlDemo.Input.Ink"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d">

    <Grid Background="Transparent">

        <StackPanel Margin="120 0 0 0">

            <Button Name="btnClear" Content="清除" Click="btnClear_Click_1" />

            <Canvas Name="canvas" Background="Blue" Width="800" Height="480" HorizontalAlignment="Left" Margin="0 10 0 0" />

        </StackPanel>

    </Grid>

</Page>

/*

 * 通过 Pointer 相关事件实现一个只有基本功能的涂鸦板

 */

using System;

using System.Collections.Generic;

using Windows.Foundation;

using Windows.UI;

using Windows.UI.Input;

using Windows.UI.Xaml;

using Windows.UI.Xaml.Controls;

using Windows.UI.Xaml.Input;

using Windows.UI.Xaml.Media;

using Windows.UI.Xaml.Shapes;

namespace XamlDemo.Input.Ink

{

    public sealed partial class Simple : Page

    {

        // 用于保存触摸点（PointerId - Point）

        private Dictionary<uint, Point?> _dicPoint;

        public Simple()

        {

            this.InitializeComponent();

            canvas.PointerPressed += canvas_PointerPressed;

            canvas.PointerMoved += canvas_PointerMoved;

            canvas.PointerReleased += canvas_PointerReleased;

            canvas.PointerExited += canvas_PointerExited;

            _dicPoint = new Dictionary<uint, Point?>();

        }

        void canvas_PointerPressed(object sender, PointerRoutedEventArgs e)

        {

            // 指针按下后，保存此触摸点

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            _dicPoint[pointerPoint.PointerId] = pointerPoint.Position;

        }

        void canvas_PointerMoved(object sender, PointerRoutedEventArgs e)

        {

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            if (_dicPoint.ContainsKey(pointerPoint.PointerId) && _dicPoint[pointerPoint.PointerId].HasValue)

            {

                Point currentPoint = pointerPoint.Position;

                Point previousPoint = _dicPoint[pointerPoint.PointerId].Value;

                // 如果指针移动过程中，两个点间的距离超过 4 则在两点间绘制一条直线，以完成涂鸦

                if (ComputeDistance(currentPoint, previousPoint) > )

                {

                    Line line = new Line()

                    {

                        X1 = previousPoint.X,

                        Y1 = previousPoint.Y,

                        X2 = currentPoint.X,

                        Y2 = currentPoint.Y,

                        StrokeThickness = ,

                        Stroke = new SolidColorBrush(Colors.Orange),

                        StrokeEndLineCap = PenLineCap.Round

                    };

                    _dicPoint[pointerPoint.PointerId] = currentPoint;

                    canvas.Children.Add(line);

                }

            }

        }

        void canvas_PointerReleased(object sender, PointerRoutedEventArgs e)

        {

            // 指针释放后，从字典中删除此 PointerId 的数据

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            if (_dicPoint.ContainsKey(pointerPoint.PointerId))

                _dicPoint.Remove(pointerPoint.PointerId);

        }

        void canvas_PointerExited(object sender, PointerRoutedEventArgs e)

        {

            // 指针离开相当于指针释放

            canvas_PointerReleased(sender, e);

        }

        // 清除涂鸦

        private void btnClear_Click_1(object sender, RoutedEventArgs e)

        {

            canvas.Children.Clear();

            _dicPoint.Clear();

        }

        // 计算两个点（Point）之间的距离

        private double ComputeDistance(Point point1, Point point2)

        {

            return Math.Sqrt(Math.Pow(point1.X - point2.X, ) + Math.Pow(point1.Y - point2.Y, ));

        }

    }

}

/*

 * 开发一个 InkRenderer 类，用于呈现 InkManager 中的内容

 *

 * 注：InkManager 用于 ink 的管理，但并不负责呈现

 *

 *

 * InkStroke - ink 画笔

 *     DrawingAttributes - 画笔的相关属性，一个 InkDrawingAttributes 类型的对象

 *         Color - 颜色

 *         FitToCurve - 使用贝塞尔曲线则为 true，使用直线则为 false，默认值为 true

 *         PenTip - 笔尖的形状（Circle, Rectangle）

 *         Size - 笔尖的尺寸

 *         IgnorePressure - 是否忽略笔尖在触摸屏上的压力

 *     BoundingRect - ink 画笔的边界框

 *     Recognized - 该画笔是否已被文字识别

 *     Selected - 该画笔是否被选中

 *     Clone() - 克隆这个画笔，并返回克隆后的新的 InkStroke 对象

 *     GetRenderingSegments() - 返回 ink 的线段集合，即 InkStrokeRenderingSegment 集合

 *

 * InkStrokeRenderingSegment - ink 的线段

 *     BezierControlPoint1 - 贝塞尔曲线的第一个控制点的位置

 *     BezierControlPoint2 - 贝塞尔曲线的第二个控制点的位置

 *     Position - 贝塞尔曲线的终点的位置

 */

using System.Collections.Generic;

using Windows.UI;

using Windows.UI.Input;

using Windows.UI.Input.Inking;

using Windows.UI.Xaml.Controls;

using Windows.UI.Xaml.Media;

using Windows.UI.Xaml.Shapes;

namespace XamlDemo.Input.Ink

{

    public class InkRenderer

    {

        /// <summary>

        /// 呈现 ink 的容器

        /// </summary>

        private readonly Panel _container = null;

        /// <summary>

        /// ink 的实时路径（PointerId - Path）

        /// </summary>

        private readonly Dictionary<uint, Path> _dicLivePath = null;

        /// <summary>

        /// ink 的实时路径中所包含的 PolyLineSegment（PointerId - PolyLineSegment）

        /// </summary>

        private readonly Dictionary<uint, PolyLineSegment> _dicLivePolyLine = null;

        /// <summary>

        /// InkStroke 所对应三次贝塞尔曲线，用于保存全部涂鸦曲线（包括未被选中的和被选中的）

        /// </summary>

        private readonly Dictionary<InkStroke, Path> _dicInkPath = null;

        /// <summary>

        /// InkStroke 所对应三次贝塞尔曲线，用于保存被选中的涂鸦曲线

        /// </summary>

        private readonly Dictionary<InkStroke, Path> _dicSelectionPath = null;

        /// <summary>

        /// 构造函数

        /// </summary>

        /// <param name="panel">用于呈现 ink 的容器</param>

        public InkRenderer(Panel panel)

        {

            _container = panel;

            _dicLivePath = new Dictionary<uint, Path>();

            _dicLivePolyLine = new Dictionary<uint, PolyLineSegment>();

            _dicInkPath = new Dictionary<InkStroke, Path>();

            _dicSelectionPath = new Dictionary<InkStroke, Path>();

        }

        /// <summary>

        /// 开始实时绘制 ink

        /// </summary>

        /// <param name="pointerPoint">当前的触摸点</param>

        /// <param name="inkDrawingAttributes">ink 的 InkDrawingAttributes 数据</param>

        public void EnterLiveRendering(PointerPoint pointerPoint, InkDrawingAttributes inkDrawingAttributes)

        {

            uint pointerId = pointerPoint.PointerId;

            var polyLine = new PolyLineSegment();

            polyLine.Points.Add(pointerPoint.Position);

            var figure = new PathFigure();

            figure.StartPoint = pointerPoint.Position;

            figure.Segments.Add(polyLine);

            var geometry = new PathGeometry();

            geometry.Figures.Add(figure);

            var path = new Path();

            path.Data = geometry;

            path.Stroke = new SolidColorBrush(inkDrawingAttributes.Color);

            path.StrokeThickness = inkDrawingAttributes.Size.Width;

            path.StrokeLineJoin = PenLineJoin.Round;

            path.StrokeStartLineCap = PenLineCap.Round;

            _dicLivePolyLine.Add(pointerId, polyLine);

            _dicLivePath.Add(pointerId, path);

            _container.Children.Add(path);

        }

        /// <summary>

        /// 更新 ink 的实时绘制

        /// </summary>

        /// <param name="pointerPoint"></param>

        public void UpdateLiveRender(PointerPoint pointerPoint)

        {

            uint pointerId = pointerPoint.PointerId;

            _dicLivePolyLine[pointerId].Points.Add(pointerPoint.Position);

        }

        /// <summary>

        /// 停止此次 ink 的实时绘制

        /// </summary>

        /// <param name="pointerPoint">涂鸦的停止点</param>

        public void ExitLiveRendering(PointerPoint pointerPoint)

        {

            uint pointerId = pointerPoint.PointerId;

            _container.Children.Remove(_dicLivePath[pointerId]);

            _dicLivePolyLine.Remove(pointerId);

            _dicLivePath.Remove(pointerId);

        }

        /// <summary>

        /// 将 InkStroke 绘制成一条三次贝塞尔曲线

        /// </summary>

        /// <param name="inkStroke">InkStroke 对象</param>

        public void UpdateInkRender(InkStroke inkStroke)

        {

            Path bezierPath = InkStroke2BezierPath(inkStroke);

            _dicInkPath.Add(inkStroke, bezierPath);

            _container.Children.Add(bezierPath);

        }

        /// <summary>

        /// 将每一个 InkStroke 都绘制成一条三次贝塞尔曲线

        /// </summary>

        /// <param name="inkStrokes">InkStroke 集合</param>

        public void UpdateInkRender(IEnumerable<InkStroke> inkStrokes)

        {

            foreach (InkStroke inkStroke in inkStrokes)

            {

                UpdateInkRender(inkStroke);

            }

        }

        /// <summary>

        /// 将被选中的 InkStroke 以被选中的样式绘制出来

        /// </summary>

        public void UpdateSelectionRender()

        {

            foreach (var inkPath in _dicInkPath)

            {

                Path selectionPath = null;

                bool selectionPathExists = _dicSelectionPath.TryGetValue(inkPath.Key, out selectionPath);

                // 如果 InkStroke 是被选中的状态，但是并没有呈现出选中状态，则呈现这个选中状态

                if (inkPath.Key.Selected && !selectionPathExists)

                {

                    inkPath.Value.StrokeThickness = inkPath.Key.DrawingAttributes.Size.Width + ;

                    selectionPath = InkStroke2BezierPath(inkPath.Key);

                    selectionPath.Stroke = new SolidColorBrush(Colors.White);

                    selectionPath.StrokeThickness = inkPath.Key.DrawingAttributes.Size.Width;

                    _dicSelectionPath.Add(inkPath.Key, selectionPath);

                    _container.Children.Add(selectionPath);

                }

                // 如果 InkStroke 是未被选中的状态，但是却呈现出选中状态，则去掉这个选中状态的呈现

                else if (selectionPathExists)

                {

                    inkPath.Value.StrokeThickness = inkPath.Key.DrawingAttributes.Size.Width;

                    _dicSelectionPath.Remove(inkPath.Key);

                    _container.Children.Remove(selectionPath);

                }

            }

        }

        /// <summary>

        /// 清除全部呈现

        /// </summary>

        public void Clear()

        {

            foreach (var path in _dicInkPath.Values)

            {

                _container.Children.Remove(path);

            }

            foreach (var path in _dicSelectionPath.Values)

            {

                _container.Children.Remove(path);

            }

            foreach (var path in _dicLivePath.Values)

            {

                _container.Children.Remove(path);

            }

            _dicInkPath.Clear();

            _dicSelectionPath.Clear();

            _dicLivePath.Clear();

            _dicLivePolyLine.Clear();

        }

        /// <summary>

        /// 如果 InkStroke 是一个贝塞尔曲线画笔，则可将其转换成 Path（一条贝塞尔曲线）

        /// </summary>

        /// <param name="inkStroke">InkStroke 对象</param>

        /// <returns>转换后的 Path 对象</returns>

        public static Path InkStroke2BezierPath(InkStroke inkStroke)

        {

            var figure = new PathFigure();

            var segments = inkStroke.GetRenderingSegments().GetEnumerator();

            segments.MoveNext();

            figure.StartPoint = segments.Current.Position;

            while (segments.MoveNext())

            {

                var bs = new BezierSegment();

                bs.Point1 = segments.Current.BezierControlPoint1;

                bs.Point2 = segments.Current.BezierControlPoint2;

                bs.Point3 = segments.Current.Position;

                figure.Segments.Add(bs);

            }

            var geometry = new PathGeometry();

            geometry.Figures.Add(figure);

            var path = new Path();

            path.Data = geometry;

            path.Stroke = new SolidColorBrush(inkStroke.DrawingAttributes.Color);

            path.StrokeThickness = inkStroke.DrawingAttributes.Size.Width;

            path.StrokeLineJoin = PenLineJoin.Round;

            path.StrokeStartLineCap = PenLineCap.Round;

            return path;

        }

    }

}

<Page

    x:Class="XamlDemo.Input.Ink.Demo"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:local="using:XamlDemo.Input.Ink"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d">

    <Grid Background="Transparent">

        <StackPanel Margin="120 0 0 0">

            <TextBlock Name="lblMsg" FontSize="14.667" />

            <StackPanel Orientation="Horizontal" Margin="0 10 0 0">

                <RadioButton Name="radInk" GroupName="mode" Content="涂鸦模式" Checked="radInk_Checked_1" IsChecked="True" />

                <RadioButton Name="radSelect" GroupName="mode" Content="选择模式" Checked="radSelect_Checked_1" Margin="10 0 0 0" />

                <RadioButton Name="radErase" GroupName="mode" Content="删除模式" Checked="radErase_Checked_1" Margin="10 0 0 0" />

            </StackPanel>

            <StackPanel Orientation="Horizontal" Margin="0 10 0 0">

                <Button Name="btnClearAll" Content="清除全部内容" Click="btnClearAll_Click_1" />

                <Button Name="btnClearSelectedInk" Content="清除被选中的内容" Click="btnClearSelectedInk_Click_1" Margin="10 0 0 0" />

                <Button Name="btnClearSelectedState" Content="清除选中状态" Click="btnClearSelectedState_Click_1" Margin="10 0 0 0" />

                <Button Name="btnMoveSelectedInk" Content="移动被选中的内容" Click="btnMoveSelectedInk_Click_1" Margin="10 0 0 0" />

            </StackPanel>

            <StackPanel Orientation="Horizontal" Margin="0 10 0 0">

                <Button Name="btnCut" Content="剪切" Click="btnCut_Click_1" />

                <Button Name="btnCopy" Content="复制" Click="btnCopy_Click_1" Margin="10 0 0 0" />

                <Button Name="btnPaste" Content="粘贴" Click="btnPaste_Click_1" Margin="10 0 0 0" />

            </StackPanel>

            <StackPanel Orientation="Horizontal" Margin="0 10 0 0">

                <Button Name="btnSave" Content="保存到文件" Click="btnSave_Click_1" />

                <Button Name="btnLoad" Content="从文件加载" Click="btnLoad_Click_1" Margin="10 0 0 0" />

                <Button Name="btnRecognize" Content="文字识别" Click="btnRecognize_Click_1" Margin="10 0 0 0" />

            </StackPanel>

            <Canvas x:Name="canvas" Background="Blue" Width="800" Height="360" Margin="0 10 0 0" HorizontalAlignment="Left"

                    PointerPressed="canvas_PointerPressed_1"

                    PointerMoved="canvas_PointerMoved_1"

                    PointerReleased="canvas_PointerReleased_1" />

        </StackPanel>

    </Grid>

</Page>

/*

 * 通过 InkManager 实现一个功能完善的涂鸦板

 *

 * 注：InkManager 用于 ink 的管理，但并不负责呈现，需要自己开发呈现 ink 的类，请参见 InkRenderer.cs

 *

 *

 * InkManager - ink 的管理类

 *     包括 ink 的输入模式，复制/粘贴，移动，保存到文件，从文件加载，文字识别等功能

 *     详细说明请参见本 Demo 中的相关代码的注释

 *

 * InkStroke - ink 画笔

 *     DrawingAttributes - 画笔的相关属性，一个 InkDrawingAttributes 类型的对象

 *         Color - 颜色

 *         FitToCurve - 使用贝塞尔曲线则为 true，使用直线则为 false，默认值为 true

 *         PenTip - 笔尖的形状（Circle, Rectangle）

 *         Size - 笔尖的尺寸

 *         IgnorePressure - 是否忽略笔尖在触摸屏上的压力

 *     BoundingRect - ink 画笔的边界框

 *     Recognized - 该画笔是否已被文字识别

 *     Selected - 该画笔是否被选中

 *     Clone() - 克隆这个画笔，并返回克隆后的新的 InkStroke 对象

 *     GetRenderingSegments() - 返回 ink 的线段集合，即 InkStrokeRenderingSegment 集合

 *

 * InkStrokeRenderingSegment - ink 的线段

 *     BezierControlPoint1 - 贝塞尔曲线的第一个控制点的位置

 *     BezierControlPoint2 - 贝塞尔曲线的第二个控制点的位置

 *     Position - 贝塞尔曲线的终点的位置

 */

using System;

using System.Linq;

using System.Collections.Generic;

using Windows.Foundation;

using Windows.Storage;

using Windows.Storage.Pickers;

using Windows.UI;

using Windows.UI.Input;

using Windows.UI.Input.Inking;

using Windows.UI.Xaml;

using Windows.UI.Xaml.Controls;

using Windows.UI.Xaml.Input;

using XamlDemo.Common;

namespace XamlDemo.Input.Ink

{

    public sealed partial class Demo : Page

    {

        // 自己开发的用于呈现 ink 的类

        private InkRenderer _renderer = null;

        private InkManager _inkManager = null;

        private InkDrawingAttributes _inkDrawingAttributes = null; // 涂鸦 ink 的样式

        private InkDrawingAttributes _inkDrawingAttributesForSelect = null; // 选择模式时，用于呈现用户的选择路径的 ink 的样式

        private int _pointerId = -; // 当前指针的 pointerId

        public Demo()

        {

            this.InitializeComponent();

            _inkDrawingAttributes = new InkDrawingAttributes();

            _inkDrawingAttributes.Color = Colors.Orange;

            _inkDrawingAttributes.Size = new Size(, );

            _inkDrawingAttributes.IgnorePressure = true;

            _inkDrawingAttributes.FitToCurve = true;

            _inkDrawingAttributesForSelect = new InkDrawingAttributes();

            _inkDrawingAttributesForSelect.Color = Colors.White;

            _inkDrawingAttributesForSelect.Size = new Size(, );

            _inkDrawingAttributesForSelect.PenTip = PenTipShape.Circle;

            _inkManager = new InkManager();

            // InkManager 一共有三种模式：Inking - 涂鸦；Erasing - 擦除；Selecting - 选择

            _inkManager.Mode = InkManipulationMode.Inking;

            // 设置 InkManager 的默认的画笔属性

            _inkManager.SetDefaultDrawingAttributes(_inkDrawingAttributes);

            // 获取 InkManager 所支持的文字识别的种类

            var inkRecognizers = _inkManager.GetRecognizers();

            var inkRecognizer = inkRecognizers.SingleOrDefault(p => p.Name.Equals("Microsoft 中文(简体)手写识别器"));

            if (inkRecognizer != null)

            {

                // 设置 InkManager 的默认的文字识别器为“Microsoft 中文(简体)手写识别器”

                _inkManager.SetDefaultRecognizer(inkRecognizer);

            }

            _renderer = new InkRenderer(canvas);

        }

        private void canvas_PointerPressed_1(object sender, PointerRoutedEventArgs e)

        {

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            _pointerId = (int)pointerPoint.PointerId;

            switch (_inkManager.Mode)

            {

                case InkManipulationMode.Erasing: // 擦除模式

                    break;

                case InkManipulationMode.Inking: // 涂鸦模式

                    _renderer.EnterLiveRendering(pointerPoint, _inkDrawingAttributes);

                    break;

                case InkManipulationMode.Selecting: // 选择模式

                    _renderer.EnterLiveRendering(pointerPoint, _inkDrawingAttributesForSelect);

                    break;

                default:

                    break;

            }

            // 通知 InkManager 指针已按下

            _inkManager.ProcessPointerDown(pointerPoint);

        }

        private void canvas_PointerMoved_1(object sender, PointerRoutedEventArgs e)

        {

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            if (_pointerId == (int)pointerPoint.PointerId)

            {

                switch (_inkManager.Mode)

                {

                    case InkManipulationMode.Erasing:

                        // 通知 InkManager 指针移动中，然后会返回一个 Rect 对象，其代表被 Erasing 的矩形范围

                        var erasingRect = (Rect)_inkManager.ProcessPointerUpdate(e.GetCurrentPoint(canvas));

                        if (erasingRect.Height !=  && erasingRect.Width != )

                        {

                            _renderer.Clear();

                            // 通过 InkManager.GetStrokes() 获取 InkManager 包含的全部 InkStroke 对象集合

                            _renderer.UpdateInkRender(_inkManager.GetStrokes());

                        }

                        break;

                    case InkManipulationMode.Inking:

                    case InkManipulationMode.Selecting:

                        if (_inkManager.Mode == InkManipulationMode.Inking || _inkManager.Mode == InkManipulationMode.Selecting)

                        {

                            var intermediatePoints = e.GetIntermediatePoints(canvas);

                            for (int i = intermediatePoints.Count - ; i >= ; i--)

                            {

                                // 通知 InkManager 指针移动中

                                _inkManager.ProcessPointerUpdate(intermediatePoints[i]);

                            }

                            _renderer.UpdateLiveRender(pointerPoint);

                        }

                        break;

                    default:

                        break;

                }

            }

        }

        private void canvas_PointerReleased_1(object sender, PointerRoutedEventArgs e)

        {

            PointerPoint pointerPoint = e.GetCurrentPoint(canvas);

            if (_pointerId == (int)pointerPoint.PointerId)

            {

                _pointerId = -;

                // 通知 InkManager 指针释放了，返回值：当 Inking 或 Selecting 时返回值为用户此次操作的矩形范围；当 Erasing 时返回值为 0,0,0,0

                var rect = _inkManager.ProcessPointerUp(pointerPoint);

                // var inkManagerRect = _inkManager.BoundingRect; // InkManager 所管理 InkStroke 集合的矩形范围（矩形边框）

                switch (_inkManager.Mode)

                {

                    case InkManipulationMode.Inking:

                        _renderer.ExitLiveRendering(pointerPoint);

                        _renderer.UpdateInkRender(_inkManager.GetStrokes()[_inkManager.GetStrokes().Count - ]);

                        break;

                    case InkManipulationMode.Selecting:

                        _renderer.ExitLiveRendering(pointerPoint);

                        _renderer.UpdateSelectionRender();

                        break;

                    default:

                        break;

                }

            }

        }

        private async void btnSave_Click_1(object sender, RoutedEventArgs e)

        {

            if (_inkManager.GetStrokes().Count > )

            {

                if (Helper.EnsureUnsnapped())

                {

                    var savePicker = new FileSavePicker();

                    savePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;

                    savePicker.FileTypeChoices.Add("GIF", new List<string> { ".gif" });

                    StorageFile file = await savePicker.PickSaveFileAsync();

                    if (null != file)

                    {

                        using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))

                        {

                            // 将 InkManager 中的 InkStroke 对象集合保存为文件

                            await _inkManager.SaveAsync(stream);

                        }

                    }

                }

            }

        }

        private async void btnLoad_Click_1(object sender, RoutedEventArgs e)

        {

            if (Helper.EnsureUnsnapped())

            {

                var openPicker = new Windows.Storage.Pickers.FileOpenPicker();

                openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;

                openPicker.FileTypeFilter.Add(".gif");

                StorageFile file = await openPicker.PickSingleFileAsync();

                if (null != file)

                {

                    using (var stream = await file.OpenSequentialReadAsync())

                    {

                        // 加载一个文件，从中获取 InkStroke 对象集合，并将其交由 InkManager 管理

                        await _inkManager.LoadAsync(stream);

                    }

                    _renderer.Clear();

                    _renderer.UpdateInkRender(_inkManager.GetStrokes());

                }

            }

        }

        private void radInk_Checked_1(object sender, RoutedEventArgs e)

        {

            if (_inkManager != null)

                _inkManager.Mode = InkManipulationMode.Inking; // 涂鸦模式

        }

        private void radSelect_Checked_1(object sender, RoutedEventArgs e)

        {

            if (_inkManager != null)

                _inkManager.Mode = InkManipulationMode.Selecting; // 选择模式

        }

        private void radErase_Checked_1(object sender, RoutedEventArgs e)

        {

            if (_inkManager != null)

                _inkManager.Mode = InkManipulationMode.Erasing; // 擦除模式

        }

        private void btnCut_Click_1(object sender, RoutedEventArgs e)

        {

            // 将 InkManager 中的被选中的 InkStroke 对象集合复制到剪切板

            _inkManager.CopySelectedToClipboard();

            // 将 InkManager 中的被选中的 InkStroke 对象集合删除掉

            _inkManager.DeleteSelected();

            _renderer.Clear();

            _renderer.UpdateInkRender(_inkManager.GetStrokes());

        }

        private void btnCopy_Click_1(object sender, RoutedEventArgs e)

        {

            // 将 InkManager 中的被选中的 InkStroke 对象集合复制到剪切板

            _inkManager.CopySelectedToClipboard();

        }

        private void btnPaste_Click_1(object sender, RoutedEventArgs e)

        {

            // 剪切板中的数据是否是 InkStroke 对象集合

            if (_inkManager.CanPasteFromClipboard())

            {

                // 将剪切板中的 InkStroke 对象集合粘贴到指定位置，并将此 InkStroke 对象集合交由 InkManager 管理

                _inkManager.PasteFromClipboard(new Point(, ));

                _renderer.Clear();

                _renderer.UpdateInkRender(_inkManager.GetStrokes());

                _renderer.UpdateSelectionRender();

            }

        }

        private void btnClearAll_Click_1(object sender, RoutedEventArgs e)

        {

            // 通过 InkManager.GetStrokes() 获取 InkManager 包含的全部 InkStroke 对象集合

            foreach (var inkStroke in _inkManager.GetStrokes())

            {

                // InkStroke 是否被选中

                inkStroke.Selected = true;

            }

            // 将 InkManager 中的被选中的 InkStroke 对象集合删除掉

            _inkManager.DeleteSelected();

            _renderer.Clear();

        }

        private void btnClearSelectedInk_Click_1(object sender, RoutedEventArgs e)

        {

            // 将 InkManager 中的被选中的 InkStroke 对象集合删除掉

            _inkManager.DeleteSelected();

            _renderer.Clear();

            _renderer.UpdateInkRender(_inkManager.GetStrokes());

        }

        private void btnClearSelectedState_Click_1(object sender, RoutedEventArgs e)

        {

            foreach (var inkStroke in _inkManager.GetStrokes())

            {

                // InkStroke 是否被选中

                inkStroke.Selected = false;

            }

            _renderer.Clear();

            _renderer.UpdateInkRender(_inkManager.GetStrokes());

        }

        private void btnMoveSelectedInk_Click_1(object sender, RoutedEventArgs e)

        {

            // 将 InkManager 中的被选中的 InkStroke 对象集合移动指定的距离（本例为向下移动 5 个像素，向右移动 50 个像素）

            _inkManager.MoveSelected(new Point(, ));

            _renderer.Clear();

            _renderer.UpdateInkRender(_inkManager.GetStrokes());

            _renderer.UpdateSelectionRender();

        }

        private async void btnRecognize_Click_1(object sender, RoutedEventArgs e)

        {

            // 对 InkManager 中的内容做文字识别

            //     InkRecognitionTarget.All - 识别全部;

            //     InkRecognitionTarget.Selected - 识别选中的 InkStroke 集合;

            //     InkRecognitionTarget.Recent - 识别最近的 InkStroke

            var recognitionResults = await _inkManager.RecognizeAsync(InkRecognitionTarget.All);

            // 将文字识别的结果更新到 InkManager

            _inkManager.UpdateRecognitionResults(recognitionResults);

            // _inkManager.GetRecognitionResults(); 获取 InkManager 中的文字识别的结果

            string result = "文字识别的结果：";

            foreach (InkRecognitionResult recognitionResult in recognitionResults)

            {

                // 获取此文字识别的所有可能的结果集合，集合的第一条数据为最匹配的结果

                result += " " + recognitionResult.GetTextCandidates()[];

            }

            lblMsg.Text = result;

        }

    }

}