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 ImageSource_RegionsInvalidated(CanvasVirtualImageSource sender, CanvasRegionsInvalidatedEventArgs args)
{
++regionsInvalidatedEventCount;
var invalidatedRegions = args.InvalidatedRegions;
regionsInvalidatedCount += invalidatedRegions.Count();
status.Text = string.Format("{0} RegionsInvalidated events, {1} total regions invalidated", regionsInvalidatedEventCount, regionsInvalidatedCount);
try
{
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
catch (Exception e)
{
if (!sender.Device.IsDeviceLost(e.HResult))
{
throw;
}
sender.Device.RaiseDeviceLost();
}
}
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);
}
}
}
}
private void RegionsInvalidatedHandler(CanvasVirtualImageSource sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
RenderRegion(region);
}
}
/// <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);
}
}
}
}
/// <summary>
/// отрисовка протухла для регионов
/// </summary>
private void canvasControl_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
var invalidatedRegions = args.InvalidatedRegions;
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
// 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 OnRegionsInvalidated(CanvasVirtualImageSource sender, CanvasRegionsInvalidatedEventArgs e)
{
foreach (var region in e.InvalidatedRegions)
{
var randomColor = CreateRandomColor();
using (sender.CreateDrawingSession(randomColor, region))
{
// Just changing colors...
}
}
}
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 MyCanvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
foreach (var region in args.InvalidatedRegions)
{
using (var ds = MyCanvas.CreateDrawingSession(region))
{
if (virtualBitmap != null)
{
ds.DrawImage(virtualBitmap, region, region);
}
}
}
}
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);
}
}
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 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);
}
}
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);
}
}
}
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 void RaiseDrawOnRegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
if (!_renderLayers.Any())
{
return;
}
foreach (var region in args.InvalidatedRegions)
{
using (var drawingSession = sender.CreateDrawingSession(region))
{
// raise for each RenderLayer in ascending order (higher index -> later rendering)
foreach (var renderLayer in _renderLayers.OrderBy(_ => _.Index))
{
var engineArgs = new EngineDrawEventArgs(Engine.Current, sender, args, renderLayer)
{
DrawingSession = drawingSession
};
_draw.OnNext(engineArgs);
}
}
}
}
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 ImageSource_RegionsInvalidated(CanvasVirtualImageSource sender, CanvasRegionsInvalidatedEventArgs args)
{
++regionsInvalidatedEventCount;
var invalidatedRegions = args.InvalidatedRegions;
regionsInvalidatedCount += invalidatedRegions.Count();
status.Text = string.Format("{0} RegionsInvalidated events, {1} total regions invalidated", regionsInvalidatedEventCount, regionsInvalidatedCount);
try
{
foreach (var region in invalidatedRegions)
{
DrawRegion(sender, region);
}
}
catch (Exception e)
{
if (!sender.Device.IsDeviceLost(e.HResult))
throw;
sender.Device.RaiseDeviceLost();
}
}
public EngineDrawEventArgs(Engine engine, CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args, RenderLayer renderLayer) : base(engine, sender)
{
Arguments = args;
RenderLayer = renderLayer;
}
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;
}
private void canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
if (Text == null)
{
return;
}
// Update the diff map
if (_parentScrollViewer == null)
{
_parentScrollViewer = VisualTreeHelper.FindParent <ScrollViewer>(this);
if (_parentScrollViewer != null)
{
_parentScrollViewer.ViewChanged += (s, e) =>
{
if (DiffMap != null)
{
DiffMap.UpdateTextViews();
}
};
// Force update once
if (DiffMap != null)
{
DiffMap.UpdateTextViews();
}
}
}
if (_language == null && !string.IsNullOrEmpty(FileExtension))
{
_language = Languages.FindById(FileExtension);
}
foreach (Windows.Foundation.Rect region in args.InvalidatedRegions)
{
using (CanvasDrawingSession ds = sender.CreateDrawingSession(region))
{
ds.Clear(_defaultBackgroundColor);
int startLine = (int)Math.Clamp(Math.Floor(region.Top / LineHeight), 0, Text.LineCount);
// 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.Clamp(Math.Ceiling(region.Bottom / LineHeight) + 2, 0, Text.LineCount);
StringBuilder stringRegion = new StringBuilder();
for (int i = startLine; i < endLine; i++)
{
ITextLine line = Text.GetLine(i);
if (line is DiffTextLine diffLine)
{
if (diffLine.ChangeType == DiffLineType.Empty)
{
stringRegion.AppendLine(); // null line
}
else
{
stringRegion.AppendLine(Text.GetLine(i).ToString());
}
}
}
using (var canvasText = new CanvasTextLayout(ds, stringRegion.ToString(), _textFormat, 9999, (float)region.Height))
{
// Handle the diff line background colors
int index = 0;
for (int i = startLine; i < endLine; i++)
{
var line = Text.GetLine(i);
if (line is DiffTextLine diffLine)
{
switch (diffLine.ChangeType)
{
case DiffLineType.Insert:
{
ds.FillRectangle(0, i * LineHeight, (float)this.ActualWidth, MathF.Ceiling(LineHeight), _addedBackgroundColor);
if (_language == null)
{
canvasText.SetBrush(index, line.Length, _addedForegroundBrush);
}
}
break;
case DiffLineType.Remove:
{
ds.FillRectangle(0, i * LineHeight, (float)this.ActualWidth, MathF.Ceiling(LineHeight), _removedBackgroundColor);
if (_language == null)
{
canvasText.SetBrush(index, line.Length, _removedForegroundBrush);
}
}
break;
case DiffLineType.Empty:
{
ds.FillRectangle(0, i * LineHeight, (float)this.ActualWidth, MathF.Ceiling(LineHeight), _nullBrush);
}
break;
case DiffLineType.Unchanged:
default:
break;
}
}
index += line.Length + 2; // add for newline
}
// Syntax highlight
if (_language != null)
{
_colorizer.FormatLine(_language, CanvasRoot, canvasText, stringRegion.ToString());
}
// Draw the text
ds.DrawTextLayout(canvasText, 0, startLine * LineHeight, _defaultForegroundBrush);
}
}
}
}
private void _canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
using (var ds = sender.CreateDrawingSession(args.VisibleRegion))
{
DrawFrame(ds);
}
}
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 canvas_RegionsInvalidated(CanvasVirtualControl sender, CanvasRegionsInvalidatedEventArgs args)
{
float tLineSWidth = 2;
CanvasStrokeStyle strokeStyle = new CanvasStrokeStyle
{
DashStyle = CanvasDashStyle.Dot,
DashCap = CanvasCapStyle.Round,
StartCap = CanvasCapStyle.Round,
EndCap = CanvasCapStyle.Round,
LineJoin = CanvasLineJoin.Bevel,
};
CanvasStrokeStyle strokeStyle2 = new CanvasStrokeStyle
{
CustomDashStyle = new float[] { 15f, 10f }
};
CanvasTextFormat infoRectTextFormat = new CanvasTextFormat
{
FontSize = 12.0f,
WordWrapping = CanvasWordWrapping.NoWrap
};
Color infoRectBGColor = Colors.Black;
Color infoRectTextColor = Colors.DarkGray;
var dir = CanvasSweepDirection.CounterClockwise;
float cursorSize = 50;
float insideCursorSize = 3;
foreach (var region in args.InvalidatedRegions)
{
using (var drawingSession = sender.CreateDrawingSession(region))
{
#region XYZ Axis
//Y
drawingSession.DrawLine(new Vector2((float)canvas.ActualWidth / 2, 0), new Vector2((float)canvas.ActualWidth / 2, (float)canvas.ActualHeight / 2), Colors.Green, 1);
drawingSession.DrawLine(new Vector2((float)canvas.ActualWidth / 2, (float)canvas.ActualHeight / 2), new Vector2((float)canvas.ActualWidth / 2, ((float)canvas.ActualHeight / 2) - 50), Colors.White, 1);
drawingSession.DrawLine(new Vector2(((float)canvas.ActualWidth / 2), ((float)canvas.ActualHeight / 2) - 70), new Vector2(((float)canvas.ActualWidth / 2) + 7, ((float)canvas.ActualHeight / 2) - 60), Colors.White, 1); // \
drawingSession.DrawLine(new Vector2(((float)canvas.ActualWidth / 2) + 14, ((float)canvas.ActualHeight / 2) - 70), new Vector2(((float)canvas.ActualWidth / 2) + 7, ((float)canvas.ActualHeight / 2) - 60), Colors.White, 1); // /
drawingSession.DrawLine(new Vector2(((float)canvas.ActualWidth / 2) + 7, ((float)canvas.ActualHeight / 2) - 50), new Vector2(((float)canvas.ActualWidth / 2) + 7, ((float)canvas.ActualHeight / 2) - 60), Colors.White, 1); // |
//X
drawingSession.DrawLine(new Vector2((float)canvas.ActualWidth / 2, (float)canvas.ActualHeight / 2), new Vector2((float)canvas.ActualWidth, (float)canvas.ActualHeight / 2), Colors.Red, 1);
drawingSession.DrawLine(new Vector2((float)canvas.ActualWidth / 2, (float)canvas.ActualHeight / 2), new Vector2(((float)canvas.ActualWidth / 2) + 50, (float)canvas.ActualHeight / 2), Colors.White, 1);
drawingSession.DrawLine(new Vector2(((float)canvas.ActualWidth / 2) + 51, (float)canvas.ActualHeight / 2 - 21), new Vector2(((float)canvas.ActualWidth / 2) + 71, (float)canvas.ActualHeight / 2 - 1), Colors.White, 1);
drawingSession.DrawLine(new Vector2(((float)canvas.ActualWidth / 2) + 71, (float)canvas.ActualHeight / 2 - 21), new Vector2(((float)canvas.ActualWidth / 2) + 51, (float)canvas.ActualHeight / 2 - 1), Colors.White, 1);
//Z
//maybeoneday
#endregion
#region CURSOR
if (windowsCursor == false)
{
if (cursorMode == 0)
{
//vertical
drawingSession.DrawLine(new Vector2((float)aCursorPOS.X, (float)aCursorPOS.Y - cursorSize), new Vector2((float)aCursorPOS.X, (float)aCursorPOS.Y - insideCursorSize), Colors.White, 1);
drawingSession.DrawLine(new Vector2((float)aCursorPOS.X, (float)aCursorPOS.Y + insideCursorSize), new Vector2((float)aCursorPOS.X, (float)aCursorPOS.Y + cursorSize), Colors.White, 1);
//horizontal
drawingSession.DrawLine(new Vector2((float)aCursorPOS.X - cursorSize, (float)aCursorPOS.Y), new Vector2((float)aCursorPOS.X - insideCursorSize, (float)aCursorPOS.Y), Colors.White, 1);
drawingSession.DrawLine(new Vector2((float)aCursorPOS.X + insideCursorSize, (float)aCursorPOS.Y), new Vector2((float)aCursorPOS.X + cursorSize, (float)aCursorPOS.Y), Colors.White, 1);
//retangulo
drawingSession.DrawRectangle(new Rect(new Point(aCursorPOS.X - insideCursorSize, aCursorPOS.Y - insideCursorSize), new Point(aCursorPOS.X + insideCursorSize, aCursorPOS.Y + insideCursorSize)), Colors.White, 1);
}
}
else
{
Window.Current.CoreWindow.PointerCursor = new CoreCursor(cursorNormal, 0);
}
#endregion
#region LINE
if (drawingLine == true)
{
// Linha do desenho
Vector2 tLineP1 = new Vector2(tLine.x1, tLine.y1);
Vector2 tLineP2 = new Vector2(tLine.x2, tLine.y2);
drawingSession.DrawLine(tLineP1, tLineP2, Colors.White, 1);
// Linha paralela
float L = (float)(Math.Sqrt((tLineP1.X - tLineP2.X) * (tLineP1.X - tLineP2.X) + (tLineP1.Y - tLineP2.Y) * (tLineP1.Y - tLineP2.Y)));
float offsetPixels = 50;
float radius = Vector2.Distance(tLineP1, tLineP2);
float yAxis = -180;
if (tLine.y2 > tLine.y1)
{
yAxis = 180;
offsetPixels = -50;
dir = CanvasSweepDirection.Clockwise;
}
Vector2 pLineP1 = new Vector2(tLineP1.X + offsetPixels * (tLineP2.Y - tLineP1.Y) / L, tLineP1.Y + offsetPixels * (tLineP1.X - tLineP2.X) / L);
Vector2 pLineP2 = new Vector2(tLineP2.X + offsetPixels * (tLineP2.Y - tLineP1.Y) / L, tLineP2.Y + offsetPixels * (tLineP1.X - tLineP2.X) / L);
drawingSession.DrawLine(pLineP1, pLineP2, Colors.DarkGray, tLineSWidth, strokeStyle); // diagonal
drawingSession.DrawLine(tLineP1, pLineP1, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 1
drawingSession.DrawLine(tLineP2, pLineP2, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 2
// linha adjacente
drawingSession.DrawLine(tLineP1.X, tLineP1.Y, tLineP1.X + L, tLineP1.Y, Colors.DarkGray, tLineSWidth, strokeStyle);
// arco
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(sender);
pathBuilder.BeginFigure(new Vector2(tLineP1.X + L, tLineP1.Y));
pathBuilder.AddArc(
tLineP2,
radius,
radius,
0, dir, CanvasArcSize.Small
);
pathBuilder.EndFigure(CanvasFigureLoop.Open);
CanvasGeometry geometry = CanvasGeometry.CreatePath(pathBuilder);
drawingSession.DrawGeometry(geometry, Colors.DarkGray, 2, strokeStyle);
// InfoBox de medição do angulo
double angle = Math.Abs((Math.Atan2((tLineP1.Y) - tLineP2.Y, (tLineP1.X + radius) - tLineP2.X)) * 360 / Math.PI + yAxis);
double arcLenght = (angle * Math.PI * radius) / 180;
Vector2 midPoint = geometry.ComputePointOnPath((float)arcLenght / 2);
CanvasTextLayout textLayout = new CanvasTextLayout(drawingSession, Math.Round(angle).ToString() + "°", infoRectTextFormat, 0.0f, 0.0f);
Rect infoRect = new Rect(midPoint.X - ((float)textLayout.DrawBounds.Width / 2) - 5,
midPoint.Y - ((float)textLayout.DrawBounds.Height / 2) - 5,
textLayout.DrawBounds.Width + 10,
textLayout.DrawBounds.Height + 10
);
drawingSession.FillRectangle(infoRect, infoRectBGColor); // fundo
drawingSession.DrawTextLayout(textLayout,
midPoint.X - ((float)textLayout.DrawBounds.Width / 2),
midPoint.Y - ((float)textLayout.DrawBounds.Height),
infoRectTextColor
);
}
#endregion
#region RECT
if (drawingRect == true)
{
drawingSession.DrawRectangle(new Rect(new Point(tRect.x1, tRect.y1), new Point(tRect.x2, tRect.y2)), Colors.White, 1);
}
#endregion
#region CIRCLE
if (drawingCircle == true)
{
// Linha do desenho
drawingSession.DrawLine(tCircle.cx1, tCircle.cy1, tCircle.rx2, tCircle.ry2, Colors.Orange, 1, strokeStyle2);
// Linha paralela
float L = (float)(Math.Sqrt((tCircle.cx1 - tCircle.rx2) * (tCircle.cx1 - tCircle.rx2) + (tCircle.cy1 - tCircle.ry2) * (tCircle.cy1 - tCircle.ry2)));
float offsetPixels = 50;
float x1p = tCircle.cx1 + offsetPixels * (tCircle.ry2 - tCircle.cy1) / L;
float x2p = tCircle.rx2 + offsetPixels * (tCircle.ry2 - tCircle.cy1) / L;
float y1p = tCircle.cy1 + offsetPixels * (tCircle.cx1 - tCircle.rx2) / L;
float y2p = tCircle.ry2 + offsetPixels * (tCircle.cx1 - tCircle.rx2) / L;
drawingSession.DrawLine(x1p, y1p, x2p, y2p, Colors.DarkGray, tLineSWidth, strokeStyle); // diagonal
drawingSession.DrawLine(tCircle.cx1, tCircle.cy1, x1p, y1p, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 1
drawingSession.DrawLine(tCircle.rx2, tCircle.ry2, x2p, y2p, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 2
drawingSession.DrawCircle(tCircle.cx1, tCircle.cy1, Vector2.Distance(new Vector2(tCircle.cx1, tCircle.cy1), new Vector2(tCircle.rx2, tCircle.ry2)), Colors.White, 1);
}
#endregion
#region RULER
if (measuring == true)
{
// Linha do desenho
Vector2 rLineP1 = new Vector2(tRuler.x1, tRuler.y1);
Vector2 rLineP2 = new Vector2(tRuler.x2, tRuler.y2);
drawingSession.DrawLine(rLineP1, rLineP2, Colors.Orange, 1, strokeStyle2);
// Linha paralela
float L = Convert.ToInt16(Math.Sqrt((rLineP1.X - rLineP2.X) * (rLineP1.X - rLineP2.X) + (rLineP1.Y - rLineP2.Y) * (rLineP1.Y - rLineP2.Y)));
float offsetPixels = 50;
Vector2 pLineP1 = new Vector2(rLineP1.X + offsetPixels * (rLineP2.Y - rLineP1.Y) / L, rLineP1.Y + offsetPixels * (rLineP1.X - rLineP2.X) / L);
Vector2 pLineP2 = new Vector2(rLineP2.X + offsetPixels * (rLineP2.Y - rLineP1.Y) / L, rLineP2.Y + offsetPixels * (rLineP1.X - rLineP2.X) / L);
drawingSession.DrawLine(pLineP1, pLineP2, Colors.DarkGray, tLineSWidth, strokeStyle); // diagonal
drawingSession.DrawLine(rLineP1, pLineP1, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 1
drawingSession.DrawLine(rLineP2, pLineP2, Colors.DarkGray, tLineSWidth, strokeStyle); // ligação 2
// InfoBox de medição do comprimento
float lenght = Vector2.Distance(rLineP1, rLineP2);
Vector2 midPoint = new Vector2(pLineP1.X + (pLineP2.X - pLineP1.X) / 2, pLineP1.Y + (pLineP2.Y - pLineP1.Y) / 2);
CanvasTextLayout textLayout = new CanvasTextLayout(drawingSession, lenght.ToString("0.0000", new CultureInfo("en-US")), infoRectTextFormat, 0.0f, 0.0f);
Rect infoRect = new Rect(midPoint.X - (textLayout.DrawBounds.Width / 2) - 5,
midPoint.Y - (textLayout.DrawBounds.Height / 2) - 5,
textLayout.DrawBounds.Width + 10,
textLayout.DrawBounds.Height + 10
);
drawingSession.FillRectangle(infoRect, infoRectBGColor); // fundo
drawingSession.DrawTextLayout(textLayout,
midPoint.X - ((float)textLayout.DrawBounds.Width / 2),
midPoint.Y - ((float)textLayout.DrawBounds.Height),
infoRectTextColor
);
}
#endregion
#region SNAP
if (isSnapActivated == true && isDrawing == true)
{
foreach (snap s in Snaps)
{
if (s.isVisible == true)
{
int size = 5;
Point centerPOS = new Point(s.rect.X + near, s.rect.Y + near);
if (s.type == 1)
{
drawingSession.DrawRectangle(new Rect(new Point(centerPOS.X - size, centerPOS.Y - size), new Point(centerPOS.X + size, centerPOS.Y + size)), Colors.DeepSkyBlue, 2);
}
else if (s.type == 2)
{
drawingSession.DrawLine(new Vector2((float)centerPOS.X - size, (float)centerPOS.Y + size), new Vector2((float)centerPOS.X + size, (float)centerPOS.Y + size), Colors.DeepSkyBlue, 2); //base
drawingSession.DrawLine(new Vector2((float)centerPOS.X - size, (float)centerPOS.Y + size), new Vector2((float)centerPOS.X, (float)centerPOS.Y - size), Colors.DeepSkyBlue, 2); //lateral esq
drawingSession.DrawLine(new Vector2((float)centerPOS.X + size, (float)centerPOS.Y + size), new Vector2((float)centerPOS.X, (float)centerPOS.Y - size), Colors.DeepSkyBlue, 2); //lateral dir
}
else if (s.type == 3)
{
drawingSession.DrawLine(new Vector2((float)centerPOS.X, (float)centerPOS.Y - size), new Vector2((float)centerPOS.X, (float)centerPOS.Y + size), Colors.Red, 1); // |
drawingSession.DrawLine(new Vector2((float)centerPOS.X - size, (float)centerPOS.Y), new Vector2((float)centerPOS.X + size, (float)centerPOS.Y), Colors.Red, 1); // -
drawingSession.DrawLine(new Vector2((float)centerPOS.X - size, (float)centerPOS.Y - size), new Vector2((float)centerPOS.X + size, (float)centerPOS.Y + size), Colors.Red, 1); // \
drawingSession.DrawLine(new Vector2((float)centerPOS.X + size, (float)centerPOS.Y - size), new Vector2((float)centerPOS.X - size, (float)centerPOS.Y + size), Colors.Red, 1); // /
}
}
}
}
#endregion
foreach (line l in Lines)
{
drawingSession.DrawLine(l.x1, l.y1, l.x2, l.y2, Colors.White, 1);
}
foreach (rect r in Rects)
{
drawingSession.DrawRectangle(new Rect(new Point(r.x1, r.y1), new Point(r.x2, r.y2)), Colors.White, 1);
}
foreach (circle c in Circles)
{
drawingSession.DrawCircle(new Vector2(c.cx1, c.cy1), c.radius, Colors.White, 1);
}
}
}
}
