Merge pull request #330 from tomaszkot/#277

#277 Add regular image formats to the save as dialog, open dialog extensions

PixiEditor/Helpers/Converters/FileExtensionToColorConverter.cs

@@ -1,38 +1,40 @@
-using System;
+using PixiEditor.Models;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Drawing.Imaging;
 using System.Globalization;
 using System.Windows.Media;
+using PixiEditor.Models.Enums;
 
 namespace PixiEditor.Helpers.Converters
 {
     public class FileExtensionToColorConverter :
         SingleInstanceConverter<FileExtensionToColorConverter>
     {
-        private static readonly SolidColorBrush PixiBrush = ColorBrush(226, 1, 45);
-
-        private static readonly SolidColorBrush PngBrush = ColorBrush(56, 108, 254);
-
-        private static readonly SolidColorBrush JpgBrush = ColorBrush(36, 179, 66);
-
-        private static readonly SolidColorBrush UnknownBrush = ColorBrush(100, 100, 100);
+        private static readonly Dictionary<string, SolidColorBrush> extensionsToBrushes;
+        public static readonly SolidColorBrush UnknownBrush = ColorBrush(100, 100, 100);
 
+        static FileExtensionToColorConverter()
+        {
+            extensionsToBrushes = new Dictionary<string, SolidColorBrush>();
+            AssignFormatToBrush(FileType.Unset, UnknownBrush);
+            AssignFormatToBrush(FileType.Pixi, ColorBrush(226, 1, 45));
+            AssignFormatToBrush(FileType.Png, ColorBrush(56, 108, 254));
+            AssignFormatToBrush(FileType.Jpeg, ColorBrush(36, 179, 66));
+            AssignFormatToBrush(FileType.Bmp, ColorBrush(255, 140, 0));
+            AssignFormatToBrush(FileType.Gif, ColorBrush(180, 0, 255));
+        }
+        static void AssignFormatToBrush(FileType format, SolidColorBrush brush)
+        {
+            SupportedFilesHelper.GetFileTypeDialogData(format).Extensions.ForEach(i => extensionsToBrushes[i] = brush);
+        }
+        
         public override object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
             string extension = (string)value;
 
-            if (extension == ".pixi")
-            {
-                return PixiBrush;
-            }
-            else if (extension == ".png")
-            {
-                return PngBrush;
-            }
-            else if (extension is ".jpg" or ".jpeg")
-            {
-                return JpgBrush;
-            }
-
-            return UnknownBrush;
+            return extensionsToBrushes.ContainsKey(extension) ? extensionsToBrushes[extension] : UnknownBrush;
         }
 
         private static SolidColorBrush ColorBrush(byte r, byte g, byte b)

PixiEditor/Helpers/SupportedFilesHelper.cs

@@ -0,0 +1,88 @@
+using PixiEditor.Models;
+using PixiEditor.Models.Enums;
+using PixiEditor.Models.IO;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace PixiEditor.Helpers
+{
+    public class SupportedFilesHelper
+    {
+        static Dictionary<FileType, FileTypeDialogData> fileTypeDialogsData;
+        static List<FileTypeDialogData> allFileTypeDialogsData;
+        public static string[] AllSupportedExtensions { get; private set; }
+        public static string[] PrimaryExtensions { get; private set; }
+
+        static SupportedFilesHelper()
+        {
+            fileTypeDialogsData = new Dictionary<FileType, FileTypeDialogData>();
+            allFileTypeDialogsData = new List<FileTypeDialogData>();
+
+            var allFormats = Enum.GetValues(typeof(FileType)).Cast<FileType>().ToList();
+            
+            foreach (var format in allFormats)
+            {
+                var fileTypeDialogData = new FileTypeDialogData(format);
+                if (format != FileType.Unset)
+                    fileTypeDialogsData[format] = fileTypeDialogData;
+
+                allFileTypeDialogsData.Add(fileTypeDialogData);
+            }
+
+            AllSupportedExtensions = fileTypeDialogsData.SelectMany(i => i.Value.Extensions).ToArray();
+            PrimaryExtensions = fileTypeDialogsData.Select(i => i.Value.PrimaryExtension).ToArray();
+        }
+
+        public static FileTypeDialogData GetFileTypeDialogData(FileType type)
+        {
+            return allFileTypeDialogsData.Where(i => i.FileType == type).Single();
+        }
+
+        public static bool IsSupportedFile(string path)
+        {
+            var ext = Path.GetExtension(path.ToLower());
+            return IsExtensionSupported(ext);
+        }
+
+        public static bool IsExtensionSupported(string fileExtension)
+        {
+            return AllSupportedExtensions.Contains(fileExtension);
+        }
+        public static FileType ParseImageFormat(string extension)
+        {
+            var allExts = fileTypeDialogsData.Values.ToList();
+            var fileData = allExts.Where(i => i.Extensions.Contains(extension)).SingleOrDefault();
+            if (fileData != null)
+                return fileData.FileType;
+            return FileType.Unset;
+        }
+
+        public static List<FileTypeDialogData> GetAllSupportedFileTypes(bool includePixi)
+        {
+            var allExts = fileTypeDialogsData.Values.ToList();
+            if (!includePixi)
+                allExts.RemoveAll(item => item.FileType == FileType.Pixi);
+            return allExts;
+        }
+
+        public static string BuildSaveFilter(bool includePixi)
+        {
+            var allSupportedExtensions = GetAllSupportedFileTypes(includePixi);
+            var filter = string.Join("|", allSupportedExtensions.Select(i => i.SaveFilter));
+
+            return filter;
+        }
+
+        public static string BuildOpenFilter()
+        {
+            var any = new FileTypeDialogDataSet(FileTypeDialogDataSet.SetKind.Any).GetFormattedTypes();
+            var pixi = new FileTypeDialogDataSet(FileTypeDialogDataSet.SetKind.Pixi).GetFormattedTypes();
+            var images = new FileTypeDialogDataSet(FileTypeDialogDataSet.SetKind.Images).GetFormattedTypes();
+
+            var filter = any + "|" + pixi + "|" + images;
+            return filter;
+        }
+    }
+}

PixiEditor/Models/DataHolders/RecentlyOpenedDocument.cs

@@ -43,11 +43,8 @@ namespace PixiEditor.Models.DataHolders
                 {
                     return "? (Corrupt)";
                 }
-
                 string extension = Path.GetExtension(filePath).ToLower();
-                return extension is not (".pixi" or ".png" or ".jpg" or ".jpeg")
-                    ? $"? ({extension})"
-                    : extension;
+                return SupportedFilesHelper.IsExtensionSupported(extension) ? extension : $"? ({extension})";
             }
         }
 
@@ -93,7 +90,7 @@ namespace PixiEditor.Models.DataHolders
 
                 return surface.ToWriteableBitmap();
             }
-            else if (FileExtension is ".png" or ".jpg" or ".jpeg")
+            else if (SupportedFilesHelper.IsExtensionSupported(FileExtension))
             {
                 WriteableBitmap bitmap = null;
 
@@ -116,6 +113,9 @@ namespace PixiEditor.Models.DataHolders
                     MaxAllowedHeightInPixels = Constants.MaxPreviewHeight,
                 };
 
+                if (bitmap == null)
+                    return null;
+
                 return imageFileMaxSizeChecker.IsFileUnderMaxSize(bitmap) ?
                     bitmap
                     : bitmap.Resize(width: Constants.MaxPreviewWidth, height: Constants.MaxPreviewHeight, WriteableBitmapExtensions.Interpolation.Bilinear);

PixiEditor/Models/Dialogs/ExportFileDialog.cs

@@ -1,4 +1,5 @@
-using PixiEditor.Views;
+using PixiEditor.Models.Enums;
+using PixiEditor.Views;
 using System.Drawing.Imaging;
 using System.Windows;
 
@@ -6,7 +7,7 @@ namespace PixiEditor.Models.Dialogs
 {
     public class ExportFileDialog : CustomDialog
     {
-        ImageFormat _chosenFormat;
+        FileType _chosenFormat;
 
         private int fileHeight;
 
@@ -59,7 +60,7 @@ namespace PixiEditor.Models.Dialogs
             }
         }
 
-        public ImageFormat ChosenFormat
+        public FileType ChosenFormat
         {
             get => _chosenFormat;
             set

PixiEditor/Models/Enums/FileType.cs

@@ -2,6 +2,6 @@
 {
     public enum FileType
     {
-        Png = 0
+        Unset, Pixi, Png, Jpeg, Bmp, Gif
     }
 }

PixiEditor/Models/IO/Exporter.cs

@@ -1,7 +1,9 @@
 using Microsoft.Win32;
+using PixiEditor.Helpers;
 using PixiEditor.Helpers.Extensions;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Dialogs;
+using PixiEditor.Models.Enums;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
@@ -18,8 +20,6 @@ namespace PixiEditor.Models.IO
 {
     public class Exporter
     {
-        static ImageFormat[] _formats = new[] { ImageFormat.Png, ImageFormat.Jpeg, ImageFormat.Bmp, ImageFormat.Gif, ImageFormat.Tiff };
-        
         /// <summary>
         ///     Saves document as .pixi file that contains all document data.
         /// </summary>
@@ -27,10 +27,9 @@ namespace PixiEditor.Models.IO
         /// <param name="path">Path where file was saved.</param>
         public static bool SaveAsEditableFileWithDialog(Document document, out string path)
         {
-            var pixi = GetFormattedString("PixiEditor File", Constants.NativeExtensionNoDot);
             SaveFileDialog dialog = new SaveFileDialog
             {
-                Filter = pixi + "|" + BuildFilter(),
+                Filter = SupportedFilesHelper.BuildSaveFilter(true),
                 FilterIndex = 0
             };
             if ((bool)dialog.ShowDialog())
@@ -43,23 +42,6 @@ namespace PixiEditor.Models.IO
             return false;
         }
 
-        public static string BuildFilter()
-        {
-          var filter = string.Join("|", Formats.Select(i => GetFormattedString(i)));
-          return filter;
-        }
-
-        public static string GetFormattedString(ImageFormat imageFormat)
-        {
-            var formatLower = imageFormat.ToString().ToLower();
-            return GetFormattedString(imageFormat.ToString() + " Image", formatLower);
-        }
-
-        private static string GetFormattedString(string imageFormat, string formatLower)
-        {
-            return $"{imageFormat}|*.{formatLower}";
-        }
-
         /// <summary>
         /// Saves editable file to chosen path and returns it.
         /// </summary>
@@ -82,27 +64,19 @@ namespace PixiEditor.Models.IO
             return path;
         }
 
-        public static ImageFormat ParseImageFormat(string fileExtension)
+        public static FileType ParseImageFormat(string extension)
         {
-            fileExtension = fileExtension.Replace(".", "");
-            return (ImageFormat)typeof(ImageFormat)
-                    .GetProperty(fileExtension, BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase)
-                    .GetValue(null);
+            return SupportedFilesHelper.ParseImageFormat(extension);
         }
 
-        //static Dictionary<ImageFormat, Action<ExportFileDialog, WriteableBitmap>> encoders = new Dictionary<ImageFormat, Action<ExportFileDialog, WriteableBitmap>>();
-        //TODO remove static methods/members
-        static Dictionary<ImageFormat, Func<BitmapEncoder>> encodersFactory = new Dictionary<ImageFormat, Func<BitmapEncoder>>();
-
-        public static ImageFormat[] Formats { get => _formats; }
+        static Dictionary<FileType, Func<BitmapEncoder>> encodersFactory = new Dictionary<FileType, Func<BitmapEncoder>>();
 
         static Exporter()
         {
-            encodersFactory[ImageFormat.Png] = () => { return new PngBitmapEncoder(); };
-            encodersFactory[ImageFormat.Jpeg] = () => { return new JpegBitmapEncoder(); };
-            encodersFactory[ImageFormat.Bmp] = () => { return new BmpBitmapEncoder(); };
-            encodersFactory[ImageFormat.Gif] = () => { return new GifBitmapEncoder(); };
-            encodersFactory[ImageFormat.Tiff] = () => { return new TiffBitmapEncoder(); };
+            encodersFactory[FileType.Png] = () => new PngBitmapEncoder();
+            encodersFactory[FileType.Jpeg] = () => new JpegBitmapEncoder();
+            encodersFactory[FileType.Bmp] = () => new BmpBitmapEncoder(); 
+            encodersFactory[FileType.Gif] = () => new GifBitmapEncoder();
         }
 
         /// <summary>

PixiEditor/Models/IO/FileTypeDialogData.cs

@@ -0,0 +1,55 @@
+using PixiEditor.Models.Enums;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PixiEditor.Models.IO
+{
+    public class FileTypeDialogData
+    {
+        public FileType FileType { get; set; }
+
+        /// <summary>
+        /// Gets or sets file type extensions e.g. {jpg,jpeg}
+        /// </summary>
+        public List<string> Extensions { get; set; }
+
+        /// <summary>
+        /// Gets file type's main extensions e.g. jpeg
+        /// </summary>
+        public string PrimaryExtension { get => Extensions.FirstOrDefault(); }
+
+        /// <summary>
+        /// Gets or sets name displayed before extension e.g. JPEG Files
+        /// </summary>
+        public string DisplayName { get; set; }
+
+        public FileTypeDialogData(FileType fileType)
+        {
+            FileType = fileType;
+            Extensions = new List<string>();
+            Extensions.Add("." + FileType.ToString().ToLower());
+            if (FileType == FileType.Jpeg)
+                Extensions.Add(".jpg");
+
+            if (fileType == FileType.Pixi)
+                DisplayName = "PixiEditor Files";
+            else
+                DisplayName = FileType.ToString() + " Images";
+        }
+
+        public string SaveFilter
+        {
+            get { return DisplayName + "|" + GetExtensionFormattedForDialog(PrimaryExtension); }
+        }
+
+        public string ExtensionsFormattedForDialog
+        {
+            get { return string.Join(";", Extensions.Select(i => GetExtensionFormattedForDialog(i))); }
+        }
+
+        string GetExtensionFormattedForDialog(string extension)
+        {
+            return "*" + extension;
+        }
+    }
+}

PixiEditor/Models/IO/FileTypeDialogDataSet.cs

@@ -0,0 +1,52 @@
+using PixiEditor.Helpers;
+using PixiEditor.Models.Enums;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PixiEditor.Models.IO
+{
+    public class FileTypeDialogDataSet
+    {
+        public enum SetKind { Any, Pixi, Images }
+        IEnumerable<FileTypeDialogData> fileTypes;
+        string displayName;
+
+        public FileTypeDialogDataSet(SetKind kind, IEnumerable<FileTypeDialogData> fileTypes = null)
+        {
+            if (fileTypes == null)
+                fileTypes = SupportedFilesHelper.GetAllSupportedFileTypes(true);
+            var allSupportedExtensions = fileTypes;
+            if (kind == SetKind.Any)
+            {
+                Init("Any", allSupportedExtensions);
+            }
+            else if (kind == SetKind.Pixi)
+            {
+                Init("PixiEditor Files", new[] { new FileTypeDialogData(FileType.Pixi) });
+            }
+            else if (kind == SetKind.Images)
+            {
+                Init("Image Files", allSupportedExtensions, FileType.Pixi);
+            }
+        }
+        public FileTypeDialogDataSet(string displayName, IEnumerable<FileTypeDialogData> fileTypes, FileType? fileTypeToSkip = null)
+        {
+            Init(displayName, fileTypes, fileTypeToSkip);
+        }
+
+        private void Init(string displayName, IEnumerable<FileTypeDialogData> fileTypes, FileType? fileTypeToSkip = null)
+        {
+            var copy = fileTypes.ToList();
+            if (fileTypeToSkip.HasValue)
+                copy.RemoveAll(i => i.FileType == fileTypeToSkip.Value);
+            this.fileTypes = copy;
+
+            this.displayName = displayName;
+        }
+
+        public string GetFormattedTypes()
+        {
+            return displayName + " |" + string.Join(";", this.fileTypes.Select(i => i.ExtensionsFormattedForDialog));
+        }
+    }
+}

PixiEditor/Models/IO/Importer.cs

@@ -7,6 +7,7 @@ using SkiaSharp;
 using System;
 using System.IO;
 using System.IO.Compression;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Windows.Media.Imaging;
 
@@ -87,8 +88,7 @@ namespace PixiEditor.Models.IO
 
         public static bool IsSupportedFile(string path)
         {
-            path = path.ToLower();
-            return path.EndsWith(".pixi") || path.EndsWith(".png") || path.EndsWith(".jpg") || path.EndsWith(".jpeg");
+            return SupportedFilesHelper.IsSupportedFile(path);
         }
 
         public static Surface LoadFromGZippedBytes(string path)

PixiEditor/ViewModels/ImportFilePopupViewModel.cs

@@ -1,5 +1,6 @@
 using PixiEditor.Exceptions;
 using PixiEditor.Helpers;
+using PixiEditor.Models.IO;
 using System;
 using System.IO;
 using System.Windows;
@@ -69,12 +70,12 @@ namespace PixiEditor.ViewModels
 
         private void CheckForPath(string path)
         {
-            if (File.Exists(path) && (path.EndsWith(".png") || path.EndsWith(".jpeg") || path.EndsWith(".jpg")))
+            if (SupportedFilesHelper.IsSupportedFile(path))
             {
                 try
                 {
                     filePath = path;
-                    BitmapImage bitmap = new BitmapImage(new Uri(path));
+                    var bitmap = new BitmapImage(new Uri(path));
                     ImportHeight = bitmap.PixelHeight;
                     ImportWidth = bitmap.PixelWidth;
                 }

PixiEditor/ViewModels/SaveFilePopupViewModel.cs

@@ -1,11 +1,8 @@
 using Microsoft.Win32;
 using PixiEditor.Helpers;
+using PixiEditor.Models.Enums;
 using PixiEditor.Models.IO;
-using System;
-using System.Drawing.Imaging;
 using System.IO;
-using System.Linq;
-using System.Reflection;
 using System.Windows;
 
 namespace PixiEditor.ViewModels
@@ -13,7 +10,7 @@ namespace PixiEditor.ViewModels
     internal class SaveFilePopupViewModel : ViewModelBase
     {
         private string _filePath;
-        private ImageFormat _chosenFormat;
+        private FileType _chosenFormat;
 
         public SaveFilePopupViewModel()
         {
@@ -39,7 +36,7 @@ namespace PixiEditor.ViewModels
             }
         }
 
-        public ImageFormat ChosenFormat 
+        public FileType ChosenFormat 
         { 
             get => _chosenFormat;
             set
@@ -61,8 +58,8 @@ namespace PixiEditor.ViewModels
             {
                 Title = "Export path",
                 CheckPathExists = true,
-                DefaultExt = "." + Exporter.Formats.First().ToString().ToLower(),
-                Filter = Exporter.BuildFilter()
+                Filter = SupportedFilesHelper.BuildSaveFilter(false),
+                FilterIndex = 0
             };
             if (path.ShowDialog() == true)
             {

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using PixiEditor.Exceptions;
 using PixiEditor.Helpers;
+using PixiEditor.Models;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Dialogs;
 using PixiEditor.Models.IO;
@@ -10,6 +11,7 @@ using PixiEditor.Parser;
 using PixiEditor.Views.Dialogs;
 using System;
 using System.Collections.Generic;
+using System.Drawing.Imaging;
 using System.IO;
 using System.Linq;
 using System.Windows;
@@ -199,16 +201,15 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                 }
             }
         }
-
+                
         private void Open(object property)
         {
+            var filter = SupportedFilesHelper.BuildOpenFilter();
+
             OpenFileDialog dialog = new OpenFileDialog
             {
-                Filter =
-                "Any|*.pixi;*.png;*.jpg;*.jpeg;|" +
-                "PixiEditor Files | *.pixi|" +
-                "Image Files|*.png;*.jpg;*.jpeg;",
-                DefaultExt = "pixi"
+                Filter = filter,
+                FilterIndex = 0
             };
 
             if ((bool)dialog.ShowDialog())

PixiEditor/Views/Dialogs/ExportFilePopup.xaml.cs

@@ -1,4 +1,5 @@
-using PixiEditor.ViewModels;
+using PixiEditor.Models.Enums;
+using PixiEditor.ViewModels;
 using System.Drawing.Imaging;
 using System.Windows;
 using System.Windows.Input;
@@ -54,7 +55,7 @@ namespace PixiEditor.Views
             set => dataContext.FilePath = value;
         }
 
-        public ImageFormat SaveFormat 
+        public FileType SaveFormat 
         {
             get => dataContext.ChosenFormat;
             set => dataContext.ChosenFormat = value;

PixiEditor/Views/UserControls/Layers/ReferenceLayer.xaml.cs

@@ -1,20 +1,12 @@
 using Microsoft.Win32;
+using PixiEditor.Helpers;
+using PixiEditor.Models.Enums;
 using PixiEditor.Models.IO;
 using PixiEditor.Models.Layers;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
 using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
+using static PixiEditor.Helpers.SupportedFilesHelper;
 
 namespace PixiEditor.Views.UserControls.Layers
 {
@@ -51,12 +43,12 @@ namespace PixiEditor.Views.UserControls.Layers
 
         private string OpenFilePicker()
         {
-
+            var imagesFilter = new FileTypeDialogDataSet(FileTypeDialogDataSet.SetKind.Images).GetFormattedTypes();
             OpenFileDialog dialog = new OpenFileDialog
             {
                 Title = "Reference layer path",
                 CheckPathExists = true,
-                Filter = "Image Files|*.png;*.jpeg;*.jpg|PNG Files|*.png|JPG Files|*.jpeg;*.jpg"
+                Filter = imagesFilter
             };
 
             return (bool)dialog.ShowDialog() ? dialog.FileName : null;

PixiEditorTests/HelpersTests/ConvertersTests/FileExtensionToColorConverterTests.cs

@@ -0,0 +1,38 @@
+using PixiEditor.Helpers;
+using PixiEditor.Helpers.Converters;
+using System.Globalization;
+using System.Linq;
+using System.Windows.Media;
+using Xunit;
+
+namespace PixiEditorTests.HelpersTests.ConvertersTests
+{
+    public class FileExtensionToColorConverterTests
+    {
+        private static SolidColorBrush GetTypedColor(string ext)
+        {
+            var converter = new FileExtensionToColorConverter();
+            object value = converter.Convert(ext, typeof(int), null, CultureInfo.CurrentCulture);
+            Assert.IsType<SolidColorBrush>(value);
+            return value as SolidColorBrush;
+        }
+
+        [Fact]
+        public void TestThatEachFormatHasColor()
+        {
+            SupportedFilesHelper.AllSupportedExtensions.ToList().ForEach(i =>
+            {
+                var typed = GetTypedColor(i);
+                Assert.NotEqual(FileExtensionToColorConverter.UnknownBrush, typed);
+            });
+        }
+               
+        [Fact]
+        public void TestThatUnsupportedFormatHasDefaultColor()
+        {
+            var converter = new FileExtensionToColorConverter();
+            var typed = GetTypedColor(".abc");
+            Assert.Equal(FileExtensionToColorConverter.UnknownBrush, typed);
+        }
+    }
+}

PixiEditorTests/HelpersTests/SupportedFilesHelperTests.cs

@@ -0,0 +1,45 @@
+using PixiEditor.Helpers;
+using Xunit;
+
+namespace PixiEditorTests.HelpersTests
+{
+    public class SupportedFilesHelperTests
+    {
+        [Fact]
+        public void TestAllExtensionsAreSupported()
+        {
+            var all = SupportedFilesHelper.AllSupportedExtensions;
+            Assert.Contains(all, i => i == ".pixi");
+            Assert.Contains(all, i => i == ".png");
+            Assert.Contains(all, i => i == ".jpg");
+            Assert.Contains(all, i => i == ".jpeg");
+            Assert.Contains(all, i => i == ".bmp");
+            Assert.Contains(all, i => i == ".gif");
+        }
+
+        [Fact]
+        public void TestBuildSaveFilter()
+        {
+            var filter = SupportedFilesHelper.BuildSaveFilter(true);
+            Assert.Equal("PixiEditor Files|*.pixi|Png Images|*.png|Jpeg Images|*.jpeg|Bmp Images|*.bmp|Gif Images|*.gif", filter);
+        }
+
+        [Fact]
+        public void TestBuildOpenFilter()
+        {
+            var filter = SupportedFilesHelper.BuildOpenFilter();
+            Assert.Equal("Any |*.pixi;*.png;*.jpeg;*.jpg;*.bmp;*.gif|PixiEditor Files |*.pixi|Image Files |*.png;*.jpeg;*.jpg;*.bmp;*.gif", filter);
+        }
+
+        [Fact]
+        public void TestIsSupportedFile()
+        {
+            Assert.True(SupportedFilesHelper.IsSupportedFile("foo.png"));
+            Assert.True(SupportedFilesHelper.IsSupportedFile("foo.bmp"));
+            Assert.True(SupportedFilesHelper.IsSupportedFile("foo.jpg"));
+            Assert.True(SupportedFilesHelper.IsSupportedFile("foo.jpeg"));
+
+            Assert.False(SupportedFilesHelper.IsSupportedFile("foo.abc"));
+        }
+    }
+}

PixiEditorTests/ModelsTests/IO/ImporterTests.cs

@@ -26,6 +26,8 @@ namespace PixiEditorTests.ModelsTests.IO
         [InlineData("dub.jpeg")]
         [InlineData("-.JPEG")]
         [InlineData("dub.jpg")]
+        [InlineData("dub.gif")]
+        [InlineData("dub.bmp")]
         public void TestThatIsSupportedFile(string file)
         {
             Assert.True(Importer.IsSupportedFile(file));