} // loadPlan()
/// <summary>
/// This function is called by the parent class as part of the displayPlan() method.
/// It only implements the actual drawing of the plan, which is different depending on
/// whether an SVG or a JPEG plan is used.
/// </summary>
/// <param name="canvas"></param>
public override void drawPlan(SKCanvas canvas)
{
// Set up scaling matrix to zoom around pivot point at centre of display, then modify to take
// account of translation. It would seem like a nice idea to set up the scaling matrix only
// when we actually change the scale, but, actually, this gets extremely messy, because both
// scaling and translating affect the "TransX" and "TransY" values of the matrix. See design
// documentation.
float scale = base.getCurrentScaleFactor();
SKMatrix matrix = new SKMatrix(scale, 0, base.getTranslationX(), 0, scale, base.getTranslationY(), 0, 0, 1);
try
{
// Draw the plan
canvas.DrawPicture(SVGCanvas.Picture, ref matrix);
}
catch (Exception e)
{
string errorString = "Cannot draw SVG plan: ";
LogFile.WriteError(errorString + e.Message);
throw new Exception(errorString, e);
}
// Draw an outline around the plan, just so we can see where it is
SKPaint paint = new SKPaint();
// ***** There is an issue with SKColor; using pre-defined SkiaSharp colour, as it does not
// seem to be possible to set SKColor to one of the colours defined in colors.xml. *****
paint.Color = SKColors.Black;
paint.IsStroke = true;
paint.StrokeWidth = 2;
// The transformation matrix was applied to the picture, not to the canvas, so we have to
// apply the same transformtion to the frame.
SKRect transformedRect = matrix.MapRect(SKRect.Create(0, 0, drawingWidth, drawingHeight));
canvas.DrawRect(transformedRect, paint);
} // drawPlan
public void DrawBoard(SKCanvas thisCanvas, float Width, float Height) // i think when drawing the board, it needs to recalculate so it can draw the pads as well.
{
SKRect bounds = SKRect.Create(0, 0, Width, Height);
SKPaint ThisPaint = new SKPaint();
ThisPaint.IsAntialias = true;
ThisPaint.FilterQuality = SKFilterQuality.High;
SKPoint FirstPoint;
SKPoint SecondPoint;
FirstPoint = new SKPoint(0, 0);
SecondPoint = new SKPoint(0, Height);
SKColor[] Colors;
Colors = new SKColor[2];
SKColor FirstColor;
SKColor SecondColor;
FirstColor = SKColors.LightBlue;
SecondColor = SKColors.DarkBlue;
Colors[0] = FirstColor;
Colors[1] = SecondColor;
ThisPaint.Shader = SKShader.CreateLinearGradient(FirstPoint, SecondPoint, Colors, null, SKShaderTileMode.Clamp);
thisCanvas.DrawRect(bounds, ThisPaint);
}
private void DrawHeader(SKCanvas canvas, string header)
{
using var backgroundPaint = new SKPaint
{
Color = SKColors.Black,
};
canvas.DrawRect(0, 0, this._layoutProperty.LabelHeaderWidth, this._layoutProperty.LabelHeaderHeight, backgroundPaint);
using var textPaint = new SKPaint
{
Color = SKColors.White,
TextSize = this._layoutProperty.LabelHeaderHeight * 0.75f,
IsAntialias = true,
};
var textWidth = textPaint.MeasureText(header);
var textX = this._layoutProperty.LabelHeaderWidth / 2 - textWidth / 2;
var textY = this._layoutProperty.LabelHeaderHeight * 0.8f;
canvas.DrawText(header, textX, textY, textPaint);
canvas.Save();
}
private static void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
if (SKBitmap == null)
{
using (SKPaint paint = new SKPaint())
{
SKRect rect = new SKRect(0, 0, App.ScreenWidth, App.ScreenHeight);
paint.Shader = CreateGradientShader(ref rect);
// Draw the gradient on the rectangle
canvas.DrawRect(rect, paint);
}
}
else
{
canvas.DrawBitmap(SKBitmap, 0, 0);
}
}
/// <inheritdoc />
protected override void DrawBar(ChartSerie serie, SKCanvas canvas, float headerHeight, float itemX, SKSize itemSize, SKSize barSize, float origin, float barX, float barY, SKColor color)
{
using (var paint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = color,
})
{
var x = barX - (itemSize.Width / 2);
var y = Math.Min(origin, barY);
var height = Math.Max(MinBarHeight, Math.Abs(origin - barY));
if (height < MinBarHeight)
{
height = MinBarHeight;
if (y + height > Margin + itemSize.Height)
{
y = headerHeight + itemSize.Height - height;
}
}
var rect = SKRect.Create(x, y, barSize.Width, height);
canvas.DrawRect(rect, paint);
}
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
SKShaderTileMode tileMode =
(SKShaderTileMode)(tileModePicker.SelectedIndex == -1 ?
0 : tileModePicker.SelectedItem);
using (SKPaint paint = new SKPaint())
{
paint.Shader = SKShader.CreateRadialGradient(
new SKPoint(info.Rect.MidX, info.Rect.MidY),
100,
new SKColor[] { SKColors.Black, SKColors.White },
null,
tileMode);
canvas.DrawRect(info.Rect, paint);
}
}
void DrawHUD(SKCanvas canvas, Character c, int x, int y)
{
const int BackgroundOffsetX = 5;
const int BackgroundOffsetY = 15;
const int HUDWidth = 85;
const int HUDHeight = 60;
const int LineHeight = 18;
const int StatusIconHeightGap = 4;
const int StatusIconWidthGap = 20;
canvas.DrawRect(SKRect.Create(x + StyleInfo.TextXOffset - BackgroundOffsetX, y + StyleInfo.TextYOffset - BackgroundOffsetY, HUDWidth, HUDHeight), Styles.TextBackground);
canvas.DrawText(c.Name, new SKPoint(x + StyleInfo.TextXOffset, y + StyleInfo.TextYOffset), Styles.TextPaint);
canvas.DrawText($"HP {c.Health.Current}/{c.Health.Maximum}", new SKPoint(x + StyleInfo.TextXOffset, LineHeight + y + StyleInfo.TextYOffset), Styles.TextPaint);
// TestData - Status Icons
int iconOffset = 0;
foreach (int i in new int [] { 33, 42, 148, 36 })
{
var bitmapRect = SKRect.Create(x + StyleInfo.TextXOffset + (iconOffset * StatusIconWidthGap), LineHeight + StatusIconHeightGap + y + StyleInfo.TextYOffset, 16, 16);
canvas.DrawBitmap(StatusIconLoader.Tileset, StatusIconLoader.GetRect(i), bitmapRect, Styles.AntialiasPaint);
iconOffset++;
}
}
private void OnPainting(object sender, SKPaintSurfaceEventArgs e)
{
var surface = e.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear(SKColors.LightGray);
Random rand = new Random();
foreach (Packer.Box box in packer.boxes)
{
if (box.position != null)
{
SKRect boxrect = new SKRect(box.position.x, box.position.y, box.position.x + box.width, box.position.y + box.height);
uint red = 100 + (uint)rand.Next(155);
uint grn = 100 + (uint)rand.Next(155);
uint blu = 100 + (uint)rand.Next(155);
canvas.DrawRect(boxrect, new SKPaint()
{
Color = new SKColor((byte)red, (byte)grn, (byte)blu)
});
}
}
}
// Implement drawing cycle.
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
//canvas.Clear();
using (SKPaint fillPaint = new SKPaint {
Style = SKPaintStyle.Stroke,
Color = SKColor.FromHsv(hue, 100, 100),
StrokeWidth = 10
})
{
// Translate to center of canvas
canvas.Translate(info.Width / 2, info.Height / 2);
for (int angle = 0; angle < 360; angle += 45)
{
canvas.Save();
// Rotate around center of canvas
canvas.RotateDegrees(revolveDegrees + angle);
// Translate horizontally
float madLad = Math.Min(info.Width, info.Height) / 3;
canvas.Translate(madLad * radius, 0);
// Rotate around center of object
canvas.RotateDegrees(rotateDegrees);
// Draw a square
float apothem = 30 + angle * 0.1f;
canvas.DrawRect(new SKRect(-apothem, -apothem, apothem, apothem), fillPaint);
canvas.Restore();
}
}
}
protected void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
using (SKPaint paint = new SKPaint())
{
SKColor SpideyBlueBckGrnd;
//SKColor.TryParse("#020f1f", out SpideyBlueBckGrnd);
SKColor.TryParse("#ECE9E6", out SpideyBlueBckGrnd);
SKColor SpideyLightBlueBckGrnd;
SKColor.TryParse("#FFFFFF", out SpideyLightBlueBckGrnd);
//SKColor.TryParse("#001c41", out SpideyLightBlueBckGrnd);
paint.Shader = SKShader.CreateLinearGradient(
new SKPoint(info.Rect.Top, info.Rect.Top),
new SKPoint(info.Rect.Bottom, info.Rect.Bottom),
new SKColor[] { SpideyBlueBckGrnd, SpideyLightBlueBckGrnd },
new float[] { 0, 10.80f },
SKShaderTileMode.Mirror);
canvas.DrawRect(info.Rect, paint);
}
}
protected void DrawPointAreas(SKCanvas canvas, SKPoint[] points, float origin)
{
if (points.Length > 0 && this.PointAreaAlpha > 0)
{
for (int i = 0; i < points.Length; i++)
{
var entry = this.Entries.ElementAt(i);
var point = points[i];
var y = Math.Min(origin, point.Y);
using (var shader = SKShader.CreateLinearGradient(new SKPoint(0, origin), new SKPoint(0, point.Y), new[] { entry.Color.WithAlpha(this.PointAreaAlpha), entry.Color.WithAlpha((byte)(this.PointAreaAlpha / 3)) }, null, SKShaderTileMode.Clamp))
using (var paint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = entry.Color.WithAlpha(this.PointAreaAlpha),
})
{
paint.Shader = shader;
var height = Math.Max(2, Math.Abs(origin - point.Y));
canvas.DrawRect(SKRect.Create(point.X - (this.PointSize / 2), y, this.PointSize, height), paint);
}
}
}
}
private void DrawFluid(SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
SKPoint center = new SKPoint(info.Width / 2, info.Height / 2);
// fluid
SKPaint fluidPaint = new SKPaint
{
IsAntialias = true,
Style = SKPaintStyle.Fill,
Color = FluidColor.ToSKColor(),
};
// fluid bottom
canvas.DrawCircle(center.X, info.Height + bottomFluidGlassCircleCenterY, bottomFluidGlassHullRadius - fluidHullPadding, fluidPaint);
// draw live
float livePixelsYStart = info.Height + bottomFluidGlassCircleCenterY - bottomFluidGlassHullRadius - startMarkerDistance;
float livePixelsYEnd = topFluidGlassCircleCenterY;
// map real temp to pixels from marker start to end
float temperatureY = Temperature.Map(MinTemperature, MaxTemperature, livePixelsYStart, livePixelsYEnd);
// fluid top
SKRect fluidTop = new SKRect
{
Top = temperatureY,
Left = center.X - (topFluidGlassWidth / 2) + fluidHullPadding,
Right = center.X + (topFluidGlassWidth / 2) - fluidHullPadding,
Bottom = info.Height + bottomFluidGlassCircleCenterY
};
canvas.DrawRect(fluidTop, fluidPaint);
}
public void UpdateSnakeImage()
{
BorderPaint = new SKPaint()
{
Style = SKPaintStyle.Stroke, Color = ((Color)Application.Current.Resources["TraceColor"]).ToSKColor()
};
SKCanvas canvas = Surface.Canvas;
canvas.Clear(Color.Green.ToSKColor());
int PixelsPerSize = PixelSize / size;
canvas.DrawRect(new SKRect(0, 0, PixelSize, PixelSize), BackgroundPaint);
canvas.DrawRect(new SKRect((float)(SnakeHead.X * PixelsPerSize + 2), (float)(SnakeHead.Y * PixelsPerSize + 2), (float)(SnakeHead.X * PixelsPerSize + PixelsPerSize) - 2, (float)(SnakeHead.Y * PixelsPerSize + PixelsPerSize) - 2), SnakePaint);
canvas.DrawRect(new SKRect((float)(SnakeHead.X * PixelsPerSize), (float)(SnakeHead.Y * PixelsPerSize), (float)(SnakeHead.X * PixelsPerSize + PixelsPerSize), (float)(SnakeHead.Y * PixelsPerSize + PixelsPerSize)), BorderPaint);
foreach (Point SnakePoint in SnakePoints)
{
canvas.DrawRect(new SKRect((float)(SnakePoint.X * PixelsPerSize + 2), (float)(SnakePoint.Y * PixelsPerSize + 2), (float)(SnakePoint.X * PixelsPerSize + PixelsPerSize) - 2, (float)(SnakePoint.Y * PixelsPerSize + PixelsPerSize) - 2), SnakePaint);
canvas.DrawRect(new SKRect((float)(SnakePoint.X * PixelsPerSize), (float)(SnakePoint.Y * PixelsPerSize), (float)(SnakePoint.X * PixelsPerSize + PixelsPerSize), (float)(SnakePoint.Y * PixelsPerSize + PixelsPerSize)), BorderPaint);
}
canvas.DrawRect(new SKRect((float)(ApplePoint.X * PixelsPerSize + 2), (float)(ApplePoint.Y * PixelsPerSize + 2), (float)(ApplePoint.X * PixelsPerSize + PixelsPerSize) - 2, (float)(ApplePoint.Y * PixelsPerSize + PixelsPerSize) - 2), ApplePaint);
canvas.DrawRect(new SKRect((float)(ApplePoint.X * PixelsPerSize), (float)(ApplePoint.Y * PixelsPerSize), (float)(ApplePoint.X * PixelsPerSize + PixelsPerSize), (float)(ApplePoint.Y * PixelsPerSize + PixelsPerSize)), BorderPaint);
SnakeDisplay.UpdateImage(Surface.Snapshot());
}
private void DrawLegend(SKCanvas canvas, int width, int height)
{
if (!LegendNames.Any())
{
return;
}
List <SKColor> colors = new List <SKColor> {
};
foreach (List <ChartEntry> l in MultiBarEntries)
{
colors.Add(l[0].Color);
}
int rectWidth = 20;
using (var paint = new SKPaint())
{
paint.TextSize = this.LabelTextSize;
paint.IsAntialias = true;
paint.IsStroke = false;
float x = 200 + rectWidth * 2;
float y = 50;
foreach (string legend in LegendNames)
{
paint.Color = SKColor.Parse("#000000");
canvas.DrawText(legend, x + rectWidth + 10, y, paint);
paint.Color = colors.ElementAt(LegendNames.IndexOf(legend));
var rect = SKRect.Create(x, y - rectWidth, rectWidth, rectWidth);
canvas.DrawRect(rect, paint);
x += rectWidth * 2 + this.LabelTextSize * (legend.Length / 2 + 2);
}
var minPoint = points.Min(p => p.Y);
var maxPoint = points.Max(p => p.Y);
paint.Color = SKColor.Parse("#000000");
paint.TextSize = 20;
canvas.DrawCircle(12, minPoint, 5, paint);
canvas.DrawText(NumbersTools.GetNember(multilineMax), 0, minPoint - 20, paint);
canvas.DrawCircle(12, maxPoint, 5, paint);
canvas.DrawText(NumbersTools.GetNember(multilineMin), 0, maxPoint - 20, paint);
var step = maxPoint / 4;
var valueStep = multilineMax / 4;
for (int i = 1; i < 4; i++)
{
var tt = (maxPoint - step * i);
if (minPoint < (maxPoint - step * i) && Math.Abs(minPoint - (maxPoint - step * i)) >= step)
{
canvas.DrawCircle(12, (maxPoint - step * i), 5, paint);
canvas.DrawText(NumbersTools.GetNember(valueStep * i), 0, (maxPoint - step * i) - 20, paint);
}
}
}
}
/// <inheritdoc />
public void DrawRectangle(IBrush brush, IPen pen, RoundedRect rect, BoxShadows boxShadows = default)
{
if (rect.Rect.Height <= 0 || rect.Rect.Width <= 0)
{
return;
}
// Arbitrary chosen values
// On OSX Skia breaks OpenGL context when asked to draw, e. g. (0, 0, 623, 6666600) rect
if (rect.Rect.Height > 8192 || rect.Rect.Width > 8192)
{
boxShadows = default;
}
var rc = rect.Rect.ToSKRect();
var isRounded = rect.IsRounded;
var needRoundRect = rect.IsRounded || (boxShadows.HasInsetShadows);
using var skRoundRect = needRoundRect ? new SKRoundRect() : null;
if (needRoundRect)
{
skRoundRect.SetRectRadii(rc,
new[]
{
rect.RadiiTopLeft.ToSKPoint(), rect.RadiiTopRight.ToSKPoint(),
rect.RadiiBottomRight.ToSKPoint(), rect.RadiiBottomLeft.ToSKPoint(),
});
}
foreach (var boxShadow in boxShadows)
{
if (!boxShadow.IsEmpty && !boxShadow.IsInset)
{
using (var shadow = BoxShadowFilter.Create(_boxShadowPaint, boxShadow, _currentOpacity))
{
var spread = (float)boxShadow.Spread;
if (boxShadow.IsInset)
{
spread = -spread;
}
Canvas.Save();
if (isRounded)
{
using var shadowRect = new SKRoundRect(skRoundRect);
if (spread != 0)
{
shadowRect.Inflate(spread, spread);
}
Canvas.ClipRoundRect(skRoundRect,
shadow.ClipOperation, true);
var oldTransform = Transform;
Transform = oldTransform * Matrix.CreateTranslation(boxShadow.OffsetX, boxShadow.OffsetY);
Canvas.DrawRoundRect(shadowRect, shadow.Paint);
Transform = oldTransform;
}
else
{
var shadowRect = rc;
if (spread != 0)
{
shadowRect.Inflate(spread, spread);
}
Canvas.ClipRect(rc, shadow.ClipOperation);
var oldTransform = Transform;
Transform = oldTransform * Matrix.CreateTranslation(boxShadow.OffsetX, boxShadow.OffsetY);
Canvas.DrawRect(shadowRect, shadow.Paint);
Transform = oldTransform;
}
Canvas.Restore();
}
}
}
if (brush != null)
{
using (var paint = CreatePaint(_fillPaint, brush, rect.Rect.Size))
{
if (isRounded)
{
Canvas.DrawRoundRect(skRoundRect, paint.Paint);
}
else
{
Canvas.DrawRect(rc, paint.Paint);
}
}
}
foreach (var boxShadow in boxShadows)
{
if (!boxShadow.IsEmpty && boxShadow.IsInset)
{
using (var shadow = BoxShadowFilter.Create(_boxShadowPaint, boxShadow, _currentOpacity))
{
var spread = (float)boxShadow.Spread;
var offsetX = (float)boxShadow.OffsetX;
var offsetY = (float)boxShadow.OffsetY;
var outerRect = AreaCastingShadowInHole(rc, (float)boxShadow.Blur, spread, offsetX, offsetY);
Canvas.Save();
using var shadowRect = new SKRoundRect(skRoundRect);
if (spread != 0)
{
shadowRect.Deflate(spread, spread);
}
Canvas.ClipRoundRect(skRoundRect,
shadow.ClipOperation, true);
var oldTransform = Transform;
Transform = oldTransform * Matrix.CreateTranslation(boxShadow.OffsetX, boxShadow.OffsetY);
using (var outerRRect = new SKRoundRect(outerRect))
Canvas.DrawRoundRectDifference(outerRRect, shadowRect, shadow.Paint);
Transform = oldTransform;
Canvas.Restore();
}
}
}
if (pen?.Brush != null)
{
using (var paint = CreatePaint(_strokePaint, pen, rect.Rect.Size))
{
if (isRounded)
{
Canvas.DrawRoundRect(skRoundRect, paint.Paint);
}
else
{
Canvas.DrawRect(rc, paint.Paint);
}
}
}
}
private void OnPaintCanvas(object sender, SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
int surfaceWidth = info.Width;
int surfaceHeight = info.Height;
SKPoint surfaceSize = new SKPoint(surfaceWidth, surfaceHeight);
//絵画開始
//背景色を塗る
canvas.Clear(PaintColors.OutOfRangeBackground.ToSKColor());
//アートボードの絵画
anArtBoard.SizeRecalculation(surfaceSize);
using (SKPaint paint = new SKPaint())
{
paint.Style = SKPaintStyle.Fill;
paint.Color = PaintColors.ArtBoardBackground.ToSKColor();
canvas.DrawRect(anArtBoard.AbsoluteRect, paint);
}
radius = Math.Min(anArtBoard.Size.X, anArtBoard.Size.Y) / 2.0f * 0.7f;
anArtBoard.InProgressPath.StrokeColor = PaintColors.Black;
anArtBoard.InProgressPath.StrokeSize = 5;
anArtBoard.InProgressPath.StrokeJoin = SKStrokeJoin.Round;
anArtBoard.InProgressPath.StrokeCap = SKStrokeCap.Round;
anArtBoard.InProgressPath.Screentone = PaintPatterns.CheckeredPattern(PaintColors.Blue.ToSKColor());
anArtBoard.BezierHandleList.Clear();
anArtBoard.BezierHandleList.Add(
new BezierHandle(
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2, anArtBoard.Size.Y / 2 - radius),
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 + radius * controlPointCoefficient, anArtBoard.Size.Y / 2 - radius)));
anArtBoard.BezierHandleList.Add(
new BezierHandle(
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 + radius, anArtBoard.Size.Y / 2),
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 + radius, anArtBoard.Size.Y / 2 + radius * controlPointCoefficient)));
anArtBoard.BezierHandleList.Add(
new BezierHandle(
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2, anArtBoard.Size.Y / 2 + radius),
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 - radius * controlPointCoefficient, anArtBoard.Size.Y / 2 + radius)));
anArtBoard.BezierHandleList.Add(
new BezierHandle(
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 - radius, anArtBoard.Size.Y / 2),
anArtBoard.AbsolutePosition + new SKPoint(anArtBoard.Size.X / 2 - radius, anArtBoard.Size.Y / 2 - radius * controlPointCoefficient)));
//絶対座標からアスペクト座標に変換
foreach (var bezierHandle in anArtBoard.BezierHandleList)
{
bezierHandle.AnchorPoint = anArtBoard.MatrixToAspectCoordinates().MapPoint(bezierHandle.AnchorPoint);
bezierHandle.MouseControlPoint = anArtBoard.MatrixToAspectCoordinates().MapPoint(bezierHandle.MouseControlPoint);
}
//暫定Path絵画
if (anArtBoard.BezierHandleList.Count >= 2)
{
anArtBoard.InProgressPath.Reset();
//bezierHandleList -> inProgressPath
anArtBoard.GenerateBezierPath(pathPreview);
anArtBoard.InProgressPath.Transform(this.anArtBoard.InverseMatrixToAbsoluteCoordinates());
canvas.DrawPath(anArtBoard.InProgressPath, anArtBoard.InProgressPath.GetFillPaint());
canvas.DrawPath(anArtBoard.InProgressPath, anArtBoard.InProgressPath.GetStrokePaint());
}
//コントロールポイントを絵画
SKPaint aBezierHandlePaint = new SKPaint()
{
IsAntialias = true,
Style = SKPaintStyle.Stroke,
Color = PaintColors.Lasso.ToSKColor(),
StrokeWidth = 2,
StrokeJoin = SKStrokeJoin.Round,
StrokeCap = SKStrokeCap.Round
};
SKPaint aBezierHandleAnchorPaint = new SKPaint()
{
IsAntialias = true,
Style = SKPaintStyle.Fill,
Color = PaintColors.Lasso.ToSKColor()
};
using (SKPath path = new SKPath())
{
foreach (var aBezierHandle in anArtBoard.BezierHandleList)
{
SKPoint anchorPoint = anArtBoard.InverseMatrixToAbsoluteCoordinates().MapPoint(aBezierHandle.AnchorPoint);
SKPoint mouseControlPoint = anArtBoard.InverseMatrixToAbsoluteCoordinates().MapPoint(aBezierHandle.MouseControlPoint);
SKPoint theOtherControlPoint = anArtBoard.InverseMatrixToAbsoluteCoordinates().MapPoint(aBezierHandle.TheOtherControlPoint);
path.MoveTo(anchorPoint);
path.LineTo(mouseControlPoint);
canvas.DrawCircle(anchorPoint, 4, aBezierHandleAnchorPaint);
path.MoveTo(anchorPoint);
path.LineTo(theOtherControlPoint);
}
canvas.DrawPath(path, aBezierHandlePaint);
}
}
public override void Draw(SKCanvas canvas, SKPaint paint, int x, int y)
{
canvas.DrawRect(new SKRect(x - 100, y - 50, x + 100, y + 50), paint);
}
public static void DrawHeaderPaint(SKCanvas c, BaseBundle icon)
{
c.DrawRect(new SKRect(0, 0, icon.Width, icon.HeaderHeight), new SKPaint
{
IsAntialias = true,
FilterQuality = SKFilterQuality.High,
Color = icon.DisplayStyle.PrimaryColor
});
if (icon.DisplayStyle.CustomBackground != null && icon.DisplayStyle.CustomBackground.Height != icon.DisplayStyle.CustomBackground.Width)
{
icon.IsDisplayNameShifted = false;
var bgPaint = new SKPaint {
IsAntialias = true, FilterQuality = SKFilterQuality.High, BlendMode = SKBlendMode.Screen
};
if (Properties.Settings.Default.UseChallengeBanner)
{
bgPaint.Color = SKColors.Transparent.WithAlpha((byte)Properties.Settings.Default.ChallengeBannerOpacity);
}
c.DrawBitmap(icon.DisplayStyle.CustomBackground, new SKRect(0, 0, 1024, 256), bgPaint);
}
else if (icon.DisplayStyle.DisplayImage != null)
{
icon.IsDisplayNameShifted = true;
if (icon.DisplayStyle.CustomBackground != null && icon.DisplayStyle.CustomBackground.Height == icon.DisplayStyle.CustomBackground.Width)
{
c.DrawBitmap(icon.DisplayStyle.CustomBackground, new SKRect(0, 0, icon.HeaderHeight, icon.HeaderHeight),
new SKPaint {
IsAntialias = true, FilterQuality = SKFilterQuality.High, BlendMode = SKBlendMode.Screen,
ImageFilter = SKImageFilter.CreateDropShadow(2.5F, 0, 20, 0, icon.DisplayStyle.SecondaryColor.WithAlpha(25), SKDropShadowImageFilterShadowMode.DrawShadowAndForeground)
});
}
c.DrawBitmap(icon.DisplayStyle.DisplayImage, new SKRect(0, 0, icon.HeaderHeight, icon.HeaderHeight),
new SKPaint {
IsAntialias = true, FilterQuality = SKFilterQuality.High,
ImageFilter = SKImageFilter.CreateDropShadow(-2.5F, 0, 20, 0, icon.DisplayStyle.SecondaryColor.WithAlpha(50), SKDropShadowImageFilterShadowMode.DrawShadowAndForeground)
});
}
SKPath pathTop = new SKPath {
FillType = SKPathFillType.EvenOdd
};
pathTop.MoveTo(0, icon.HeaderHeight);
pathTop.LineTo(icon.Width, icon.HeaderHeight);
pathTop.LineTo(icon.Width, icon.HeaderHeight - 19);
pathTop.LineTo(icon.Width / 2 + 7, icon.HeaderHeight - 23);
pathTop.LineTo(icon.Width / 2 + 13, icon.HeaderHeight - 7);
pathTop.LineTo(0, icon.HeaderHeight - 19);
pathTop.Close();
c.DrawPath(pathTop, new SKPaint {
IsAntialias = true, FilterQuality = SKFilterQuality.High, Color = icon.DisplayStyle.SecondaryColor,
ImageFilter = SKImageFilter.CreateDropShadow(-5, -5, 0, 0, icon.DisplayStyle.AccentColor.WithAlpha(75), SKDropShadowImageFilterShadowMode.DrawShadowAndForeground)
});
c.DrawRect(new SKRect(0, icon.HeaderHeight, icon.Width, icon.HeaderHeight + icon.AdditionalSize), new SKPaint
{
IsAntialias = true,
FilterQuality = SKFilterQuality.High,
Color = icon.DisplayStyle.PrimaryColor.WithAlpha(200) // default background is black, so i'm kinda lowering the brightness here and that's what i want
});
}
protected override void OnDrawSample(SKCanvas canvas, int width, int height)
{
var modes = Enum.GetValues(typeof(SKXferMode)).Cast <SKXferMode>().ToArray();
var cols = width < height ? 3 : 5;
var rows = (modes.Length - 1) / cols + 1;
var w = (float)width / cols;
var h = (float)height / rows;
var rect = SKRect.Create(w, h);
var srcPoints = new[] {
new SKPoint(0.0f, 0.0f),
new SKPoint(w, 0.0f)
};
var srcColors = new[] {
SKColors.Magenta.WithAlpha(0),
SKColors.Magenta
};
var dstPoints = new[] {
new SKPoint(0.0f, 0.0f),
new SKPoint(0.0f, h)
};
var dstColors = new[] {
SKColors.Cyan.WithAlpha(0),
SKColors.Cyan
};
using (var text = new SKPaint())
using (var stroke = new SKPaint())
using (var src = new SKPaint())
using (var dst = new SKPaint())
using (var srcShader = SKShader.CreateLinearGradient(srcPoints[0], srcPoints[1], srcColors, null, SKShaderTileMode.Clamp))
using (var dstShader = SKShader.CreateLinearGradient(dstPoints[0], dstPoints[1], dstColors, null, SKShaderTileMode.Clamp))
{
text.TextSize = 12.0f;
text.IsAntialias = true;
text.TextAlign = SKTextAlign.Center;
stroke.IsStroke = true;
src.Shader = srcShader;
dst.Shader = dstShader;
canvas.Clear(SKColors.White);
for (var i = 0; i < modes.Length; ++i)
{
using (new SKAutoCanvasRestore(canvas, true))
{
canvas.Translate(w * (i / rows), h * (i % rows));
canvas.ClipRect(rect);
canvas.DrawColor(SKColors.LightGray);
canvas.SaveLayer(null);
canvas.Clear(SKColors.Transparent);
canvas.DrawPaint(dst);
src.XferMode = modes[i];
canvas.DrawPaint(src);
canvas.DrawRect(rect, stroke);
var desc = modes[i].ToString();
canvas.DrawText(desc, w / 2f, h / 2f, text);
}
}
}
}
private SKBitmap BuildThumbCollageBitmap(string[] paths, int width, int height, string?libraryName)
{
var bitmap = new SKBitmap(width, height);
using var canvas = new SKCanvas(bitmap);
canvas.Clear(SKColors.Black);
using var backdrop = GetNextValidImage(paths, 0, out _);
if (backdrop == null)
{
return(bitmap);
}
// resize to the same aspect as the original
var backdropHeight = Math.Abs(width * backdrop.Height / backdrop.Width);
using var residedBackdrop = SkiaEncoder.ResizeImage(backdrop, new SKImageInfo(width, backdropHeight, backdrop.ColorType, backdrop.AlphaType, backdrop.ColorSpace));
// draw the backdrop
canvas.DrawImage(residedBackdrop, 0, 0);
// draw shadow rectangle
var paintColor = new SKPaint
{
Color = SKColors.Black.WithAlpha(0x78),
Style = SKPaintStyle.Fill
};
canvas.DrawRect(0, 0, width, height, paintColor);
var typeFace = SKTypeface.FromFamilyName("sans-serif", SKFontStyleWeight.Bold, SKFontStyleWidth.Normal, SKFontStyleSlant.Upright);
// use the system fallback to find a typeface for the given CJK character
var nonCjkPattern = @"[^\p{IsCJKUnifiedIdeographs}\p{IsCJKUnifiedIdeographsExtensionA}\p{IsKatakana}\p{IsHiragana}\p{IsHangulSyllables}\p{IsHangulJamo}]";
var filteredName = Regex.Replace(libraryName ?? string.Empty, nonCjkPattern, string.Empty);
if (!string.IsNullOrEmpty(filteredName))
{
typeFace = SKFontManager.Default.MatchCharacter(null, SKFontStyleWeight.Bold, SKFontStyleWidth.Normal, SKFontStyleSlant.Upright, null, filteredName[0]);
}
// draw library name
var textPaint = new SKPaint
{
Color = SKColors.White,
Style = SKPaintStyle.Fill,
TextSize = 112,
TextAlign = SKTextAlign.Center,
Typeface = typeFace,
IsAntialias = true
};
// scale down text to 90% of the width if text is larger than 95% of the width
var textWidth = textPaint.MeasureText(libraryName);
if (textWidth > width * 0.95)
{
textPaint.TextSize = 0.9f * width * textPaint.TextSize / textWidth;
}
canvas.DrawText(libraryName, width / 2f, (height / 2f) + (textPaint.FontMetrics.XHeight / 2), textPaint);
return(bitmap);
}
private void DrawBars(float xOffset, float yOffset, float width, SKCanvas canvas)
{
if (_sortedProfileData.Count != 0)
{
long maxAverage = 0;
long maxTotal = 0;
long maxInstant = 0;
float barHeight = (LineHeight - LinePadding) / 3.0f;
// Get max values
foreach (KeyValuePair <ProfileConfig, TimingInfo> kvp in _sortedProfileData)
{
maxInstant = Math.Max(maxInstant, kvp.Value.Instant);
maxAverage = Math.Max(maxAverage, kvp.Value.AverageTime);
maxTotal = Math.Max(maxTotal, kvp.Value.TotalTime);
}
SKPaint barPaint = new SKPaint()
{
Color = SKColors.Blue
};
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
// Instant
barPaint.Color = SKColors.Blue;
float bottom = GetLineY(yOffset, LineHeight, LinePadding, false, verticalIndex);
float top = bottom + barHeight;
float right = (float)entry.Value.Instant / maxInstant * width + xOffset;
// Skip rendering out of bounds bars
if (top < 0 || bottom > _rendererHeight)
{
continue;
}
canvas.DrawRect(new SKRect(xOffset, top, right, bottom), barPaint);
// Average
barPaint.Color = SKColors.Green;
top += barHeight;
bottom += barHeight;
right = (float)entry.Value.AverageTime / maxAverage * width + xOffset;
canvas.DrawRect(new SKRect(xOffset, top, right, bottom), barPaint);
// Total
barPaint.Color = SKColors.Red;
top += barHeight;
bottom += barHeight;
right = (float)entry.Value.TotalTime / maxTotal * width + xOffset;
canvas.DrawRect(new SKRect(xOffset, top, right, bottom), barPaint);
}
}
}
private void DrawGraph(SKCanvas Canvas, SKPoint[] Points, object[] Parameters, SKPoint[] PrevPoints, object[] PrevParameters,
DrawingArea DrawingArea)
{
SKPaint Brush = null;
SKPath Path = null;
try
{
Brush = new SKPaint()
{
Color = Graph.ToColor(Parameters[0]),
Style = SKPaintStyle.Fill
};
Path = new SKPath();
float HalfBarWidth = (DrawingArea.Width - Points.Length) * 0.45f / Points.Length;
float x0, y0, x1, y1;
int i, c;
if (PrevPoints != null)
{
if ((c = PrevPoints.Length) != Points.Length)
{
PrevPoints = null;
}
else
{
for (i = 0; i < c; i++)
{
if (PrevPoints[i].X != Points[i].X)
{
PrevPoints = null;
break;
}
}
}
}
i = 0;
foreach (SKPoint Point in Points)
{
x0 = Point.X - HalfBarWidth + 1;
y0 = Point.Y;
x1 = Point.X + HalfBarWidth - 1;
y1 = PrevPoints != null ? PrevPoints[i++].Y : DrawingArea.OrigoY;
Canvas.DrawRect(new SKRect(x0, y0, x1, y1), Brush);
}
Canvas.DrawPath(Path, Brush);
}
finally
{
if (Brush != null)
{
Brush.Dispose();
}
if (Path != null)
{
Path.Dispose();
}
}
}
private void DrawRect(SKRect rect, SKPaint paint, SKCanvas canvas)
{
canvas.DrawRect(rect, paint);
}
protected override void DrawGradient(SKImageInfo info, SKCanvas canvas, SKPaint paint)
{
canvas.DrawRect(0, 0, info.Width, info.Height, paint);
}
public void FillRect(RectangleF rect, Color color)
{
skPaint.IsStroke = false;
skPaint.Color = color.ToSKColor();
skCanvas.DrawRect(rect.ToSKRect(), skPaint);
}
private void DrawProperties(SKCanvas thisCanvas) // this is a big one.
{
SKPaint fillColor;
SKColor foreColor; // used for textpaint.
string text1;
string text2;
switch (CardValue)
{
case 19:
{
text1 = "Medit Avenue";
fillColor = _purplePaint !;
foreColor = SKColors.White;
text2 = "1 of 2";
break;
}
case 20:
{
text1 = "Baltic Avenue";
fillColor = _purplePaint !;
foreColor = SKColors.White;
text2 = "2 of 2";
break;
}
case 21:
{
text1 = "Oriental Avenue";
fillColor = _aquaPaint !;
foreColor = SKColors.Black;
text2 = "1 of 3";
break;
}
case 22:
{
text1 = "Vermont Avenue";
fillColor = _aquaPaint !;
foreColor = SKColors.Black;
text2 = "2 of 3";
break;
}
case 23:
{
text1 = "Connect Avenue";
fillColor = _aquaPaint !;
foreColor = SKColors.Black;
text2 = "3 of 3";
break;
}
case 24:
{
text1 = "Charles Avenue";
fillColor = _fuchsiaPaint !;
foreColor = SKColors.Black;
text2 = "1 or 3";
break;
}
case 25:
{
text1 = "States Avenue";
fillColor = _fuchsiaPaint !;
foreColor = SKColors.Black;
text2 = "2 of 3";
break;
}
case 26:
{
text1 = "Virginia Avenue";
fillColor = _fuchsiaPaint !;
foreColor = SKColors.Black;
text2 = "3 of 3";
break;
}
case 27:
{
text1 = "James Place";
fillColor = _darkOrangePaint !;
foreColor = SKColors.Black;
text2 = "1 of 3";
break;
}
case 28:
{
text1 = "Tenn Avenue";
fillColor = _darkOrangePaint !;
foreColor = SKColors.Black;
text2 = "2 of 3";
break;
}
case 29:
{
text1 = "York Avenue";
fillColor = _darkOrangePaint !;
foreColor = SKColors.Black;
text2 = "3 of 3";
break;
}
case 30:
{
text1 = "Kentucky Avenue";
fillColor = _redPaint !;
foreColor = SKColors.White;
text2 = "1 of 3";
break;
}
case 31:
{
text1 = "Indiana Avenue";
fillColor = _redPaint !;
foreColor = SKColors.White;
text2 = "2 to 3";
break;
}
case 32:
{
text1 = "Illinois Avenue";
fillColor = _redPaint !;
foreColor = SKColors.White;
text2 = "3 of 3";
break;
}
case 33:
{
text1 = "Atlantic Avenue";
fillColor = _yellowPaint !;
foreColor = SKColors.Black;
text2 = "1 of 3";
break;
}
case 34:
{
text1 = "Ventor Avenue";
fillColor = _yellowPaint !;
foreColor = SKColors.Black;
text2 = "2 of 3";
break;
}
case 35:
{
text1 = "Marvin Gardens";
fillColor = _yellowPaint !;
foreColor = SKColors.Black;
text2 = "3 of 3";
break;
}
case 36:
{
text1 = "Pacific Avenue";
fillColor = _greenPaint !;
foreColor = SKColors.White;
text2 = "1 of 3";
break;
}
case 37:
{
text1 = "Carolina Avenue";
fillColor = _greenPaint !;
foreColor = SKColors.White;
text2 = "2 of 3";
break;
}
case 38:
{
text1 = "Penn Avenue";
fillColor = _greenPaint !;
foreColor = SKColors.White;
text2 = "3 of 3";
break;
}
case 39:
{
text1 = "Park Place";
fillColor = _darkBluePaint !;
foreColor = SKColors.White;
text2 = "1 of 2";
break;
}
case 40:
{
text1 = "Board Walk";
fillColor = _darkBluePaint !;
foreColor = SKColors.White;
text2 = "2 of 2";
break;
}
default:
{
throw new BasicBlankException("Nothing Found");
}
}
var firstRect = MainGraphics !.GetActualRectangle(3, 3, 50, 36);
thisCanvas.DrawRect(firstRect, fillColor);
var thisList = text1.Split(" ").ToCustomBasicList();
var fontSize = MainGraphics.GetFontSize(11);
var textPaint = MiscHelpers.GetTextPaint(foreColor, fontSize);
textPaint.FakeBoldText = true;
if (thisList.Count != 2)
{
throw new Exception("Needs 2 items");
}
int tops;
tops = 1;
foreach (var thisText in thisList)
{
var thisRect = MainGraphics.GetActualRectangle(1, tops, 53, 18);
thisCanvas.DrawCustomText(thisText, TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, textPaint, thisRect, out _);
tops += 18;
}
var secondRect = MainGraphics.GetActualRectangle(0, 37, 55, 35);
fontSize = MainGraphics.GetFontSize(15);
textPaint = MiscHelpers.GetTextPaint(SKColors.Black, fontSize);
textPaint.FakeBoldText = true;
thisCanvas.DrawCustomText(text2, TextExtensions.EnumLayoutOptions.Center, TextExtensions.EnumLayoutOptions.Center, textPaint, secondRect, out _);
}
public void RenderToSizeNetStandard2()
{
//ExStart
//ExFor:Document.RenderToSize
//ExSummary:Shows how to render the document as a bitmap at a specified location and size (.NetStandard 2.0).
Document doc = new Document(MyDir + "Rendering.docx");
using (SKBitmap bitmap = new SKBitmap(700, 700))
{
using (SKCanvas canvas = new SKCanvas(bitmap))
{
// Apply a scaling factor of 70% to the page that we will render using this canvas.
canvas.Scale(70);
// Offset the page 0.5" from the top and left edges of the page.
canvas.Translate(0.5f, 0.5f);
// Rotate the rendered page by 10 degrees.
canvas.RotateDegrees(10);
// Create and draw a rectangle.
SKRect rect = new SKRect(0f, 0f, 3f, 3f);
canvas.DrawRect(rect, new SKPaint
{
Color = SKColors.Black,
Style = SKPaintStyle.Stroke,
StrokeWidth = 3f / 72f
});
// Render the first page of the document to the same size as the above rectangle.
// The rectangle will frame this page.
float returnedScale = doc.RenderToSize(0, canvas, 0f, 0f, 3f, 3f);
Console.WriteLine("The image was rendered at {0:P0} zoom.", returnedScale);
// Reset the matrix, and then apply a new set of scaling and translations.
canvas.ResetMatrix();
canvas.Scale(5);
canvas.Translate(10, 10);
// Create another rectangle.
rect = new SKRect(0, 0, 50, 100);
rect.Offset(90, 10);
canvas.DrawRect(rect, new SKPaint
{
Color = SKColors.Black,
Style = SKPaintStyle.Stroke,
StrokeWidth = 1
});
// Render the first page within the newly created rectangle once again.
doc.RenderToSize(0, canvas, 90, 10, 50, 100);
using (SKFileWStream fs = new SKFileWStream(ArtifactsDir + "Rendering.RenderToSizeNetStandard2.png"))
{
bitmap.PeekPixels().Encode(fs, SKEncodedImageFormat.Png, 100);
}
}
}
//ExEnd
}
public void Draw(SKCanvas canvas)
{
_lastOutputDraw = PerformanceCounter.ElapsedTicks;
if (!Visible ||
!_initComplete ||
!_enableCheckbutton.Active ||
!_redrawPending)
{
return;
}
float viewTop = TitleHeight + 5;
float viewBottom = _rendererHeight - FilterHeight - LineHeight;
float columnWidth;
float maxColumnWidth = MinimumColumnWidth;
float yOffset = _scrollPos + viewTop;
float xOffset = 10;
float timingWidth;
float contentHeight = GetLineY(0, LineHeight, LinePadding, false, _sortedProfileData.Count - 1);
_outputScrollbar.Adjustment.Upper = contentHeight;
_outputScrollbar.Adjustment.Lower = 0;
_outputScrollbar.Adjustment.PageSize = viewBottom - viewTop;
SKPaint textFont = new SKPaint()
{
Color = SKColors.White,
TextSize = LineHeight
};
SKPaint titleFont = new SKPaint()
{
Color = SKColors.White,
TextSize = TitleFontHeight
};
SKPaint evenItemBackground = new SKPaint()
{
Color = SKColors.Gray
};
canvas.Save();
canvas.ClipRect(new SKRect(0, viewTop, _rendererWidth, viewBottom), SKClipOperation.Intersect);
for (int i = 1; i < _sortedProfileData.Count; i += 2)
{
float top = GetLineY(yOffset, LineHeight, LinePadding, false, i - 1);
float bottom = GetLineY(yOffset, LineHeight, LinePadding, false, i);
canvas.DrawRect(new SKRect(0, top, _rendererWidth, bottom), evenItemBackground);
}
lock (_profileDataLock)
{
// Display category
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
if (entry.Key.Category == null)
{
continue;
}
float y = GetLineY(yOffset, LineHeight, LinePadding, true, verticalIndex);
canvas.DrawText(entry.Key.Category, new SKPoint(xOffset, y), textFont);
columnWidth = textFont.MeasureText(entry.Key.Category);
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
}
canvas.Restore();
canvas.DrawText("Category", new SKPoint(xOffset, TitleFontHeight + 2), titleFont);
columnWidth = titleFont.MeasureText("Category");
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
xOffset += maxColumnWidth + ColumnSpacing;
canvas.DrawLine(new SKPoint(xOffset - ColumnSpacing / 2, 0), new SKPoint(xOffset - ColumnSpacing / 2, viewBottom), textFont);
// Display session group
maxColumnWidth = MinimumColumnWidth;
canvas.Save();
canvas.ClipRect(new SKRect(0, viewTop, _rendererWidth, viewBottom), SKClipOperation.Intersect);
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
if (entry.Key.SessionGroup == null)
{
continue;
}
float y = GetLineY(yOffset, LineHeight, LinePadding, true, verticalIndex);
canvas.DrawText(entry.Key.SessionGroup, new SKPoint(xOffset, y), textFont);
columnWidth = textFont.MeasureText(entry.Key.SessionGroup);
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
}
canvas.Restore();
canvas.DrawText("Group", new SKPoint(xOffset, TitleFontHeight + 2), titleFont);
columnWidth = titleFont.MeasureText("Group");
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
xOffset += maxColumnWidth + ColumnSpacing;
canvas.DrawLine(new SKPoint(xOffset - ColumnSpacing / 2, 0), new SKPoint(xOffset - ColumnSpacing / 2, viewBottom), textFont);
// Display session item
maxColumnWidth = MinimumColumnWidth;
canvas.Save();
canvas.ClipRect(new SKRect(0, viewTop, _rendererWidth, viewBottom), SKClipOperation.Intersect);
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
if (entry.Key.SessionItem == null)
{
continue;
}
float y = GetLineY(yOffset, LineHeight, LinePadding, true, verticalIndex);
canvas.DrawText(entry.Key.SessionItem, new SKPoint(xOffset, y), textFont);
columnWidth = textFont.MeasureText(entry.Key.SessionItem);
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
}
canvas.Restore();
canvas.DrawText("Item", new SKPoint(xOffset, TitleFontHeight + 2), titleFont);
columnWidth = titleFont.MeasureText("Item");
if (columnWidth > maxColumnWidth)
{
maxColumnWidth = columnWidth;
}
xOffset += maxColumnWidth + ColumnSpacing;
timingWidth = _rendererWidth - xOffset - 370;
canvas.Save();
canvas.ClipRect(new SKRect(0, viewTop, _rendererWidth, viewBottom), SKClipOperation.Intersect);
canvas.DrawLine(new SKPoint(xOffset, 0), new SKPoint(xOffset, _rendererHeight), textFont);
int mode = _modeBox.Active;
canvas.Save();
canvas.ClipRect(new SKRect(xOffset, yOffset, xOffset + timingWidth, yOffset + contentHeight),
SKClipOperation.Intersect);
switch (mode)
{
case 0:
DrawGraph(xOffset, yOffset, timingWidth, canvas);
break;
case 1:
DrawBars(xOffset, yOffset, timingWidth, canvas);
canvas.DrawText("Blue: Instant, Green: Avg, Red: Total",
new SKPoint(xOffset, _rendererHeight - TitleFontHeight), titleFont);
break;
}
canvas.Restore();
canvas.DrawLine(new SKPoint(xOffset + timingWidth, 0), new SKPoint(xOffset + timingWidth, _rendererHeight), textFont);
xOffset = _rendererWidth - 360;
// Display timestamps
long totalInstant = 0;
long totalAverage = 0;
long totalTime = 0;
long totalCount = 0;
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
float y = GetLineY(yOffset, LineHeight, LinePadding, true, verticalIndex);
canvas.DrawText($"{GetTimeString(entry.Value.Instant)} ({entry.Value.InstantCount})", new SKPoint(xOffset, y), textFont);
canvas.DrawText(GetTimeString(entry.Value.AverageTime), new SKPoint(150 + xOffset, y), textFont);
canvas.DrawText(GetTimeString(entry.Value.TotalTime), new SKPoint(260 + xOffset, y), textFont);
totalInstant += entry.Value.Instant;
totalAverage += entry.Value.AverageTime;
totalTime += entry.Value.TotalTime;
totalCount += entry.Value.InstantCount;
}
canvas.Restore();
canvas.DrawLine(new SKPoint(0, viewTop), new SKPoint(_rendererWidth, viewTop), titleFont);
float yHeight = 0 + TitleFontHeight;
canvas.DrawText("Instant (Count)", new SKPoint(xOffset, yHeight), titleFont);
canvas.DrawText("Average", new SKPoint(150 + xOffset, yHeight), titleFont);
canvas.DrawText("Total (ms)", new SKPoint(260 + xOffset, yHeight), titleFont);
// Totals
yHeight = _rendererHeight - FilterHeight + 3;
int textHeight = LineHeight - 2;
SKPaint detailFont = new SKPaint()
{
Color = new SKColor(100, 100, 255, 255),
TextSize = textHeight
};
canvas.DrawLine(new SkiaSharp.SKPoint(0, viewBottom), new SkiaSharp.SKPoint(_rendererWidth, viewBottom), textFont);
string hostTimeString = $"Host {GetTimeString(_timingFlagsLast[(int)TimingFlagType.SystemFrame])} " +
$"({GetTimeString(_timingFlagsAverages[(int)TimingFlagType.SystemFrame])})";
canvas.DrawText(hostTimeString, new SKPoint(5, yHeight), detailFont);
float tempWidth = detailFont.MeasureText(hostTimeString);
detailFont.Color = SKColors.Red;
string gameTimeString = $"Game {GetTimeString(_timingFlagsLast[(int)TimingFlagType.FrameSwap])} " +
$"({GetTimeString(_timingFlagsAverages[(int)TimingFlagType.FrameSwap])})";
canvas.DrawText(gameTimeString, new SKPoint(15 + tempWidth, yHeight), detailFont);
tempWidth += detailFont.MeasureText(gameTimeString);
detailFont.Color = SKColors.White;
canvas.DrawText($"Profiler: Update {GetTimeString(_lastOutputUpdateDuration)} Draw {GetTimeString(_lastOutputDrawDuration)}",
new SKPoint(20 + tempWidth, yHeight), detailFont);
detailFont.Color = SKColors.White;
canvas.DrawText($"{GetTimeString(totalInstant)} ({totalCount})", new SKPoint(xOffset, yHeight), detailFont);
canvas.DrawText(GetTimeString(totalAverage), new SKPoint(150 + xOffset, yHeight), detailFont);
canvas.DrawText(GetTimeString(totalTime), new SKPoint(260 + xOffset, yHeight), detailFont);
_lastOutputDrawDuration = PerformanceCounter.ElapsedTicks - _lastOutputDraw;
}
}
public void Draw(SKCanvas canvas, double screenWidth, double screenHeight, IWidget widget,
float layerOpacity)
{
var scaleBar = (ScaleBarWidget)widget;
if (!scaleBar.CanTransform())
{
return;
}
// If this is the first time, we call this renderer, ...
if (_paintScaleBar == null)
{
// ... than create the paints
_paintScaleBar = CreateScaleBarPaint(scaleBar.TextColor.ToSkia(layerOpacity), StrokeInternal, SKPaintStyle.Fill, scaleBar.Scale);
_paintScaleBarStroke = CreateScaleBarPaint(scaleBar.Halo.ToSkia(layerOpacity), StrokeExternal, SKPaintStyle.Stroke, scaleBar.Scale);
_paintScaleText = CreateTextPaint(scaleBar.TextColor.ToSkia(layerOpacity), 2, SKPaintStyle.Fill, scaleBar.Scale);
_paintScaleTextStroke = CreateTextPaint(scaleBar.Halo.ToSkia(layerOpacity), 2, SKPaintStyle.Stroke, scaleBar.Scale);
}
else
{
// Update paints with new values
_paintScaleBar.Color = scaleBar.TextColor.ToSkia(layerOpacity);
_paintScaleBar.StrokeWidth = StrokeInternal * scaleBar.Scale;
_paintScaleBarStroke.Color = scaleBar.Halo.ToSkia(layerOpacity);
_paintScaleBarStroke.StrokeWidth = StrokeExternal * scaleBar.Scale;
_paintScaleText.Color = scaleBar.TextColor.ToSkia(layerOpacity);
_paintScaleText.StrokeWidth = StrokeInternal * scaleBar.Scale;
_paintScaleText.Typeface = SKTypeface.FromFamilyName(scaleBar.Font.FontFamily, SKTypefaceStyle.Bold);
_paintScaleText.TextSize = (float)scaleBar.Font.Size * scaleBar.Scale;
_paintScaleTextStroke.Color = scaleBar.Halo.ToSkia(layerOpacity);
_paintScaleTextStroke.StrokeWidth = StrokeInternal * scaleBar.Scale;
_paintScaleTextStroke.Typeface = SKTypeface.FromFamilyName(scaleBar.Font.FontFamily, SKTypefaceStyle.Bold);
_paintScaleTextStroke.TextSize = (float)scaleBar.Font.Size * scaleBar.Scale;
}
float scaleBarLength1;
string scaleBarText1;
float scaleBarLength2;
string scaleBarText2;
(scaleBarLength1, scaleBarText1, scaleBarLength2, scaleBarText2) = scaleBar.GetScaleBarLengthAndText();
// Calc height of scale bar
SKRect textSize = SKRect.Empty;
// Do this, because height of text changes sometimes (e.g. from 2 m to 1 m)
_paintScaleTextStroke.MeasureText("9999 m", ref textSize);
var scaleBarHeight = textSize.Height + (scaleBar.TickLength + StrokeExternal * 0.5f + scaleBar.TextMargin) * scaleBar.Scale;
if (scaleBar.ScaleBarMode == ScaleBarMode.Both && scaleBar.SecondaryUnitConverter != null)
{
scaleBarHeight *= 2;
}
else
{
scaleBarHeight += StrokeExternal * 0.5f * scaleBar.Scale;
}
scaleBar.Height = scaleBarHeight;
// Draw lines
// Get lines for scale bar
var points = scaleBar.GetScaleBarLinePositions(scaleBarLength1, scaleBarLength2, StrokeExternal);
// BoundingBox for scale bar
BoundingBox envelop = new BoundingBox();
if (points != null)
{
// Draw outline of scale bar
for (int i = 0; i < points.Length; i += 2)
{
canvas.DrawLine((float)points[i].X, (float)points[i].Y, (float)points[i + 1].X, (float)points[i + 1].Y, _paintScaleBarStroke);
}
// Draw scale bar
for (int i = 0; i < points.Length; i += 2)
{
canvas.DrawLine((float)points[i].X, (float)points[i].Y, (float)points[i + 1].X, (float)points[i + 1].Y, _paintScaleBar);
}
envelop = points[0].BoundingBox;
for (int i = 1; i < points.Length; i++)
{
envelop = envelop.Join(points[i].BoundingBox);
}
envelop = envelop.Grow(StrokeExternal * 0.5f * scaleBar.Scale);
}
// Draw text
// Calc text height
SKRect textSize1 = SKRect.Empty;
SKRect textSize2 = SKRect.Empty;
scaleBarText1 = scaleBarText1 ?? string.Empty;
scaleBarText2 = scaleBarText2 ?? string.Empty;
_paintScaleTextStroke.MeasureText(scaleBarText1, ref textSize1);
_paintScaleTextStroke.MeasureText(scaleBarText2, ref textSize2);
var(posX1, posY1, posX2, posY2) = scaleBar.GetScaleBarTextPositions(textSize.ToMapsui(), textSize1.ToMapsui(), textSize2.ToMapsui(), StrokeExternal);
// Now draw text
canvas.DrawText(scaleBarText1, posX1, posY1 - textSize1.Top, _paintScaleTextStroke);
canvas.DrawText(scaleBarText1, posX1, posY1 - textSize1.Top, _paintScaleText);
envelop = envelop.Join(new BoundingBox(posX1, posY1, posX1 + textSize1.Width, posY1 + textSize1.Height));
if (scaleBar.ScaleBarMode == ScaleBarMode.Both && scaleBar.SecondaryUnitConverter != null)
{
// Now draw second text
canvas.DrawText(scaleBarText2, posX2, posY2 - textSize2.Top, _paintScaleTextStroke);
canvas.DrawText(scaleBarText2, posX2, posY2 - textSize2.Top, _paintScaleText);
envelop = envelop.Join(new BoundingBox(posX2, posY2, posX2 + textSize2.Width, posY2 + textSize2.Height));
}
scaleBar.Envelope = envelop;
if (scaleBar.ShowEnvelop)
{
// Draw a rect around the scale bar for testing
var tempPaint = _paintScaleTextStroke;
canvas.DrawRect(new SKRect((float)envelop.MinX, (float)envelop.MinY, (float)envelop.MaxX, (float)envelop.MaxY), tempPaint);
}
}
private void DrawGraph(float xOffset, float yOffset, float width, SKCanvas canvas)
{
if (_sortedProfileData.Count != 0)
{
int left, right;
float top, bottom;
float graphRight = xOffset + width;
float barHeight = (LineHeight - LinePadding);
long history = Profile.HistoryLength;
double timeWidthTicks = history / (double)_graphZoom;
long graphPositionTicks = (long)(_graphPosition * PerformanceCounter.TicksPerMillisecond);
long ticksPerPixel = (long)(timeWidthTicks / width);
// Reset start point if out of bounds
if (timeWidthTicks + graphPositionTicks > history)
{
graphPositionTicks = history - (long)timeWidthTicks;
_graphPosition = (float)graphPositionTicks / PerformanceCounter.TicksPerMillisecond;
}
graphPositionTicks = _captureTime - graphPositionTicks;
// Draw timing flags
if (_showFlags.Active)
{
TimingFlagType prevType = TimingFlagType.Count;
SKPaint timingPaint = new SKPaint
{
Color = _timingFlagColors.First()
};
foreach (TimingFlag timingFlag in _timingFlags)
{
if (prevType != timingFlag.FlagType)
{
prevType = timingFlag.FlagType;
timingPaint.Color = _timingFlagColors[(int)prevType];
}
int x = (int)(graphRight - ((graphPositionTicks - timingFlag.Timestamp) / timeWidthTicks) * width);
if (x > xOffset)
{
canvas.DrawLine(new SKPoint(x, yOffset), new SKPoint(x, _rendererHeight), timingPaint);
}
}
}
SKPaint barPaint = new SKPaint()
{
Color = SKColors.Green,
};
// Draw bars
for (int verticalIndex = 0; verticalIndex < _sortedProfileData.Count; verticalIndex++)
{
KeyValuePair <ProfileConfig, TimingInfo> entry = _sortedProfileData[verticalIndex];
long furthest = 0;
bottom = GetLineY(yOffset, LineHeight, LinePadding, false, verticalIndex);
top = bottom + barHeight;
// Skip rendering out of bounds bars
if (top < 0 || bottom > _rendererHeight)
{
continue;
}
barPaint.Color = SKColors.Green;
foreach (Timestamp timestamp in entry.Value.GetAllTimestamps())
{
// Skip drawing multiple timestamps on same pixel
if (timestamp.EndTime < furthest)
{
continue;
}
furthest = timestamp.EndTime + ticksPerPixel;
left = (int)(graphRight - ((graphPositionTicks - timestamp.BeginTime) / timeWidthTicks) * width);
right = (int)(graphRight - ((graphPositionTicks - timestamp.EndTime) / timeWidthTicks) * width);
left = (int)Math.Max(xOffset + 1, left);
// Make sure width is at least 1px
right = Math.Max(left + 1, right);
canvas.DrawRect(new SKRect(left, top, right, bottom), barPaint);
}
// Currently capturing timestamp
barPaint.Color = SKColors.Red;
long entryBegin = entry.Value.BeginTime;
if (entryBegin != -1)
{
left = (int)(graphRight - ((graphPositionTicks - entryBegin) / timeWidthTicks) * width);
// Make sure width is at least 1px
left = Math.Min(left - 1, (int)graphRight);
left = (int)Math.Max(xOffset + 1, left);
canvas.DrawRect(new SKRect(left, top, graphRight, bottom), barPaint);
}
}
string label = $"-{MathF.Round(_graphPosition, 2)} ms";
SKPaint labelPaint = new SKPaint()
{
Color = SKColors.White,
TextSize = LineHeight
};
float labelWidth = labelPaint.MeasureText(label);
canvas.DrawText(label, new SKPoint(graphRight - labelWidth - LinePadding, FilterHeight + LinePadding), labelPaint);
canvas.DrawText($"-{MathF.Round((float)((timeWidthTicks / PerformanceCounter.TicksPerMillisecond) + _graphPosition), 2)} ms",
new SKPoint(xOffset + LinePadding, FilterHeight + LinePadding), labelPaint);
}
}