/// <summary>
/// Sets the left.
/// </summary>
/// <param name="definition">The definition.</param>
public void SetLeft(IDefinition definition)
{
async Task parseImage()
{
var mutex = await leftImageLock.LockAsync();
var left = LeftImage;
if (definition != null)
{
LeftImageInfo = string.Empty;
LeftImage = null;
left?.Dispose();
LeftHeight = LeftWidth = 0;
using var ms = await modService.GetImageStreamAsync(definition?.ModName, definition?.File);
if (ms != null)
{
try
{
LeftImage = new Bitmap(ms);
var imageHeight = (LeftImage?.PixelSize.Width).GetValueOrDefault();
var imageWidth = (LeftImage?.PixelSize.Height).GetValueOrDefault();
var info = localizationManager.GetResource(LocalizationResources.Conflict_Solver.ImageInfo);
LeftImageInfo = Smart.Format(info, new { Width = imageWidth, Height = imageHeight });
LeftHeight = imageHeight;
LeftWidth = imageWidth;
}
catch (Exception ex)
{
logger.Error(ex);
LeftImageInfo = string.Empty;
LeftImage = null;
left?.Dispose();
LeftHeight = LeftWidth = 0;
}
}
}
else
{
LeftImageInfo = string.Empty;
LeftImage = null;
left?.Dispose();
LeftHeight = LeftWidth = 0;
}
await Task.Delay(10);
mutex.Dispose();
}
Task.Run(() => parseImage().ConfigureAwait(false)).ConfigureAwait(false);
}
/// <summary>
/// Sets the left.
/// </summary>
/// <param name="definition">The definition.</param>
public void SetLeft(IDefinition definition)
{
var loadingImage = false;
async Task loadImage()
{
while (loadingImage)
{
await Task.Delay(25);
}
loadingImage = true;
LeftImageInfo = string.Empty;
var left = LeftImage;
LeftImage = null;
left?.Dispose();
using var ms = await modService.GetImageStreamAsync(definition?.ModName, definition?.File);
if (ms != null)
{
LeftImage = new Bitmap(ms);
var info = localizationManager.GetResource(LocalizationResources.Conflict_Solver.ImageInfo);
LeftImageInfo = Smart.Format(info, new { LeftImage.PixelSize.Width, LeftImage.PixelSize.Height });
}
loadingImage = false;
}
if (definition != null)
{
Task.Run(() => loadImage().ConfigureAwait(false)).ConfigureAwait(false);
}
else
{
LeftImageInfo = string.Empty;
var left = LeftImage;
LeftImage = null;
left?.Dispose();
}
}
/// <summary>
/// load images as an asynchronous operation.
/// </summary>
protected virtual async Task LoadImagesAsync()
{
while (loadingImages)
{
await Task.Delay(25);
}
loadingImages = true;
if (prevLeftDefinition != LeftDefinition)
{
LeftImageInfo = string.Empty;
var left = LeftImage;
LeftImage = null;
left?.Dispose();
using var ms = await modService.GetImageStreamAsync(LeftDefinition?.ModName, LeftDefinition?.File);
if (ms != null)
{
LeftImage = new Bitmap(ms);
var info = localizationManager.GetResource(LocalizationResources.Conflict_Solver.ImageInfo);
LeftImageInfo = Smart.Format(info, new { LeftImage.PixelSize.Width, LeftImage.PixelSize.Height });
}
}
if (prevRightDefinition != RightDefinition)
{
RightImageInfo = string.Empty;
var right = RightImage;
RightImage = null;
right?.Dispose();
using var ms = await modService.GetImageStreamAsync(RightDefinition?.ModName, RightDefinition?.File);
if (ms != null)
{
RightImage = new Bitmap(ms);
var info = localizationManager.GetResource(LocalizationResources.Conflict_Solver.ImageInfo);
RightImageInfo = Smart.Format(info, new { RightImage.PixelSize.Width, RightImage.PixelSize.Height });
}
}
loadingImages = false;
}
/// <summary>
/// Get bitmap as an asynchronous operation.
/// </summary>
/// <param name="definition">The definition.</param>
/// <returns>A Task<IBitmap> representing the asynchronous operation.</returns>
protected virtual async Task <IBitmap> GetBitmapAsync(IDefinition definition)
{
IBitmap bitmap = null;
var key = ConstructImageCacheKey(definition);
if (imageCache.Contains(key))
{
bitmap = imageCache[key];
}
else
{
using var ms = await modService.GetImageStreamAsync(definition.ModName, definition.File, definition.IsFromGame);
if (ms != null)
{
bitmap = new Bitmap(ms);
imageCache.Add(key, bitmap);
}
}
return(bitmap);
}