/// <summary>
/// Function to load the image to be used a thumbnail.
/// </summary>
/// <param name="thumbnailCodec">The codec for the thumbnail images.</param>
/// <param name="thumbnailFile">The path to the thumbnail file.</param>
/// <param name="content">The content being thumbnailed.</param>
/// <param name="fileManager">The file manager used to handle content files.</param>
/// <param name="cancelToken">The token used to cancel the operation.</param>
/// <returns>The image, image content file and sprite, or just the thumbnail image if it was cached (sprite will be null).</returns>
private (IGorgonImage image, IContentFile imageFile, GorgonSprite sprite) LoadThumbnailImage(IGorgonImageCodec thumbnailCodec, FileInfo thumbnailFile, IContentFile content, IContentFileManager fileManager, CancellationToken cancelToken)
{
IGorgonImage spriteImage;
Stream inStream = null;
Stream imgStream = null;
try
{
// If we've already got the file, then leave.
if (thumbnailFile.Exists)
{
inStream = thumbnailFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
spriteImage = thumbnailCodec.LoadFromStream(inStream);
#pragma warning disable IDE0046 // Convert to conditional expression
if (cancelToken.IsCancellationRequested)
{
return(null, null, null);
}
#pragma warning restore IDE0046 // Convert to conditional expression
return(spriteImage, null, null);
}
IContentFile imageFile = FindImage(content, fileManager);
if (imageFile == null)
{
return(_noImage.Clone(), null, null);
}
imgStream = imageFile.OpenRead();
inStream = content.OpenRead();
if ((!_ddsCodec.IsReadable(imgStream)) ||
(!_defaultCodec.IsReadable(inStream)))
{
return(_noImage.Clone(), null, null);
}
spriteImage = _ddsCodec.LoadFromStream(imgStream);
GorgonSprite sprite = _defaultCodec.FromStream(inStream);
return(spriteImage, imageFile, sprite);
}
catch (Exception ex)
{
CommonServices.Log.Print($"[ERROR] Cannot create thumbnail for '{content.Path}'", LoggingLevel.Intermediate);
CommonServices.Log.LogException(ex);
return(null, null, null);
}
finally
{
imgStream?.Dispose();
inStream?.Dispose();
}
}
/// <summary>
/// Function to determine if the form can be shown.
/// </summary>
/// <returns><b>true</b> if the form can be shown, <b>false</b> if not.</returns>
private bool CanShowForm()
{
if ((string.IsNullOrWhiteSpace(_fileManager?.CurrentDirectory)) ||
(_fileManager.SelectedFile == null))
{
return(false);
}
if ((_fileManager.SelectedFile.Metadata == null) ||
(!_fileManager.SelectedFile.Metadata.Attributes.TryGetValue(CommonEditorConstants.ContentTypeAttr, out string contentType)) ||
(!string.Equals(contentType, CommonEditorContentTypes.ImageType, StringComparison.OrdinalIgnoreCase)))
{
return(false);
}
Stream fileStream = null;
try
{
fileStream = _fileManager.SelectedFile.OpenRead();
if (!_defaultImageCodec.IsReadable(fileStream))
{
return(false);
}
IGorgonImageInfo metaData = _defaultImageCodec.GetMetaData(fileStream);
if ((metaData.ImageType != ImageType.Image2D) && (metaData.ImageType != ImageType.ImageCube))
{
return(false);
}
}
catch (Exception ex)
{
CommonServices.Log.Print($"[ERROR] Cannot open the selected file {_fileManager.SelectedFile.Name}.", LoggingLevel.Simple);
CommonServices.Log.LogException(ex);
}
finally
{
fileStream?.Dispose();
}
return(true);
}
/// <summary>
/// Function to locate the associated texture file for a sprite.
/// </summary>
/// <param name="textureName">The name of the texture.</param>
/// <returns>The texture file.</returns>
private IGorgonVirtualFile LocateTextureFile(string textureName)
{
// Check to see if the name has path information for the texture in the name.
// The GorgonEditor from v2 does this.
if (textureName.Contains("/"))
{
IGorgonVirtualFile textureFile = _fileSystem.GetFile(textureName);
if (textureFile == null)
{
return(null);
}
using (Stream imgFileStream = textureFile.OpenStream())
{
if (_ddsCodec.IsReadable(imgFileStream))
{
return(textureFile);
}
}
}
return(null);
}
/// <summary>
/// Function to import an image file from the physical file system into the current image.
/// </summary>
/// <param name="codec">The codec used to open the file.</param>
/// <param name="filePath">The path to the file to import.</param>
/// <returns>The source file information, image data, the virtual file entry for the working file and the original pixel format of the file.</returns>
public (FileInfo file, IGorgonImage image, IGorgonVirtualFile workingFile, BufferFormat originalFormat) ImportImage(IGorgonImageCodec codec, string filePath)
{
var file = new FileInfo(filePath);
IGorgonImageCodec importCodec = codec;
IGorgonImageInfo metaData = null;
IGorgonVirtualFile workFile = null;
IGorgonImage importImage = null;
string workFilePath = $"{Path.GetFileNameWithoutExtension(filePath)}_import_{Guid.NewGuid().ToString("N")}";
// Try to determine if we can actually read the file using an installed codec, if we can't, then try to find a suitable codec.
using (FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
if ((importCodec == null) || (!importCodec.IsReadable(stream)))
{
importCodec = null;
foreach (IGorgonImageCodec newCodec in InstalledCodecs.Codecs.Where(item => (item.CodecCommonExtensions.Count > 0) && (item.CanDecode)))
{
if (newCodec.IsReadable(stream))
{
importCodec = newCodec;
break;
}
}
}
if (importCodec == null)
{
throw new GorgonException(GorgonResult.CannotRead, string.Format(Resources.GORIMG_ERR_NO_CODEC, filePath));
}
metaData = importCodec.GetMetaData(stream);
// We absolutely need to have an extension, or else the texconv tool will not work.
var codecExtension = new GorgonFileExtension(importCodec.CodecCommonExtensions[0]);
_log.Print($"Adding {codecExtension.Extension} extension to working file or else external tools may not be able to read it.", LoggingLevel.Verbose);
workFilePath = $"{workFilePath}.{codecExtension.Extension}";
using (Stream outStream = ScratchArea.OpenStream(workFilePath, FileMode.Create))
{
stream.CopyTo(outStream);
}
}
workFile = ScratchArea.FileSystem.GetFile(workFilePath);
var formatInfo = new GorgonFormatInfo(metaData.Format);
// This is always in DDS format.
if (formatInfo.IsCompressed)
{
_log.Print($"Image is compressed using [{formatInfo.Format}] as its pixel format.", LoggingLevel.Intermediate);
if (_compressor == null)
{
throw new GorgonException(GorgonResult.CannotRead, string.Format(Resources.GORIMG_ERR_COMPRESSED_FILE, formatInfo.Format));
}
_log.Print($"Loading image '{workFile.FullPath}'...", LoggingLevel.Simple);
importImage = _compressor.Decompress(ref workFile, metaData);
if (importImage == null)
{
throw new GorgonException(GorgonResult.CannotRead, string.Format(Resources.GORIMG_ERR_COMPRESSED_FILE, formatInfo.Format));
}
_log.Print($"Loaded compressed ([{formatInfo.Format}]) image data as [{importImage.Format}]", LoggingLevel.Intermediate);
}
else
{
using (Stream workStream = workFile.OpenStream())
{
importImage = importCodec.LoadFromStream(workStream);
}
}
return(file, importImage, workFile, metaData.Format);
}