private void ImageVirtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = ImageVirtualControl.CreateDrawingSession(region))
{
if (virtualBitmap != null)
ds.DrawImage(virtualBitmap, region, region);
}
}
}
private void CanvasVirtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
if (args.InvalidatedRegions.Length <= 0)
{
return;
}
OnBeforeDraw();
foreach (var region in args.InvalidatedRegions)
{
using (var session = canvasControl.CreateDrawingSession(region))
{
#if DRAW_RECTS
byte[] color = new byte[3];
random.NextBytes(color);
session.FillRectangle(region, Color.FromArgb(255, color[0], color[1], color[2]));
#endif
OnDraw(new BoundedCanvasDrawEventArgs(session, region.ToRect2()));
}
}
OnAfterDraw();
isSuccessfullyRendered = true;
}
/// <summary>
/// отрисовка участка канваса
/// </summary>
private void DrawRegion(CanvasVirtualControl sender, Rect region)
{
using (var ds = sender.CreateDrawingSession(region))
{
ds.Clear(NextColor());
var left = ((int)(region.X / gridSize) - 2) * gridSize;
var top = ((int)(region.Y / gridSize) - 2) * gridSize;
var right = ((int)((region.X + region.Width) / gridSize) + 2) * gridSize;
var bottom = ((int)((region.Y + region.Height) / gridSize) + 2) * gridSize;
for (var x = left; x <= right; x += gridSize)
{
for (var y = top; y <= bottom; y += gridSize)
{
var curObj = Edjes.FirstOrDefault(xx => xx.Item1 == x / gridSize && xx.Item2 == y / gridSize);
if (curObj != null)
{
var pos = new Vector2(x + Xoffset, y + Yoffset);
ds.DrawCachedGeometry(getCashedValve16(sender), pos, Colors.Black);
ds.DrawCachedGeometry(getCashedValve15(sender), pos, Colors.LightGray);
ds.DrawText(curObj.Item3, pos, Colors.DarkBlue, textFormat);
DrawSelectedObject(ds);
}
}
}
}
}
public void FormatLine(ILanguage language,
CanvasVirtualControl canvas, CanvasTextLayout canvasText, string content)
{
var offset = 0;
base.languageParser.Parse(content, language,
(parsedCode, captures) =>
{
foreach (var capture in captures)
{
if (base.Styles.Contains(capture.Name))
{
var style = base.Styles[capture.Name];
if (!string.IsNullOrEmpty(style.Foreground))
{
var foregroundBrush = GetSolidColorBrush(canvas, style.Foreground);
canvasText.SetBrush(
capture.Index + offset,
capture.Length, foregroundBrush);
}
}
}
offset += parsedCode.Length;
});
}
private void canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = sender.CreateDrawingSession(region))
{
ds.Clear(Colors.Transparent);
int startLine = (int)Math.Floor(region.Top / LineHeight);
// add 2 to the end line count. we want to "overdraw" a bit if the line is going to be cut-off
int endLine = (int)(Math.Ceiling(region.Bottom / LineHeight) + 2);
var stringRegion = new StringBuilder();
for (int i = startLine; i < endLine; i++)
{
if (Text != null && i < Text.LineCount)
{
var textLine = Text.GetLine(i);
if (textLine != null && textLine is DiffTextLine diffLine)
{
stringRegion.AppendLine(diffLine.LineNo > -1 ? (diffLine.LineNo).ToString() : "");
}
}
}
using (var canvasText = new CanvasTextLayout(ds, stringRegion.ToString(), _textFormat, 32, (float)region.Height))
{
ds.DrawTextLayout(canvasText, 0, startLine * LineHeight, _defaultForegroundBrush);
}
}
}
}
public void Attach(CanvasVirtualControl control)
{
_control = control;
_events = EngineEvents.Attach(this, control);
_status.IsPaused = true;
}
private CanvasSolidColorBrush GetSolidColorBrush(CanvasVirtualControl resourceCreator, string hex)
{
hex = hex.Replace("#", string.Empty);
byte a = 255;
int index3 = 0;
if (hex.Length == 8)
{
a = (byte)Convert.ToUInt32(hex.Substring(index3, 2), 16);
index3 += 2;
}
byte r = (byte)Convert.ToUInt32(hex.Substring(index3, 2), 16);
index3 += 2;
byte g = (byte)Convert.ToUInt32(hex.Substring(index3, 2), 16);
index3 += 2;
byte b = (byte)Convert.ToUInt32(hex.Substring(index3, 2), 16);
var color = Color.FromArgb(a, r, g, b);
if (_brushLookup.TryGetValue(color, out CanvasSolidColorBrush brush))
{
return(brush);
}
var newBrush = new CanvasSolidColorBrush(resourceCreator, color);
_brushLookup.Add(color, newBrush);
return(newBrush);
}
/// <summary>Redrawing Canvas</summary>
private void Canvas_OnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
if (region.Width > 0 && region.Height > 0)
{
var x = (int)System.Math.Floor(region.X);
var y = (int)System.Math.Floor(region.Y);
var width = (int)System.Math.Ceiling(region.X + region.Width) - x;
var height = (int)System.Math.Ceiling(region.Y + region.Height) - y;
if (sender == captureCanvas)
{
_captureLayer.OnPaint(x, y, width, height);
}
else if (sender == tempCanvas)
{
_temporaryLayer.OnPaint(x, y, width, height);
}
else if (sender == modelCanvas)
{
_modelLayer.OnPaint(x, y, width, height);
}
else if (sender == backgroundCanvas)
{
_backgroundLayer.OnPaint(x, y, width, height);
}
}
}
}
internal async Task LoadAsync(CanvasVirtualControl resourceCreator, ICoordinateSystem coords)
{
Image = await CanvasBitmap.LoadAsync(resourceCreator, Source);
var spriteSizeInPixels = new Vector2(Image.SizeInPixels.Width, Image.SizeInPixels.Height);
var canvasSizeInDips = resourceCreator.Size.ToVector2();
var pixelRatio = spriteSizeInPixels / canvasSizeInDips;
var worldSizeRatio = Size / coords.Size;
if (pixelRatio.X == pixelRatio.Y && worldSizeRatio.X == worldSizeRatio.Y)
{
// If world and sprite have the same aspect ratio we can load
// the sprite with manipulated DPI so we do not need to scale
// it in DrawImage(...) or using a ScaleEffect
var dpi = (96 * pixelRatio.X) / worldSizeRatio.X;
Image.Dispose();
Image = await CanvasBitmap.LoadAsync(resourceCreator, Source, dpi);
IsPreScaled = true;
}
else
{
// Otherwise, the renderer must do the scaling
IsPreScaled = false;
}
}
private void ImageVirtualControl_CreateResources(CanvasVirtualControl sender, Microsoft.Graphics.Canvas.UI.CanvasCreateResourcesEventArgs args)
{
if (imageStream != null)
{
args.TrackAsyncAction(LoadVirtualBitmap().AsAsyncAction());
}
}
public Layer(CanvasVirtualControl control, IRenderTarget target, LayerType type, Renderer renderer)
{
Type = type;
_control = control;
_target = target;
_renderer = renderer;
}
/// <summary>
/// отрисовка протухла для регионов
/// </summary>
private void canvasControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
var invalidatedRegions = args.InvalidatedRegions;
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
void Canvas_CreateResources(CanvasVirtualControl sender, CanvasCreateResourcesEventArgs args)
{
// Don't bother reloading our shaders if it is only the DPI that changed.
// That happens all the time due to ScrollViewer_ViewChanged adjusting canvas.DpiScale.
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
return;
args.TrackAsyncAction(Canvas_CreateResourcesAsync(sender).AsAsyncAction());
}
public void Draw(CanvasDrawingSession session, CanvasVirtualControl device)
{
foreach (var geo in Geometrys)
{
geo.Draw(session, device);
}
TemporaryGeometry?.Draw(session, device);
_image?.Draw(session, device);
}
private void canvas_CreateResources(CanvasVirtualControl sender, CanvasCreateResourcesEventArgs args)
{
// Don't bother reloading our shaders if it is only the DPI that changed.
// That happens all the time due to ScrollViewer_ViewChanged adjusting canvas.DpiScale.
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
{
return;
}
}
// Draw to the CanvasVirtualControl
void virtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = sender.CreateDrawingSession(region))
{
Draw(ds, "Canvas\nVirtual\nControl", sender.Size);
}
}
}
// Draw to the CanvasVirtualControl
void virtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = sender.CreateDrawingSession(region))
{
Draw(ds, "Canvas\nVirtual\nControl", sender.Size);
}
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
CanvasVirtualControl canvasVirtualControl = new CanvasVirtualControl();
canvasVirtualControl.Width = 1486;
canvasVirtualControl.Height = 610;
MyCanvas.Children.Add(canvasVirtualControl);
Canvas.SetLeft(canvasVirtualControl, 100);
Canvas.SetTop(canvasVirtualControl, 100);
canvasVirtualControl.RegionsInvalidated += CanvasVirtualControl_RegionsInvalidated;
}
internal static EngineEvents Attach(Engine engine, CanvasVirtualControl control)
{
var events = new EngineEvents
{
_engine = engine
};
events.AttachCore(engine, control);
return(events);
}
private void RaiseCreateResources(CanvasVirtualControl sender, CanvasCreateResourcesEventArgs args)
{
if (args.Reason == CanvasCreateResourcesReason.DpiChanged)
{
return;
}
var task = OnCreateResources(_earlyCreateResources, _createResources, sender, args);
args.TrackAsyncAction(task.AsAsyncAction());
}
private void OnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs e)
{
Debug.WriteLine(e.VisibleRegion);
foreach (var r in e.InvalidatedRegions)
{
using (var ds = sender.CreateDrawingSession(r))
{
ds.Clear(Colors.DeepSkyBlue);
}
}
}
private void ImageVirtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = ImageVirtualControl.CreateDrawingSession(region))
{
if (virtualBitmap != null)
{
ds.DrawImage(virtualBitmap, region, region);
}
}
}
}
private void OnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
++regionsInvalidatedEventCount;
var invalidatedRegions = args.InvalidatedRegions;
regionsInvalidatedCount += invalidatedRegions.Count();
status.Text = string.Format("{0} RegionsInvalidated events, {1} total regions invalidated", regionsInvalidatedEventCount, regionsInvalidatedCount);
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
private void DrawBorderGeometry(CanvasDrawingSession session, CanvasVirtualControl device)
{
if (Points == null || Points.Count == 0)
{
return;
}
if (_geometry == null || _rebuildGeometry)
{
CreateCanvasGeometry(device);
_rebuildGeometry = false;
}
session.DrawGeometry(_geometry, Colors.WhiteSmoke, 1f / MapController.Instance.Zoom);
}
public void RegionInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
var visibleRegion = new Rect(ViewportOffsetX.Value, ViewportOffsetY.Value,
ViewportWidth.Value, ViewportHeight.Value);
foreach (var rect in args.InvalidatedRegions)
{
if (!visibleRegion.IsIntersect(rect))
{
continue;
}
RenderPart(sender, rect);
}
}
private void CanvasVirtualControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
CanvasDrawingSession drawingSession;
Rect rect = new Rect(args.InvalidatedRegions[0].Left, args.InvalidatedRegions[0].Top, args.InvalidatedRegions[0].Width, args.InvalidatedRegions[0].Height);
using (drawingSession = sender.CreateDrawingSession(rect))
{
var dashedStroke = new CanvasStrokeStyle()
{
LineJoin = CanvasLineJoin.Round
};
drawingSession.DrawRectangle(new Rect(20, 20, 200, 200), Windows.UI.Color.FromArgb(255, 255, 0, 0), 40, dashedStroke);
}
}
private void MapCanvas_OnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
var visible = args.InvalidatedRegions[0];
for (int i = 1; i < args.InvalidatedRegions.Length; i++)
{
visible.Union(args.InvalidatedRegions[i]);
}
using (var drawingSession = sender.CreateDrawingSession(visible))
{
_map.Draw(drawingSession, sender);
}
}
private void OnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
++regionsInvalidatedEventCount;
var invalidatedRegions = args.InvalidatedRegions;
regionsInvalidatedCount += invalidatedRegions.Count();
status.Text = string.Format("{0} RegionsInvalidated events, {1} total regions invalidated", regionsInvalidatedEventCount, regionsInvalidatedCount);
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
private void RecreateCanvas()
{
if (contentControl == null)
{
return;
}
if (canvasControl != null)
{
ReleaseCanvas();
}
contentControl.Content = canvasControl = new CanvasVirtualControl();
InitializeCanvas();
}
async Task Canvas_CreateResourcesAsync(CanvasVirtualControl sender)
{
mandelbrotEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Mandelbrot.bin"));
// The Mandelbrot pixel shader outputs grayscale values. To make the result more interesting,
// we run it through a TableTransferEffect. This applies a color gradient that goes from black
// through blue, cyan, green, yellow, red, magenta, blue again, and finally back toward cyan.
colorizeEffect = new TableTransferEffect
{
Source = mandelbrotEffect,
RedTable = new float[] { 0, 0, 0, 0, 1, 1, 0.67f, 0, 0 },
GreenTable = new float[] { 0, 0, 1, 1, 1, 0, 0, 0, 0.5f },
BlueTable = new float[] { 0, 1, 1, 0, 0, 0, 1, 1, 1 },
};
}
async Task Canvas_CreateResourcesAsync(CanvasVirtualControl sender)
{
mandelbrotEffect = new PixelShaderEffect(await Utils.ReadAllBytes("Shaders/Mandelbrot.bin"));
// The Mandelbrot pixel shader outputs grayscale values. To make the result more interesting,
// we run it through a TableTransferEffect. This applies a color gradient that goes from black
// through blue, cyan, green, yellow, red, magenta, blue again, and finally back toward cyan.
colorizeEffect = new TableTransferEffect
{
Source = mandelbrotEffect,
RedTable = new float[] { 0, 0, 0, 0, 1, 1, 0.67f, 0, 0 },
GreenTable = new float[] { 0, 0, 1, 1, 1, 0, 0, 0, 0.5f },
BlueTable = new float[] { 0, 1, 1, 0, 0, 0, 1, 1, 1 },
};
}
//初始化
public static void Initialize(CanvasVirtualControl sender, int width, int height)
{
App.GrayWhiteGrid = App.GrayWhite(sender, width, height);//灰白网格
//主渲染目标
App.Model.MainRenderTarget = new CanvasRenderTarget(sender, width, height, 96);
//选区渲染目标
App.Model.MaskRenderTarget = new CanvasRenderTarget(sender, width, height);
//空白渲染目标
App.Model.NullRenderTarget = new CanvasRenderTarget(sender, width, height);
//第二页渲染目标（上下）
App.Model.SecondSourceRenderTarget = new CanvasRenderTarget(sender, width, height);
App.Model.SecondTopRenderTarget = new CanvasRenderTarget(sender, width, height);
App.Model.SecondBottomRenderTarget = new CanvasRenderTarget(sender, width, height);
App.Model.isAnimated = false;
}
void Canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
// Configure the Mandelbrot effect to position and scale its output.
const float baseScale = 0.005f;
float scale = baseScale * 96 / sender.Dpi;
Vector2 translate = baseScale * sender.Size.ToVector2() * new Vector2(-0.75f, -0.5f);
mandelbrotEffect.Properties["scale"] = scale;
mandelbrotEffect.Properties["translate"] = translate;
// Draw the effect to whatever regions of the CanvasVirtualControl have been invalidated.
foreach (var region in args.InvalidatedRegions)
{
using (var drawingSession = sender.CreateDrawingSession(region))
{
drawingSession.DrawImage(colorizeEffect);
}
}
}
private void DrawRegion(CanvasVirtualControl sender, Rect region)
{
var tryPanningOrZoomingLayout = new CanvasTextLayout(sender, "Try panning or zooming.", format, 500, 0);
var infoLayout = new CanvasTextLayout(sender,
"In this demo, each time a region is updated, it is cleared to a different background color. " +
"This is to make it possible to see which regions get redrawn.",
format, 500, 0);
var youMadeIt = new CanvasTextLayout(sender,
"You made it to the end!", endFormat, 1000, 0);
using (var ds = sender.CreateDrawingSession(region))
{
ds.Clear(NextColor());
var left = ((int)(region.X / gridSize) - 1) * gridSize;
var top = ((int)(region.Y / gridSize) - 1) * gridSize;
var right = ((int)((region.X + region.Width) / gridSize) + 1) * gridSize;
var bottom = ((int)((region.Y + region.Height) / gridSize) + 1) * gridSize;
for (var x = left; x <= right; x += gridSize)
{
for (var y = top; y <= bottom; y += gridSize)
{
var pos = new Vector2((float)x, (float)y);
ds.DrawCircle(pos, 50, Colors.Black, 6);
ds.DrawCircle(pos, 50, Colors.White, 4);
ds.DrawText(string.Format("{0}\n{1}", x, y), pos, Colors.DarkBlue, coordFormat);
}
}
if (!ThumbnailGenerator.IsDrawingThumbnail)
{
DrawTextWithBackground(ds, tryPanningOrZoomingLayout, gridSize / 2, gridSize / 2);
DrawTextWithBackground(ds, infoLayout, gridSize * 3.5, gridSize * 5.5);
DrawTextWithBackground(ds, youMadeIt, sender.ActualWidth - youMadeIt.RequestedSize.Width, sender.ActualHeight - youMadeIt.RequestedSize.Height);
}
}
}
private void DrawRegion(CanvasVirtualControl sender, Rect region)
{
var tryPanningOrZoomingLayout = new CanvasTextLayout(sender, "Try panning or zooming.", format, 500, 0);
var infoLayout = new CanvasTextLayout(sender,
"In this demo, each time a region is updated, it is cleared to a different background color. " +
"This is to make it possible to see which regions get redrawn.",
format, 500, 0);
var youMadeIt = new CanvasTextLayout(sender,
"You made it to the end!", endFormat, 1000, 0);
using (var ds = sender.CreateDrawingSession(region))
{
ds.Clear(NextColor());
var left = ((int)(region.X / gridSize) - 1) * gridSize;
var top = ((int)(region.Y / gridSize) - 1) * gridSize;
var right = ((int)((region.X + region.Width) / gridSize) + 1) * gridSize;
var bottom = ((int)((region.Y + region.Height) / gridSize) + 1) * gridSize;
for (var x = left; x <= right; x += gridSize)
{
for (var y = top; y <= bottom; y += gridSize)
{
var pos = new Vector2((float)x, (float)y);
ds.DrawCircle(pos, 50, Colors.Black, 6);
ds.DrawCircle(pos, 50, Colors.White, 4);
ds.DrawText(string.Format("{0}\n{1}", x, y), pos, Colors.DarkBlue, coordFormat);
}
}
if (!ThumbnailGenerator.IsDrawingThumbnail)
{
DrawTextWithBackground(ds, tryPanningOrZoomingLayout, gridSize / 2, gridSize / 2);
DrawTextWithBackground(ds, infoLayout, gridSize * 3.5, gridSize * 5.5);
DrawTextWithBackground(ds, youMadeIt, sender.ActualWidth - youMadeIt.RequestedSize.Width, sender.ActualHeight - youMadeIt.RequestedSize.Height);
}
}
}
private CanvasGeometry CreateCanvasGeometry(CanvasVirtualControl device)
{
switch (GeometryType)
{
case GeometryType.Rectangle:
return(CanvasGeometry.CreateRectangle(device, (float)Points[0].X, (float)Points[0].Y,
(float)MapController.Instance.MousePosition.X - (float)Points[0].X, (float)MapController.Instance.MousePosition.Y - (float)Points[0].Y));
case GeometryType.Line:
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(device);
pathBuilder.SetSegmentOptions(CanvasFigureSegmentOptions.ForceRoundLineJoin);
pathBuilder.BeginFigure((float)Points[0].X, (float)Points[0].Y);
pathBuilder.AddLine(new Vector2((float)MapController.Instance.MousePosition.X, (float)MapController.Instance.MousePosition.Y));
pathBuilder.EndFigure(CanvasFigureLoop.Open);
return(CanvasGeometry.CreatePath(pathBuilder));
case GeometryType.Circle:
return(CanvasGeometry.CreateCircle(device, new Vector2((float)Points[0].X, (float)Points[0].Y), GetSegmentLength.CalculateSegmentLength(Points[0], MapController.Instance.MousePosition)));
}
return(null);
}
void Canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
// Configure the Mandelbrot effect to position and scale its output.
const float baseScale = 0.005f;
float scale = baseScale * 96 / sender.Dpi;
Vector2 translate = baseScale * sender.Size.ToVector2() * new Vector2(-0.75f, -0.5f);
mandelbrotEffect.Properties["scale"] = scale;
#if WINDOWS_UWP
mandelbrotEffect.Properties["translate"] = translate;
#else
mandelbrotEffect.Properties["translate"] = (Microsoft.Graphics.Canvas.Numerics.Vector2)translate;
#endif
// Draw the effect to whatever regions of the CanvasVirtualControl have been invalidated.
foreach (var region in args.InvalidatedRegions)
{
using (var drawingSession = sender.CreateDrawingSession(region))
{
drawingSession.DrawImage(colorizeEffect);
}
}
}
private async void CanvasCreateResources(CanvasVirtualControl sender, CanvasCreateResourcesEventArgs args)
{
// create back buffer
_buffer = CanvasRenderTargetExtension.CreateEmpty(sender, new Size(CanvasWidth, CanvasHeight));
_tmpBuffer = CanvasRenderTargetExtension.CreateEmpty(sender, new Size(CanvasWidth, CanvasHeight));
// create default layer
AddLayer();
_background = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///PaintCanvas/Assets/canvas.png"));
_canvas.Invalidate();
Win2dInitialized?.Invoke(this, EventArgs.Empty);
}
private void ImageVirtualControl_CreateResources(CanvasVirtualControl sender, Microsoft.Graphics.Canvas.UI.CanvasCreateResourcesEventArgs args)
{
if (imageStream != null)
{
args.TrackAsyncAction(LoadVirtualBitmap().AsAsyncAction());
}
}
private void VirtualCanvasOnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
if (cachedMap != null && ControlCallback != null)
{
ITextRender2VirtualRenderer renderer = new Direct2DTextRender2Renderer(ControlCallback);
foreach (var r in args.InvalidatedRegions)
{
using (var session = sender.CreateDrawingSession(r))
{
session.DrawRectangle(r, Colors.Black);
renderer.Render(cachedMap, session, r);
}
}
}
}
private void ThisUnloaded(object sender, RoutedEventArgs e)
{
_canvas?.RemoveFromVisualTree();
_canvas = null;
// dispose buffers
_buffer.Dispose();
_tmpBuffer.Dispose();
_background.Dispose();
foreach (var buffer in _undoBuffer)
{
buffer.Value.Dispose();
}
foreach (var buffer in _redoBuffer)
{
buffer.Value.Dispose();
}
foreach (var layer in _layers)
{
layer.Image.Dispose();
}
_undoBuffer.Clear();
_redoBuffer.Clear();
_layers.Clear();
_buffer = null;
_tmpBuffer = null;
_background = null;
}
private void _canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
using (var ds = sender.CreateDrawingSession(args.VisibleRegion))
{
DrawFrame(ds);
}
}
protected override void OnApplyTemplate()
{
_canvas = (CanvasVirtualControl)GetTemplateChild("PART_canvas");
_canvas.ManipulationMode = CanScrollable ? ManipulationModes.System : ManipulationModes.None;
_canvas.CreateResources += CanvasCreateResources;
_canvas.SizeChanged += CanvasSizeChanged;
_canvas.RegionsInvalidated += _canvas_RegionsInvalidated;
_canvas.PointerPressed += CanvasPointerPressed;
_canvas.PointerMoved += CanvasPointerMoved;
_canvas.PointerReleased += CanvasPointerReleased;
_canvas.PointerCanceled += CanvasPointerReleased;
_canvas.PointerCaptureLost += CanvasPointerReleased;
//
_scrollViewer = (ScrollViewer)GetTemplateChild("PART_ScrollViewer");
_scrollViewer.HorizontalScrollBarVisibility = _scrollViewer.VerticalScrollBarVisibility =
CanScrollable ? ScrollBarVisibility.Auto : ScrollBarVisibility.Hidden;
_scrollViewer.HorizontalScrollMode = _scrollViewer.VerticalScrollMode =
CanScrollable ? ScrollMode.Auto : ScrollMode.Disabled;
}
