void DisplayClipOp(SKCanvas canvas, SKRect rect, SKClipOperation clipOp)
{
float textSize = textPaint.TextSize;
canvas.DrawText(clipOp.ToString(), rect.MidX, rect.Top + textSize, textPaint);
rect.Top += textSize;
float radius = 0.9f * Math.Min(rect.Width / 3, rect.Height / 2);
float xCenter = rect.MidX;
float yCenter = rect.MidY;
canvas.Save();
using (SKPath path1 = new SKPath())
{
path1.AddCircle(xCenter - radius / 2, yCenter, radius);
canvas.ClipPath(path1);
using (SKPath path2 = new SKPath())
{
path2.AddCircle(xCenter + radius / 2, yCenter, radius);
canvas.ClipPath(path2, clipOp);
canvas.DrawPaint(fillPaint);
}
}
canvas.Restore();
}
public override void PreProcess(SKCanvas canvas, SKRect bounds, SKPaint paint)
{
// TODO: Lets see whether we can tell Artemis we only support layers
if (ProfileElement is not Layer layer || !layer.Leds.Any())
{
return;
}
// Find out how many LEDs to reveal according to the current percentage
int toReveal = Properties.RoundingFunction.CurrentValue switch
{
RoundingFunction.Round => (int)Math.Round(layer.Leds.Count / 100.0 * Math.Min(100, Properties.Percentage.CurrentValue), MidpointRounding.AwayFromZero),
RoundingFunction.Floor => (int)Math.Floor(layer.Leds.Count / 100.0 * Math.Min(100, Properties.Percentage.CurrentValue)),
RoundingFunction.Ceiling => (int)Math.Ceiling(layer.Leds.Count / 100.0 * Math.Min(100, Properties.Percentage.CurrentValue)),
_ => throw new ArgumentOutOfRangeException()
};
// If the amount hasn't changed, reuse the last path
if (toReveal == _lastToReveal && Properties.MaxVisibleLeds == _lastMaxVisible && _clipPath != null)
{
canvas.ClipPath(_clipPath);
return;
}
// Order LEDs by their position to create a nice revealing effect from left top right, top to bottom
List <ArtemisLed> leds = layer.Leds.OrderBy(l => l.AbsoluteRectangle.Top).ThenBy(l => l.AbsoluteRectangle.Left).ToList();
// Because rendering for effects is 0,0 based, zero out the position of LEDs starting at the top-left
float offsetX = leds.First().AbsoluteRectangle.Left;
float offsetY = leds.First().AbsoluteRectangle.Top;
// Create or reset the path
if (_clipPath == null)
{
_clipPath = new SKPath();
}
else
{
_clipPath.Reset();
}
IEnumerable <ArtemisLed> ledsEnumerable = leds.Take(toReveal);
if (Properties.LimitVisibleLeds)
{
ledsEnumerable = ledsEnumerable.Skip(toReveal - Properties.MaxVisibleLeds);
}
foreach (ArtemisLed artemisLed in ledsEnumerable)
{
_clipPath.AddRect(SKRect.Create(
artemisLed.AbsoluteRectangle.Left - offsetX,
artemisLed.AbsoluteRectangle.Top - offsetY,
artemisLed.AbsoluteRectangle.Width,
artemisLed.AbsoluteRectangle.Height));
}
canvas.ClipPath(_clipPath);
_lastMaxVisible = Properties.MaxVisibleLeds;
_lastToReveal = toReveal;
}
private void DrawShadow(SKCanvas canvas)
{
var pancake = Element as PancakeView;
if (pancake.Shadow != null)
{
SKPath path;
if (pancake.Sides != 4)
{
path = DrawingExtensions.CreatePolygonPath(Control.Geometry.Width, Control.Geometry.Height,
pancake.Sides, pancake.CornerRadius.TopLeft, pancake.OffsetAngle);
}
else
{
var left = Control.Geometry.Left - _skCanvasView.Geometry.Left;
var top = Control.Geometry.Top - _skCanvasView.Geometry.Top;
path = DrawingExtensions.CreateRoundedRectPath(left, top, left + Control.Geometry.Width, top + Control.Geometry.Height, pancake.CornerRadius);
}
using (var paint = new SKPaint())
{
paint.IsAntialias = true;
paint.Style = SKPaintStyle.StrokeAndFill;
var shadow = pancake.Shadow;
var scaledOffsetX = Forms.ConvertToScaledPixel(shadow.Offset.X);
var scaledOffsetY = Forms.ConvertToScaledPixel(shadow.Offset.Y);
var scaledBlurRadius = Forms.ConvertToScaledPixel(shadow.BlurRadius);
canvas.Save();
canvas.ClipPath(path, SKClipOperation.Difference, true);
paint.ImageFilter = SKImageFilter.CreateDropShadow(
scaledOffsetX,
scaledOffsetY,
scaledBlurRadius,
scaledBlurRadius,
shadow.Color.MultiplyAlpha(shadow.Opacity).ToNative().ToSKColor(),
SKDropShadowImageFilterShadowMode.DrawShadowOnly);
canvas.DrawPath(path, paint);
canvas.Restore();
canvas.Save();
canvas.ClipPath(path, SKClipOperation.Intersect, true);
canvas.DrawPath(path, paint);
canvas.Restore();
}
}
}
public override void Draw(SKCanvas canvas, RectangleF dirtyRect)
{
canvas.Clear(Color.Transparent.ToSKColor());
if (TypedVirtualView == null || drawMapper == null)
{
return;
}
canvas.Save();
var layers = LayerDrawingOrder();
var padding = this.GetPadding();
var rect = dirtyRect.ApplyPadding(padding);
foreach (var layer in layers)
{
drawMapper.DrawLayer(canvas, rect, this, TypedVirtualView, layer);
}
var clipShape = VirtualView?.GetClipShape() ?? VirtualView?.GetBorder();
if (clipShape != null)
{
canvas.ClipPath(clipShape.PathForBounds(rect).ToSKPath());
}
drawMapper.DrawLayer(canvas, rect, this, TypedVirtualView, SkiaEnvironmentKeys.Border);
canvas.Restore();
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
// Set transform to center and enlarge clip path to window height
SKRect bounds;
path.GetTightBounds(out bounds);
canvas.Translate(info.Width / 2, info.Height / 2);
canvas.Scale((0.5f * info.Height / bounds.Height) * -1);
canvas.Translate(-bounds.MidX, -bounds.MidY);
// Set the clip path
canvas.ClipPath(path, SKClipOperation.Difference);
// Reset transforms
canvas.ResetMatrix();
using (SKPaint paint2 = new SKPaint())
{
paint2.Style = SKPaintStyle.Fill;
paint2.Color = SKColors.Green.WithAlpha(0x50);
canvas.DrawPaint(paint2);
}
}
private void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
if (_pathToClip != null)
{
// Crop canvas before drawing image
canvas.ClipPath(_pathToClip);
}
canvas.DrawBitmap(_originalBitmap, info.Rect);
if (_pathToClip != null)
{
// Get cropped image byte array
var snap = surface.Snapshot();
var data = snap.Encode();
_bytearray = data.ToArray();
ManualCropView.IsVisible = false;
CropButton.IsVisible = false;
DisplayCroppedButton.IsVisible = true;
}
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
// Set transform to center and enlarge clip path to window height
SKRect bounds;
keyholePath.GetTightBounds(out bounds);
canvas.Translate(info.Width / 2, info.Height / 2);
canvas.Scale(0.98f * info.Height / bounds.Height);
canvas.Translate(-bounds.MidX, -bounds.MidY);
// Set the clip path
canvas.ClipPath(keyholePath);
// Reset transforms
canvas.ResetMatrix();
// Display monkey to fill height of window but maintain aspect ratio
canvas.DrawBitmap(bitmap,
new SKRect((info.Width - info.Height) / 2, 0,
(info.Width + info.Height) / 2, info.Height));
}
public void Draw(SKCanvas c, SKPath path, SKPaint paint, SKRect rect)
{
if (GradientColors == null)
{
return;
}
int save = c.Save();
c.ClipPath(path);
using (var gradient = SKShader.CreateLinearGradient(
SKPoint.Empty,
new SKPoint(rect.Width,
rect.Height),
GradientColors,
ColorPos,
SKShaderTileMode.Mirror))
{
var previousStyle = paint.Style;
paint.Style = SKPaintStyle.Fill;
paint.Shader = gradient;
c.DrawPath(path, paint);
paint.Style = previousStyle;
}
c.RestoreToCount(save);
}
public void Fill(SKCanvas canvas, SKPath path)
{
using (var paint = new SKPaint()
{
IsAntialias = true,
Style = SKPaintStyle.Fill,
})
{
canvas.Save();
try
{
using (var img = SKImage.FromBitmap(Source))
{
paint.Color = SKColors.White.WithAlpha((byte)(this.Opacity * 255));
canvas.ClipPath(path);
canvas.DrawImage(img, path.Bounds, paint);
}
}
catch (Exception e)
{
using (var errorPaint = new SKPaint
{
Color = SKColors.Red,
Style = SKPaintStyle.Fill,
})
{
canvas.DrawRect(path.Bounds, errorPaint);
errorPaint.Color = SKColors.White;
canvas.DrawText(e.Message, path.Bounds.MidX, path.Bounds.MidY, errorPaint);
}
}
canvas.Restore();
}
}
public void DrawHole(SKCanvas canvas, SKRect rect, float scale = 1)
{
using (SKPath path = new SKPath())
{
path.AddCircle(rect.Left + rect.Width / 2, rect.Top + rect.Height / 2, rect.Width / 2);
canvas.ClipPath(path, SKClipOperation.Difference);
}
}
public void Close()
{
canvas.ClipPath(clip, SKClipOperation.Intersect, true);
canvas.DrawImage(SKImage.FromBitmap(noise), new SKPoint(0, 0));
canvas.DrawImage(surface.Snapshot(), new SKPoint(0, 0), paint);
canvas.Restore();
}
/// <summary>
/// Draws the provided path in filled mode with the provided color and alpha.
/// Special thanks to Angelo Suzuki (https://github.com/tinsukE) for this.
protected void DrawFilledPath(SKCanvas c, SKPath filledPath, SKColor fillColor, byte fillAlpha)
{
int save = c.Save();
c.ClipPath(filledPath);
c.DrawColor(fillColor.WithAlpha(fillAlpha), SKBlendMode.SrcOver);
c.RestoreToCount(save);
}
internal void SetClipPath(SvgVisualElement svgVisualElement, CompositeDisposable disposable)
{
var skPathClip = SkiaUtil.GetSvgVisualElementClipPath(svgVisualElement, disposable);
if (skPathClip != null && !skPathClip.IsEmpty)
{
bool antialias = SkiaUtil.IsAntialias(svgVisualElement);
_skCanvas.ClipPath(skPathClip, SKClipOperation.Intersect, antialias);
}
}
public static void ClipCanvas(SKCanvas canvas, RectangleF dirtyRect, SkiaControl control, View view)
{
var border = control?.GetBorder();
var clipShape = control?.GetClipShape() ?? border;
if (clipShape != null)
{
canvas.ClipPath(clipShape.PathForBounds(dirtyRect).ToSKPath());
}
}
void DrawClippingMask(SKCanvas canvas, SKImageInfo info)
{
//Move clipping mask
var xPos = sliderPosition - clipPath.TightBounds.MidX;
clipPath.Transform(SKMatrix.MakeTranslation(xPos, 0));
//Draw clipping mask
canvas.ClipPath(clipPath, SKClipOperation.Difference, true);
}
private void DrawBorder(SKCanvas canvas)
{
var pancake = Element as PancakeView;
if (pancake.Border != null && pancake.Border.Thickness != default)
{
using (var paint = new SKPaint())
{
var border = pancake.Border;
paint.Style = SKPaintStyle.Stroke;
paint.Color = border.Color.ToNative().ToSKColor();
paint.StrokeWidth = Forms.ConvertToScaledPixel(border.Thickness);
paint.IsAntialias = true;
SKPath path;
if (pancake.Sides != 4)
{
path = DrawingExtensions.CreatePolygonPath(Control.Geometry.Width, Control.Geometry.Height,
pancake.Sides, pancake.CornerRadius.TopLeft, pancake.OffsetAngle);
}
else
{
var left = Control.Geometry.Left - _skCanvasView.Geometry.Left;
var top = Control.Geometry.Top - _skCanvasView.Geometry.Top;
path = DrawingExtensions.CreateRoundedRectPath(left, top, left + Control.Geometry.Width, top + Control.Geometry.Height, pancake.CornerRadius);
}
if (border.DashPattern.Pattern != null &&
border.DashPattern.Pattern.Length > 0 &&
(border.DashPattern.Pattern.Length % 2 == 0 || border.DashPattern.Pattern.Length == 1))
{
var items = border.DashPattern.Pattern.Select(x => Convert.ToSingle(x)).ToList();
if (items.Count == 1)
{
items.Add(items[0]);
}
paint.PathEffect = SKPathEffect.CreateDash(items.ToArray(), 0);
}
if (border.GradientStops != null && border.GradientStops.Any())
{
var startPoint = new SKPoint((float)(border.GradientStartPoint.X * Control.Geometry.Width), (float)(border.GradientStartPoint.Y * Control.Geometry.Height));
var endPoint = new SKPoint((float)(border.GradientEndPoint.X * Control.Geometry.Width), (float)(border.GradientEndPoint.Y * Control.Geometry.Height));
var orderedStops = border.GradientStops.OrderBy(x => x.Offset).ToList();
var gradientColors = orderedStops.Select(x => x.Color.ToNative().ToSKColor()).ToArray();
var gradientColorPos = orderedStops.Select(x => x.Offset).ToArray();
paint.Shader = SKShader.CreateLinearGradient(startPoint, endPoint, gradientColors, gradientColorPos, SKShaderTileMode.Clamp);
}
canvas.ClipPath(path, SKClipOperation.Intersect, true);
canvas.DrawPath(path, paint);
}
}
}
private void ImageSkiaCanvas_PaintSurface(object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
SKRect imageRect = new SKRect(0, 0, info.Width, info.Height);
// render out the bitmap
SKRect outgoingImageRect;
if (transitionValue >= 1)
{
outgoingImageRect = new SKRect(0 - (float)outgoingOffset, 0, info.Width, info.Height);
}
else
{
outgoingImageRect = new SKRect(0, 0, info.Width, info.Height);
}
canvas.DrawBitmap(currentBitmap, outgoingImageRect, BitmapStretch.AspectFill);
if (transitionValue <= 0)
{
return;
}
// draw our clipping path
if (offscreenBitmap != null)
{
// animate int the rect that the image is being rendered to
int movementAmount = 600;
float offset = (float)(movementAmount - (movementAmount * (transitionValue / 2)));
SKRect incomingRect = new SKRect(0, 0, info.Width + offset, info.Height);
// draw the faded version of the image
using (SKPaint transparentPaint = new SKPaint())
{
var opacity = Math.Max((transitionValue - .5) * .5, 0);
transparentPaint.Color = transparentPaint.Color.WithAlpha((byte)(0xFF * opacity));
canvas.DrawBitmap(
bitmap: offscreenBitmap,
dest: incomingRect,
stretch: BitmapStretch.AspectFill,
paint: transparentPaint);
}
var clipPath = CalculateClipPath(info, transitionValue);
canvas.ClipPath(clipPath, SKClipOperation.Intersect);
canvas.DrawBitmap(offscreenBitmap, incomingRect, BitmapStretch.AspectFill);
}
}
static void PrepBitmap(SKCanvas bitmapCanvas, int bitmapSize)
{
// Set clipping path based on bitmap size
using (SKPath bitmapClipPath = new SKPath())
{
bitmapClipPath.AddCircle(bitmapSize / 2, bitmapSize / 2, bitmapSize / 2);
bitmapCanvas.ClipPath(bitmapClipPath);
}
// Color the bitmap background
bitmapCanvas.Clear(backgroundColor);
}
void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
{
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
float size = Math.Min(info.Width, info.Height);
float radius = 0.4f * size;
float offset = size / 2 - radius;
// Translate to center
canvas.Translate(info.Width / 2, info.Height / 2);
using (SKPath path = new SKPath())
{
path.AddCircle(-offset, -offset, radius);
canvas.ClipPath(path, SKClipOperation.Intersect);
path.Reset();
path.AddCircle(-offset, offset, radius);
canvas.ClipPath(path, SKClipOperation.Intersect);
path.Reset();
path.AddCircle(offset, -offset, radius);
canvas.ClipPath(path, SKClipOperation.Intersect);
path.Reset();
path.AddCircle(offset, offset, radius);
canvas.ClipPath(path, SKClipOperation.Intersect);
using (SKPaint paint = new SKPaint())
{
paint.Style = SKPaintStyle.Fill;
paint.Color = SKColors.Blue;
canvas.DrawPaint(paint);
}
}
}
protected override void DrawMarks(SKCanvas c)
{
// Get the rect vectors
var pTR = new SKPoint(p1.X, p0.Y);
var pBL = new SKPoint(p0.X, p1.Y);
var vHorizontal = new SKPoint(p1.X - p0.X, 0);
var vVertical = new SKPoint(0, p1.Y - p0.Y);
// Clip path as defined by the oval
var clipBounds = new SKRect(
frame.Bounds.Left + 3,
frame.Bounds.Top + 3,
frame.Bounds.Right - 3,
frame.Bounds.Bottom - 3);
var clipPath = new SKPath();
clipPath.AddOval(clipBounds);
// Draw all visible marks
foreach (var mark in marks)
{
if (!mark.Visible)
{
continue;
}
// Clip all marks but Endpoints (they're the bounding box)
if (mark.MarkId != MarkId.Endpoint)
{
c.Save();
c.ClipPath(clipPath);
}
foreach (var m in mark.Pos)
{
// Positions relative the the sides
var v0 = p0.Pos + vHorizontal.Scale(m);
var v1 = pBL + vHorizontal.Scale(m);
var h0 = p0.Pos + vVertical.Scale(m);
var h1 = pTR + vVertical.Scale(m);
// Draw them
c.DrawLine(v0, v1, mark.PaintMark);
c.DrawLine(h0, h1, mark.PaintMark);
}
if (mark.MarkId != MarkId.Endpoint)
{
c.Restore();
}
}
}
private void CanvasView_PaintSurface(object sender, SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
if (lastSize.Width != info.Width || lastSize.Height != info.Height)
{
lastSize.Width = info.Width;
lastSize.Height = info.Height;
radius = (float)Math.Min(lastSize.Width, lastSize.Height);
isChanged = true;
}
if (isChanged)
{
circleMaskPath = CreateCircleMaskPath(info.Width, info.Height);
isChanged = false;
}
wavePath = CreateWaveMaskPath(info.Width, info.Height, radius / 5 / 2 / 2 / 2, transX, transY, 5);
if (wavePaint == null)
{
wavePaint = new SKPaint
{
Style = SKPaintStyle.Fill,
Color = FullColor.ToSKColor()
};
}
SKPath cirlePath = new SKPath();
cirlePath.AddCircle(info.Width / 2, info.Height / 2, Math.Min(info.Width, info.Height) / 2);
canvas.ClipPath(cirlePath);
canvas.DrawPath(cirlePath, circlePaint);
canvas.DrawPath(wavePath, wavePaint);
//canvas.DrawPath(circleMaskPath, circlePaint);
if (isAnimate == false)
{
Animate();
isAnimate = true;
}
}
/// <summary>
/// draws the description text in the center of the pie chart makes most
/// sense when center-hole is enabled
/// </summary>
/// <param name="c"></param>
partial void DrawCenterText(SKCanvas c)
{
var centerText = Chart.CenterText;
if (Chart.DrawCenterTextEnabled && centerText != null)
{
var center = Chart.CenterCircleBox;
var offset = Chart.CenterTextOffset;
float x = center.X + offset.X;
float y = center.Y + offset.Y;
float innerRadius = Chart.DrawHoleEnabled && !Chart.DrawSlicesUnderHoleEnabled
? Chart.Radius * (Chart.HoleRadius / 100f)
: Chart.Radius;
var holeRect = SKRect.Empty;
holeRect.Left = x - innerRadius;
holeRect.Top = y - innerRadius;
holeRect.Right = x + innerRadius;
holeRect.Bottom = y + innerRadius;
var boundingRect = holeRect;
float radiusPercent = Chart.CenterTextRadiusPercent / 100f;
if (radiusPercent > 0.0)
{
boundingRect = boundingRect.Inset(
(boundingRect.Width - boundingRect.Width * radiusPercent) / 2.0f,
(boundingRect.Height - boundingRect.Height * radiusPercent) / 2.0f
);
}
//float layoutWidth = Utils.getStaticLayoutMaxWidth(mCenterTextLayout);
c.Save();
var path = DrawCenterTextPathBuffer;
path.Reset();
path.AddOval(holeRect, SKPathDirection.Clockwise);
c.ClipPath(path);
using (var layout = new Components.TextLayout()
{
VerticalAlignment = Xamarin.Forms.TextAlignment.Center,
HorizontalAlign = Xamarin.Forms.TextAlignment.Center
})
{
layout.Draw(c, centerText, boundingRect);
}
c.Restore();
}
}
/// <summary>
/// Opens the render context using the dimensions of the provided path
/// </summary>
public void Open(SKPath path, Folder?parent)
{
if (_disposed)
{
throw new ObjectDisposedException("Renderer");
}
if (IsOpen)
{
throw new ArtemisCoreException("Cannot open render context because it is already open");
}
if (path.Bounds != _lastBounds || (parent != null && parent.Bounds != _lastParentBounds))
{
Invalidate();
}
if (!_valid || Canvas == null)
{
SKRect pathBounds = path.Bounds;
int width = (int)pathBounds.Width;
int height = (int)pathBounds.Height;
Bitmap = new SKBitmap(width, height);
Path = new SKPath(path);
Canvas = new SKCanvas(Bitmap);
Path.Transform(SKMatrix.CreateTranslation(pathBounds.Left * -1, pathBounds.Top * -1));
TargetLocation = new SKPoint(pathBounds.Location.X, pathBounds.Location.Y);
if (parent != null)
{
TargetLocation -= parent.Bounds.Location;
}
Canvas.ClipPath(Path);
_lastParentBounds = parent?.Bounds ?? new SKRect();
_lastBounds = path.Bounds;
_valid = true;
}
Paint = new SKPaint();
Canvas.Clear();
Canvas.Save();
IsOpen = true;
}
internal override void InternalRender(SKCanvas canvas, SKImageInfo canvasInfo, SKPath path, SKPaint paint)
{
// We don't want translations on this canvas because that'll displace the LEDs, translations are applied to the points of each LED instead
Layer.ExcludeCanvasFromTranslation(canvas, true);
if (Layer.General.ResizeMode == LayerResizeMode.Normal)
{
// Apply a translated version of the shape as the clipping mask
SKPath shapePath = new SKPath(Layer.LayerShape.Path);
Layer.IncludePathInTranslation(shapePath, true);
canvas.ClipPath(shapePath);
}
using SKPath pointsPath = new SKPath();
using SKPaint ledPaint = new SKPaint();
foreach (ArtemisLed artemisLed in Layer.Leds)
{
pointsPath.AddPoly(new[]
{
new SKPoint(0, 0),
new SKPoint(artemisLed.AbsoluteRenderRectangle.Left - Layer.Bounds.Left, artemisLed.AbsoluteRenderRectangle.Top - Layer.Bounds.Top)
});
}
Layer.ExcludePathFromTranslation(pointsPath, true);
SKPoint[] points = pointsPath.Points;
for (int index = 0; index < Layer.Leds.Count; index++)
{
ArtemisLed artemisLed = Layer.Leds[index];
SKPoint renderPoint = points[index * 2 + 1];
if (!float.IsFinite(renderPoint.X) || !float.IsFinite(renderPoint.Y))
{
continue;
}
// Let the brush determine the color
ledPaint.Color = GetColor(artemisLed, renderPoint);
SKRect ledRectangle = SKRect.Create(
artemisLed.AbsoluteRenderRectangle.Left - Layer.Bounds.Left,
artemisLed.AbsoluteRenderRectangle.Top - Layer.Bounds.Top,
artemisLed.AbsoluteRenderRectangle.Width,
artemisLed.AbsoluteRenderRectangle.Height
);
canvas.DrawRect(ledRectangle, ledPaint);
}
}
public override void Awake(NSObject context)
{
base.Awake(context);
var scale = WKInterfaceDevice.CurrentDevice.ScreenScale;
var bitmap = new SKBitmap((int)(ContentFrame.Width * scale), (int)(ContentFrame.Height * scale));
var colors = new[] { SKColors.Cyan, SKColors.Magenta, SKColors.Yellow, SKColors.Cyan };
var center = new SKPoint(bitmap.Width / 2, bitmap.Height / 2);
using (var canvas = new SKCanvas(bitmap))
{
canvas.Clear(SKColors.Transparent);
using (var path = new SKPath())
{
path.AddRoundedRect(new SKRect(5, 5, bitmap.Width - 5, bitmap.Height - 5), 5, 5);
canvas.ClipPath(path);
}
using (var paint = new SKPaint())
using (var gradient = SKShader.CreateSweepGradient(center, colors, null))
{
paint.IsAntialias = true;
paint.Shader = gradient;
canvas.DrawPaint(paint);
paint.Shader = null;
}
using (var paint = new SKPaint())
using (var tf = SKTypeface.FromFamilyName("San Fransisco"))
{
paint.IsAntialias = true;
paint.Color = SKColors.DarkBlue;
paint.TextSize = (float)(20 * scale);
paint.TextAlign = SKTextAlign.Center;
paint.Typeface = tf;
canvas.DrawText("SkiaSharp", center.X, (center.Y / 2) + (paint.TextSize / 2), paint);
}
}
var image = bitmap.ToUIImage(scale, UIKit.UIImageOrientation.Up);
imageView.SetImage(image);
}
private async void HandlePaintCanvas(object sender, SKPaintSurfaceEventArgs e)
{
SKImageInfo info = e.Info;
SKCanvas canvas = e.Surface.Canvas;
canvas.Clear();
if (_doSave)
{
using (var hole = new SKPath()) {
hole.AddCircle(info.Width / 2, info.Height / 2, info.Width / 3);
canvas.ClipPath(hole, antialias: true);
}
}
canvas.SetMatrix(_m);
//Draw ball image
SKSize imgSize = new SKSize(_bitmap.Width, _bitmap.Height);
SKRect aspectRect = SKRect.Create(info.Width, info.Height).AspectFit(imgSize);
canvas.DrawBitmap(_bitmap, aspectRect);
if (!_doSave)
{
canvas.ResetMatrix();
//Draw circle overlay
using (var frame = new SKPath())
using (var hole = new SKPath()) {
frame.AddRect(info.Rect);
hole.AddCircle(info.Width / 2, info.Height / 2, info.Width / 3);
SKPath frameHole = frame.Op(hole, SKPathOp.Difference);
using (var p = new SKPaint {
IsAntialias = true, Style = SKPaintStyle.Fill, Color = new SKColor(128, 128, 128, 200)
}) {
canvas.DrawPath(frameHole, p);
}
}
}
else
{
SKImage snapI = e.Surface.Snapshot();
snapI = snapI.Subset(canvas.DeviceClipBounds);
SKData pngImage = snapI.Encode();
File.WriteAllBytes(_ballFilename, pngImage.ToArray());
await Navigation.PopAsync();
OnBallImageUpdated(_ballFilename);
}
}
public static byte[] CreateRoundImage(byte[] data, int size)
{
using (var bitmap = SKBitmap.Decode(data))
using (var resultBitmap = new SKBitmap(size, size))
using (var canvas = new SKCanvas(resultBitmap))
using (var path = new SKPath())
{
var widthHeight = Math.Min(bitmap.Width, bitmap.Height);
var scale = (float)size / widthHeight;
canvas.Clear();
path.AddCircle(size / 2, size / 2, size / 2);
canvas.ClipPath(path);
canvas.Scale(scale, scale);
canvas.DrawBitmap(bitmap, (widthHeight - bitmap.Width) / 2, (widthHeight - bitmap.Height) / 2);
return(ToPngData(resultBitmap));
}
}
private void DrawInnerBlurRectangle(SKCanvas canvas, SKRect rect)
{
// create the rounded rectangle
var roundedRect = new SKPath();
roundedRect.AddRoundRect(rect, 10, 10);
// draw the white background
var p = new SKPaint
{
IsAntialias = true,
Style = SKPaintStyle.Fill,
Color = SKColors.White
};
canvas.DrawPath(roundedRect, p);
using (new SKAutoCanvasRestore(canvas))
{
// clip the canvas to stop the blur from appearing outside
canvas.ClipPath(roundedRect, SKClipOperation.Intersect, true);
// draw the wide blur all around
p.Color = SKColors.Black;
p.Style = SKPaintStyle.Stroke;
p.StrokeWidth = 2;
p.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, 2);
canvas.Translate(0.5f, 1.5f);
canvas.DrawPath(roundedRect, p);
// draw the narrow blur at the top
p.StrokeWidth = 1;
p.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, 1);
canvas.DrawPath(roundedRect, p);
}
// draw the border
p.StrokeWidth = 2;
p.MaskFilter = null;
p.Color = SampleMedia.Colors.XamarinGreen;
canvas.DrawPath(roundedRect, p);
}
public static SKCanvas ClippingText(this SKCanvas canvas, SKImageInfo info, string text, SKPaint paint)
{
using (SKPath textPath = paint.GetTextPath(text, 0, 0))
{
// Set transform to center and enlarge clip path to window height
SKRect bounds;
textPath.GetTightBounds(out bounds);
textPath.FillType = SKPathFillType.InverseWinding;
canvas.Translate(info.Width / 2, info.Height / 2);
canvas.Scale((info.Width / bounds.Width) * 0.9f, (info.Height / bounds.Height) * 0.9f);
canvas.Translate(-bounds.MidX, -bounds.MidY);
// Set the clip path
canvas.ClipPath(textPath);
}
// Reset transforms
canvas.ResetMatrix();
return(canvas);
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs args)
{
base.OnPaintSurface(args);
SKImageInfo info = args.Info;
SKSurface surface = args.Surface;
SKCanvas canvas = surface.Canvas;
canvas.Clear();
CircularPath.GetBounds(out SKRect bounds);
canvas.Translate(info.Width / 2, info.Height / 2);
canvas.Scale(0.98f * info.Height / bounds.Height);
canvas.Translate(-bounds.MidX, -bounds.MidY);
canvas.ClipPath(CircularPath);
canvas.ResetMatrix();
if (_resourceBitmap != null)
{
canvas.DrawBitmap(_resourceBitmap, info.Rect);
}
}
