public List <Document> RecoverDocuments()
{
List <Document> documents = new();
foreach (ZipArchiveEntry entry in ZipFile.Entries.Where(x => x.FullName.EndsWith(".pixi")))
{
using Stream stream = entry.Open();
Document document;
try
{
document = PixiParser.Deserialize(stream).ToDocument();
document.ChangesSaved = false;
}
catch
{
continue;
}
documents.Add(document);
}
return(documents);
}
public void Save()
{
using FileStream zipStream = new(FilePath, FileMode.Create, FileAccess.Write);
using ZipArchive archive = new ZipArchive(zipStream, ZipArchiveMode.Create);
using (Stream reportStream = archive.CreateEntry("report.txt").Open())
{
reportStream.Write(Encoding.UTF8.GetBytes(ReportText));
}
foreach (Document document in ViewModelMain.Current.BitmapManager.Documents)
{
try
{
string documentPath =
$"{(string.IsNullOrWhiteSpace(document.DocumentFilePath) ? "Unsaved" : Path.GetFileNameWithoutExtension(document.DocumentFilePath))}-{document.OpenedUTC}.pixi".Replace(':', '_');
byte[] serialized = PixiParser.Serialize(document.ToSerializable());
using Stream documentStream = archive.CreateEntry($"Documents/{documentPath}").Open();
documentStream.Write(serialized);
}
catch { }
}
}
public void CanCreateSKImageFromLayer()
{
SerializableDocument document = PixiParser.Deserialize("./Files/16x16,PPD-3.pixi");
SerializableLayer layer = document.Layers[0];
using SKImage image = layer.ToSKImage();
Assert.Equal(layer.Width, image.Width);
}
public void Setup()
{
benchmarkDocumentBytes = PixiParser.Serialize(Helper.CreateDocument(Size, Layers));
benchmarkDocument = Helper.CreateDocument(Size, Layers);
bitmaps = new SkiaSharp.SKBitmap[Layers];
for (int i = 0; i < Layers; i++)
{
bitmaps[i] = Helper.CreateSKBitmap(Size);
}
}
public byte[] SerializeAndCreate()
{
SerializableDocument document = Helper.CreateDocument(Size, Layers, false);
for (int i = 0; i < Layers; i++)
{
SKData encoded = bitmaps[i].Encode(SKEncodedImageFormat.Png, 100);
document.Layers[i].PngBytes = encoded.AsSpan().ToArray();
}
return(PixiParser.Serialize(benchmarkDocument));
}
public static Document ImportDocument(string path)
{
try
{
Document doc = PixiParser.Deserialize(path).ToDocument();
doc.DocumentFilePath = path;
return(doc);
}
catch (InvalidFileException)
{
throw new CorruptedFileException();
}
}
public static Document ImportOldDocument(string path)
{
try
{
using FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
Document doc = PixiParser.DeserializeOld(stream).ToDocument();
doc.DocumentFilePath = path;
return(doc);
}
catch (SerializationException)
{
throw new CorruptedFileException();
}
}
public void SerializeAndDeserializeEmptyLayer()
{
SerializableDocument document = new()
{
Width = 1,
Height = 1
};
document.Layers.Add("Base Layer");
var serialized = PixiParser.Serialize(document);
SerializableDocument deserialized = PixiParser.Deserialize(serialized);
AssertEqual(document, deserialized);
}
private static unsafe SerializableDocument GetSerializable(DataObject data, out CropData cropData)
{
MemoryStream pixiStream = data.GetData("PIXI") as MemoryStream;
SerializableDocument document = PixiParser.Deserialize(pixiStream);
if (data.GetDataPresent(typeof(CropData)))
{
cropData = CropData.FromStream(data.GetData(typeof(CropData)) as MemoryStream);
}
else
{
cropData = new CropData(document.Width, document.Height, 0, 0);
}
return(document);
}
public void TestThatForBigPixiFilesPreviewImageIsResizedToMaxSize()
{
string bigFilePath = $@"{Environment.CurrentDirectory}\..\..\..\ModelsTests\IO\BigPixiFile.pixi";
RecentlyOpenedDocument recentlyOpenedDocument = new RecentlyOpenedDocument(bigFilePath);
var bigPixiFilePreviewImage = recentlyOpenedDocument.PreviewBitmap;
const int MaxWidthInPixels = 1080;
Assert.True(bigPixiFilePreviewImage.PixelWidth <= MaxWidthInPixels);
const int MaxHeightInPixels = 1080;
Assert.True(bigPixiFilePreviewImage.PixelHeight <= MaxHeightInPixels);
// This is a workaround for checking the Pixi file layers.
Assert.True(PixiParser.Deserialize(bigFilePath).Layers.Count <= 5);
}
public void SerializingAndDeserialzingWorks()
{
SerializableDocument document = new()
{
Height = 1,
Width = 1
};
document.Swatches.Add(255, 255, 255);
SerializableLayer layer = document.Layers.Add("Base Layer", 1, 1, false, 0.5f, 1, 1);
layer.PngBytes = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
document.Groups.Add(new SerializableGroup("Base Group"));
byte[] serialized = PixiParser.Serialize(document);
SerializableDocument deserializedDocument = PixiParser.Deserialize(serialized);
AssertEqual(document, deserializedDocument);
}
/// <summary>
/// Saves editable file to chosen path and returns it.
/// </summary>
/// <param name="document">Document to be saved.</param>
/// <param name="path">Path where to save file.</param>
/// <returns>Path.</returns>
public static string SaveAsEditableFile(Document document, string path)
{
PixiParser.Serialize(document.ToSerializable(), path);
return(path);
}
public SerializableDocument Deserialize()
{
return(PixiParser.Deserialize(benchmarkDocumentBytes));
}
public byte[] Serialize()
{
return(PixiParser.Serialize(benchmarkDocument));
}
public void IsBackwardsCompatible() => PixiParser.Deserialize("./Files/16x16,PE-0.6.pixi");
public void CanOpenExistingFile() => PixiParser.Deserialize("./Files/16x16,PPD-3.pixi");
public void DetectCorruptedFile() => Assert.Throws <InvalidFileException>(() => PixiParser.Deserialize("./Files/CorruptedPixiFile.pixi"));
public void DetectOldFile() => Assert.Throws <OldFileFormatException>(() => PixiParser.Deserialize("./Files/OldPixiFile.pixi"));
