private IImage BuildTerrainImage(int columns, int rows)
{
using IImageCanvas textureImage = _imageFactory.CreateImageCanvas(columns, rows);
textureImage.Canvas.DrawRect(0, 0, columns, rows,
new PaintBrush
{
Style = PaintStyle.Fill,
Color = TerrainColourLookup.DefaultColour
});
foreach (Terrain terrain in _terrainMap)
{
Color colour = TerrainColourLookup.GetTerrainColour(terrain);
if (colour == TerrainColourLookup.DefaultColour)
{
continue;
}
textureImage.Canvas.DrawRect(terrain.Column, terrain.Row, 1, 1,
new PaintBrush
{
Style = PaintStyle.Fill,
Color = colour
});
}
return(textureImage.Render());
}
public ShapeView(AppKit.NSImageView imageView) : base(imageView)
{
var size = new NGraphics.Size(1, 1);
canvas = Platforms.Current.CreateImageCanvas(size, scale: 2);
Refresh(size);
}
public ShapeView()
{
var size = new Size(1, 1);
canvas = Platforms.Current.CreateImageCanvas(size, 2);
Refresh(size);
}
protected override void OnChangeFrameSize(LiteForms.Size newSize)
{
var size = new Size(newSize.Width, newSize.Height);
canvas = Platforms.Current.CreateImageCanvas(size, 2);
Refresh(size);
}
public override void OnChangeFrameSize(LiteForms.Size newSize)
{
var size = newSize.ToNGraphicSize();
canvas = Platforms.Current.CreateImageCanvas(size, scale: 2);
Refresh(size);
base.OnChangeFrameSize(newSize);
}
protected override void OnDraw(IImageCanvas canvas)
{
//canvas.Translate(Allocation.Width/2f, Allocation.Height / 2f);
canvas.DrawEllipse(
new Rect(new Size(canvas.Size.Width - 1, canvas.Size.Height - 1)),
pen: Pen,
brush: Brush);
}
protected override void OnDraw(IImageCanvas canvas)
{
canvas.DrawEllipse(
new Rect(0, 0, Width, Height),
new Pen(
Color.ToNGraphicColor(),
StrokeThickness
));
}
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper)
{
if (pixelMapper.CellSize != _lastCellSize)
{
_cache.Clear();
_lastCellSize = pixelMapper.CellSize;
}
foreach (T entity in _layout)
{
(int x, int y, bool onScreen) = pixelMapper.CoordsToViewPortPixels(entity.Column, entity.Row);
if (!onScreen)
{
continue;
}
canvas.Save();
canvas.Translate(x, y);
if (_renderer is ICachableRenderer <T> cachableRenderer)
{
canvas.ClipRect(new Rectangle(0, 0, pixelMapper.CellSize, pixelMapper.CellSize), false);
string key = cachableRenderer.GetCacheKey(entity);
if (!_cache.TryGetValue(key, out IImage cachedImage))
{
using IImageCanvas imageCanvas = _imageFactory.CreateImageCanvas(pixelMapper.CellSize, pixelMapper.CellSize);
float scale = pixelMapper.CellSize / 100.0f;
imageCanvas.Canvas.Scale(scale, scale);
_renderer.Render(imageCanvas.Canvas, entity);
cachedImage = imageCanvas.Render();
_cache[key] = cachedImage;
}
canvas.DrawImage(cachedImage, 0, 0);
}
else
{
float scale = pixelMapper.CellSize / 100.0f;
canvas.Scale(scale, scale);
_renderer.Render(canvas, entity);
}
canvas.Restore();
}
}
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper)
{
if (pixelMapper.CellSize != _lastCellSize)
{
_imageCache.Clear();
_lastCellSize = pixelMapper.CellSize;
}
foreach (T entity in _layout)
{
var renderer = _renderers.FirstOrDefault(r => r.ShouldRender(entity));
if (renderer is null)
{
// TODO: Fill with Red to indicate error?
continue;
}
(int x, int y, bool onScreen) = pixelMapper.CoordsToViewPortPixels(entity.Column, entity.Row);
if (!onScreen)
{
continue;
}
string key = $"{entity.GetType().Name}.{entity.Identifier}";
if (_imageCache.IsDirty(key))
{
using IImageCanvas imageCanvas = _imageFactory.CreateImageCanvas(pixelMapper.CellSize, pixelMapper.CellSize);
float scale = pixelMapper.CellSize / 100.0f;
imageCanvas.Canvas.Scale(scale, scale);
renderer.Render(imageCanvas.Canvas, entity);
_imageCache.Set(key, imageCanvas.Render());
}
using (canvas.Scope())
{
canvas.Translate(x, y);
canvas.ClipRect(new Rectangle(0, 0, pixelMapper.CellSize, pixelMapper.CellSize), false, false);
canvas.DrawImage(_imageCache.Get(key) !, 0, 0);
}
}
}
public IImage GetTerrainImage()
{
if (_imageCache.IsDirty(this))
{
int width = _pixelMapper.Columns;
int _height = _pixelMapper.Rows;
using IImageCanvas textureImage = _imageFactory.CreateImageCanvas(width, _height);
foreach (Terrain terrain in _terrainMap)
{
Color colour = GetTerrainColour(terrain);
PaintBrush paint = GetPaint(colour);
textureImage.Canvas.DrawRect(terrain.Column, terrain.Row, 1, 1, paint);
}
_imageCache.Set(this, textureImage.Render());
Changed?.Invoke(this, EventArgs.Empty);
}
return(_imageCache.Get(this) !);
}
public async Task SaveImage(IImageCanvas canvas, string name)
{
await SaveImage(canvas.GetImage(), name);
}
protected override void OnDraw(IImageCanvas canvas)
{
OnSvgDraw(canvas, g);
g?.Draw(canvas);
}
public Task SaveImage (IImageCanvas canvas, string name)
{
return SaveImage (canvas.GetImage (), name);
}
public Task SaveImage(IImageCanvas canvas, string name)
{
return(SaveImage(canvas.GetImage(), name));
}
protected override void OnDraw(IImageCanvas canvas)
{
g?.Draw(canvas);
}
protected abstract void OnDraw(IImageCanvas canvas);
public async Task SaveImage(IImageCanvas canvas, string name)
{
await SaveImage(canvas.GetImage(), name);
}
private async Task <string> CreateBadge(CancellationToken token)
{
//Get the badge icon
IImage badgeIcon = null;
if (_mode == Mode.File)
{
badgeIcon = await _canvasService.GetImage(FileIcon, token);
}
else if (_mode == Mode.Svg)
{
badgeIcon = await _canvasService.GetSvgImage(SvgIcon, SvgWidth, SvgHeight, token);
}
if (badgeIcon == null)
{
return(null);
}
token.ThrowIfCancellationRequested();
IImageCanvas canvas = null;
if (IsBadgeVisible)
{
//InitializeCache frames
var font = new Font(null, BadgeFontSize);
var metrics = _canvasService.MeasureText(BadgeCount.ToString(), font);
var textSize = metrics.Size;
var badgeSize = new Size(BadgePadding.Left + BadgePadding.Right + textSize.Width,
BadgePadding.Top + BadgePadding.Bottom + textSize.Height);
var canvasSize = new Size(badgeIcon.Size.Width + badgeSize.Width - BadgeInsets.Width,
badgeIcon.Size.Height + badgeSize.Height - BadgeInsets.Height);
//Create canvas
canvas = _canvasService.GetCanvas(canvasSize);
token.ThrowIfCancellationRequested();
//Draw icon
var imageFrame = new Rect(0, badgeSize.Height - BadgeInsets.Height, badgeIcon.Size.Width,
badgeIcon.Size.Height);
canvas.DrawImage(badgeIcon, imageFrame);
token.ThrowIfCancellationRequested();
//Draw the badge rounded rect
var badgeFrame = new Rect(badgeIcon.Size.Width - BadgeInsets.Width, 0, badgeSize.Width,
badgeSize.Height);
var color = GetColor(BadgeColor);
var badgeImage = _canvasService.GetRoundedImage(badgeFrame.Size, color, BadgeRadius);
canvas.DrawImage(badgeImage, badgeFrame);
token.ThrowIfCancellationRequested();
//Draw badge text
var textFrame = new Rect(badgeFrame.X + BadgePadding.Left,
badgeFrame.Y + BadgePadding.Top + metrics.Ascent, textSize.Width, textSize.Height);
canvas.DrawText(BadgeCount.ToString(), textFrame, font, TextAlignment.Center,
GetColor(BadgeTextColor));
}
else
{
//Create canvas
canvas = _canvasService.GetCanvas(badgeIcon.Size);
token.ThrowIfCancellationRequested();
//Draw icon
var imageFrame = new Rect(0, 0, badgeIcon.Size.Width, badgeIcon.Size.Height);
canvas.DrawImage(badgeIcon, imageFrame);
}
token.ThrowIfCancellationRequested();
//Get the result image
var image = canvas.GetImage();
//Save the image to cache
var filename = GetBadgeCacheFileName();
var path = PortablePath.Combine(_cacheFolder.Path, filename);
await _canvasService.SaveImage(image, _cacheFolder.Path, filename, token);
return(path);
}
public EasyCanvas(int width, int height)
{
canvas = Platforms.Current.CreateImageCanvas(new Size(width, height), scale: 2);
}
protected virtual void OnSvgDraw(IImageCanvas canvas, Graphic graphic)
{
}
