FileType enum covers all formats

PixiEditor/Helpers/Converters/FileExtensionToColorConverter.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using System.Drawing.Imaging;
 using System.Globalization;
 using System.Windows.Media;
+using PixiEditor.Models.Enums;
 
 namespace PixiEditor.Helpers.Converters
 {
@@ -12,35 +13,28 @@ namespace PixiEditor.Helpers.Converters
         SingleInstanceConverter<FileExtensionToColorConverter>
     {
         private static readonly Dictionary<string, SolidColorBrush> extensions2Brushes;
-
         public static readonly SolidColorBrush UnknownBrush = ColorBrush(100, 100, 100);
 
         static FileExtensionToColorConverter()
         {
             extensions2Brushes = new Dictionary<string, SolidColorBrush>();
-            AssignFormat2Brush(Constants.NativeExtension, ColorBrush(226, 1, 45));
-            AssignFormat2Brush(ImageFormat.Png, ColorBrush(56, 108, 254));
-            AssignFormat2Brush(ImageFormat.Jpeg, ColorBrush(36, 179, 66));
-            AssignFormat2Brush(ImageFormat.Bmp, ColorBrush(40, 170, 236));
-            AssignFormat2Brush(ImageFormat.Gif, ColorBrush(180, 0, 255));
-        }
-        static void AssignFormat2Brush(ImageFormat format, SolidColorBrush brush)
-        {
-            SupportedFilesHelper.GetFormatExtensions(format).ForEach(i => AssignFormat2Brush(i, brush));
+            AssignFormat2Brush(FileType.Unset, UnknownBrush);
+            AssignFormat2Brush(FileType.Pixi, ColorBrush(226, 1, 45));
+            AssignFormat2Brush(FileType.Png, ColorBrush(56, 108, 254));
+            AssignFormat2Brush(FileType.Jpeg, ColorBrush(36, 179, 66));
+            AssignFormat2Brush(FileType.Bmp, ColorBrush(40, 170, 236));
+            AssignFormat2Brush(FileType.Gif, ColorBrush(180, 0, 255));
         }
-        static void AssignFormat2Brush(string format, SolidColorBrush brush)
+        static void AssignFormat2Brush(FileType format, SolidColorBrush brush)
         {
-            extensions2Brushes[format] = brush;
+            SupportedFilesHelper.GetFileTypeDialogData(format).Extensions.ForEach(i => extensions2Brushes[i] = brush);
         }
-
+        
         public override object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
             string extension = (string)value;
 
-            if (extensions2Brushes.ContainsKey(extension))
-                return extensions2Brushes[extension];
-
-            return UnknownBrush;
+            return extensions2Brushes.ContainsKey(extension) ? extensions2Brushes[extension] : UnknownBrush;
         }
 
         private static SolidColorBrush ColorBrush(byte r, byte g, byte b)

PixiEditor/Helpers/SupportedFilesHelper.cs

@@ -1,7 +1,8 @@
 using PixiEditor.Models;
+using PixiEditor.Models.Enums;
+using PixiEditor.Models.IO;
 using System;
 using System.Collections.Generic;
-using System.Drawing.Imaging;
 using System.IO;
 using System.Linq;
 
@@ -9,92 +10,78 @@ namespace PixiEditor.Helpers
 {
     public class SupportedFilesHelper
     {
-        static ImageFormat[] _imageFormats = new[] { ImageFormat.Png, ImageFormat.Jpeg, ImageFormat.Bmp, ImageFormat.Gif, /*ImageFormat.Tiff */};
-        static Dictionary<string, List<string>> extensions;
-        public static ImageFormat[] ImageFormats { get => _imageFormats; }
+        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()
         {
-            extensions = new Dictionary<string, List<string>>();
-            extensions[Constants.NativeExtension] = new List<string>() { Constants.NativeExtension };
-            foreach(var format in _imageFormats)
-                extensions[Format2Extension(format)] = GetFormatExtensions(format);
+            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 IEnumerable<string> GetAllSupportedExtensions()
+        public static FileTypeDialogData GetFileTypeDialogData(FileType type)
         {
-            return extensions.SelectMany(i => i.Value);
-        }
-
-        public static List<string> GetExtensions()
-        {
-            return extensions.Keys.ToList();
-        }
-
-        public static List<string> GetFormatExtensions(ImageFormat format)
-        {
-            var res = new List<string>();
-            res.Add(Format2Extension(format));
-            if (format == ImageFormat.Jpeg)
-                res.Add(".jpg");
-            return res;
-        }
-
-        public static string Format2Extension(ImageFormat format)
-        {
-            return "." + format.ToString().ToLower();
-        }
-
-        static string GetExtensionsFormattedForDialog(IEnumerable<string> parts)
-        {
-            return string.Join(";", parts.Select(i => GetExtensionFormattedForDialog(i)));
-        }
-
-        static string GetExtensionFormattedForDialog(string extension)
-        {
-            return "*" + extension;
+            return allFileTypeDialogsData.Where(i => i.FileType == type).Single();
         }
 
         public static bool IsSupportedFile(string path)
         {
             var ext = Path.GetExtension(path.ToLower());
-            return GetAllSupportedExtensions().Contains(ext);
+            return IsExtensionSupported(ext);
         }
 
         public static bool IsExtensionSupported(string fileExtension)
         {
-            return GetAllSupportedExtensions().Contains(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 string GetFormattedFilesExtensions(bool includePixi)
+        public static List<FileTypeDialogData> GetAllSupportedFileTypes(bool includePixi)
         {
-            var allExts = GetAllSupportedExtensions().ToList();
+            var allExts = fileTypeDialogsData.Values.ToList();
             if (!includePixi)
-                allExts.Remove(Constants.NativeExtension);
-            var imageFilesExts = GetExtensionsFormattedForDialog(allExts);
-            return imageFilesExts;
+                allExts.RemoveAll(item => item.FileType == FileType.Pixi);
+            return allExts;
         }
 
         public static string BuildSaveFilter(bool includePixi)
         {
-            var formatName2Extension = new Dictionary<string, string>();
-            if (includePixi)
-                formatName2Extension.Add("PixiEditor Files", Constants.NativeExtension);
-
-            foreach (var format in ImageFormats)
-                formatName2Extension.Add(format + " Images", Format2Extension(format));
+            var allSupportedExtensions = GetAllSupportedFileTypes(includePixi);
+            var filter = string.Join("|", allSupportedExtensions.Select(i => i.SaveFilter));
 
-            var filter = string.Join("|", formatName2Extension.Select(i => i.Key + "|" + GetExtensionFormattedForDialog(i.Value)));
             return filter;
         }
 
         public static string BuildOpenFilter()
         {
-            var filter =
-               "Any |" + GetFormattedFilesExtensions(true) + "|" +
-               "PixiEditor Files |" + GetExtensionsFormattedForDialog(new[] { Constants.NativeExtension }) + "|" +
-               "Image Files |" + GetFormattedFilesExtensions(false);
+            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/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

@@ -3,6 +3,7 @@ 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;
@@ -63,24 +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);
         }
 
-        //TODO remove static methods/members
-        static Dictionary<ImageFormat,BitmapEncoder> encodersFactory = new Dictionary<ImageFormat, BitmapEncoder>();
+        static Dictionary<FileType, BitmapEncoder> encodersFactory = new Dictionary<FileType, BitmapEncoder>();
 
         static Exporter()
         {
-            encodersFactory[ImageFormat.Png] = new PngBitmapEncoder();
-            encodersFactory[ImageFormat.Jpeg] = new JpegBitmapEncoder();
-            encodersFactory[ImageFormat.Bmp] = new BmpBitmapEncoder(); 
-            encodersFactory[ImageFormat.Gif] = new GifBitmapEncoder();
-            encodersFactory[ImageFormat.Tiff] = 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/ViewModels/SaveFilePopupViewModel.cs

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

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,21 +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
 {
@@ -52,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 | " + SupportedFilesHelper.GetFormattedFilesExtensions(false)
+                Filter = imagesFilter
             };
 
             return (bool)dialog.ShowDialog() ? dialog.FileName : null;

PixiEditorTests/HelpersTests/ConvertersTests/FileExtensionToColorConverterTests.cs

@@ -20,7 +20,7 @@ namespace PixiEditorTests.HelpersTests.ConvertersTests
         [Fact]
         public void TestThatEachFormatHasColor()
         {
-            SupportedFilesHelper.GetAllSupportedExtensions().ToList().ForEach(i =>
+            SupportedFilesHelper.AllSupportedExtensions.ToList().ForEach(i =>
             {
                 var typed = GetTypedColor(i);
                 Assert.NotEqual(FileExtensionToColorConverter.UnknownBrush, typed);

PixiEditorTests/HelpersTests/SupportedFilesHelperTests.cs

@@ -8,7 +8,7 @@ namespace PixiEditorTests.HelpersTests
         [Fact]
         public void TestAllExtensionsAreSupported()
         {
-            var all = SupportedFilesHelper.GetAllSupportedExtensions();
+            var all = SupportedFilesHelper.AllSupportedExtensions;
             Assert.Contains(all, i => i == ".pixi");
             Assert.Contains(all, i => i == ".png");
             Assert.Contains(all, i => i == ".jpg");