private List <RasterInkStroke> RecreateDryStrokes(InkModel inkDataModel)
{
if (inkDataModel.InkTree.Root == null)
{
return(new List <RasterInkStroke>());
}
List <RasterInkStroke> dryStrokes = new List <RasterInkStroke>(inkDataModel.Strokes.Count);
DecodedRasterInkBuilder decodedRasterInkBuilder = new DecodedRasterInkBuilder();
IEnumerator <InkNode> enumerator = inkDataModel.InkTree.Root.GetRecursiveEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current is StrokeNode strokeNode)
{
var dryStroke = CreateDryStroke(decodedRasterInkBuilder, strokeNode.Stroke, inkDataModel);
dryStrokes.Add(dryStroke);
bool res = inkDataModel.SensorData.GetSensorData(dryStroke.SensorDataId, out SensorData sensorData);
if (res)
{
mSerializer.LoadSensorDataFromModel(inkDataModel, sensorData);
}
}
}
return(dryStrokes);
}
public void LoadSensorDataFromModel(InkModel inkModel, SensorData sensorData)
{
// Load sensor data if missing
if (mSensorDataMap.TryAdd(sensorData.Id, sensorData))
{
InputContext inputContext = inkModel.InputConfiguration.InputContexts.Find((ic) => ic.Id == sensorData.InputContextID);
// Load input context if missing
if (mInputContexts.TryAdd(inputContext.Id, inputContext))
{
Wacom.Ink.Serialization.Model.Environment environment = inkModel.InputConfiguration.Environments.Find((env) => env.Id == inputContext.EnvironmentId);
mEnvironments.TryAdd(environment.Id, environment);
SensorContext sensorContext = inkModel.InputConfiguration.SensorContexts.Find((sc) => sc.Id == inputContext.SensorContextId);
// Load sensor context if missing
if (mSensorContexts.TryAdd(sensorContext.Id, sensorContext))
{
// Iterate and load sensor channels contexts if missing
for (int j = 0; j < sensorContext.SensorChannelContexts.Count; j++)
{
SensorChannelsContext sensorChannelsContext = sensorContext.SensorChannelContexts[j];
// Load input device if missing
mInputDevices.TryAdd(sensorChannelsContext.InputDevice.Id, sensorChannelsContext.InputDevice);
// Load ink input provider if missing
mInkInputProvidersMap.TryAdd(sensorChannelsContext.InkInputProvider.Id, sensorChannelsContext.InkInputProvider);
}
}
}
}
}
/// <summary>
/// Loads serialized ink
/// </summary>
/// <param name="inkDocument"></param>
public override void LoadInk(InkModel inkDocument)
{
mSerializer = new Serializer();
base.LoadInk(inkDocument);
mDryStrokes = new List <RasterInkStroke>(RecreateDryStrokes(inkDocument));
}
/// <summary>
/// Loads serialized ink
/// </summary>
/// <param name="inkDocument"></param>
public override void LoadInk(InkModel inkDocument)
{
mSpatialModel.Reset();
mSerializer = new Serializer();
base.LoadInk(inkDocument);
mDryStrokes = new List <VectorInkStroke>(RecreateDryStrokes(inkDocument));
}
/// <summary>
/// Loads serialized ink
/// </summary>
private void LoadInk(InkModel inkDocument)
{
if (inkDocument != null)
{
mDryStrokes = new List <DryStroke>(RecreateDryStrokes(inkDocument));
mSerializer.InkDocument = inkDocument;
}
}
public static bool Update(InkModel ink)
{
int result = 0;
using (var db = DbContext.GetDbConnection())
{
result = db.Update(ink);
}
return(result > 0);
}
public VectorInkControl(VectorBrushStyle brushStyle, MediaColor brushColor, InkModel inkDocument = null)
{
InitializeComponent();
mBrushStyle = brushStyle;
mInkBuilder = new VectorInkBuilder(brushStyle);
BrushColor = brushColor;
LoadInk(inkDocument);
StartProcessingInput();
}
public RasterInkControl(RasterBrushStyle brushStyle, MediaColor color, InkModel inkDocument = null)
{
InitializeComponent();
mInkBuilder = new RasterInkBuilder();
mInkBuilder.LayoutUpdated += InkBuilder_LayoutUpdated;
BrushColor = color;
mBrushStyle = brushStyle;
mInkDocument = inkDocument;
StartProcessingInput();
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var targetNote = e.Parameter as InkModel;
if (targetNote != null)
{
currentNote = new InkModel();
currentNote = targetNote;
Task task = Load(currentNote.Content);
}
else
{
currentNote = new InkModel();
currentNote.Title = "新笔记";
}
}
private List <DryStroke> RecreateDryStrokes(InkModel inkDataModel)
{
if (inkDataModel.InkTree.Root == null)
{
return(new List <DryStroke>());
}
List <DryStroke> dryStrokes = new List <DryStroke>(inkDataModel.Strokes.Count);
DecodedRasterInkBuilder decodedRasterInkBuilder = new DecodedRasterInkBuilder();
IEnumerator <InkNode> enumerator = inkDataModel.InkTree.Root.GetRecursiveEnumerator();
while (enumerator.MoveNext())
{
if ((enumerator.Current is StrokeNode strokeNode))
{
dryStrokes.Add(CreateDryStroke(decodedRasterInkBuilder, strokeNode.Stroke, inkDataModel));
}
}
return(dryStrokes);
}
private RasterInkStroke CreateDryStroke(DecodedRasterInkBuilder decodedVectorInkBuilder, Stroke stroke, InkModel inkDataModel)
{
inkDataModel.Brushes.TryGetBrush(stroke.Style.BrushUri, out Wacom.Ink.Serialization.Model.Brush brush);
if (brush is Wacom.Ink.Serialization.Model.VectorBrush vectorBrush)
{
throw new Exception("This sample does not support serialization of both raster and vector brushes");
}
else if (brush is RasterBrush rasterBrush)
{
return(CreateDryStrokeFromRasterBrush(decodedVectorInkBuilder, rasterBrush, stroke));
}
else
{
throw new Exception("Brush not recognized");
}
}
/// <summary>
/// Loads serialized ink
/// </summary>
/// <param name="inkDocument"></param>
public virtual void LoadInk(InkModel inkDocument)
{
StrokeHandler.LoadInk(inkDocument);
}
public void Init()
{
InkDocument = new InkModel();
InkDocument.InkTree.Root = new StrokeGroupNode(Identifier.FromNewGuid());
}
