Made it working

PixiEditor.SDK/FileParsers/FileParserInfo.cs

@@ -9,7 +9,7 @@ namespace PixiEditor.SDK.FileParsers
     {
         public Type ParserType { get; }
 
-        public bool Enabled { get; set; }
+        public bool Enabled { get; set; } = true;
 
         public string[] SupportedFileExtensions { get; set; }
 
@@ -40,6 +40,7 @@ namespace PixiEditor.SDK.FileParsers
                 throw new ParserException(parserType, $"'{parserType}' needs an {nameof(FileParserAttribute)}");
             }
 
+            SupportedFileExtensions = fileParserAttribute.FileExtensions;
             Constructor = parserType.GetConstructor(Type.EmptyTypes);
 
             if (Constructor is null)

PixiEditor.SDK/FileParsers/FileParserList.cs

@@ -7,23 +7,49 @@ namespace PixiEditor.SDK.FileParsers
 {
     internal class FileParserList
     {
+        public List<string> SupportedImageExtensions { get; set; } = new();
+
+        public List<string> SupportedDocumentExtensions { get; set; } = new();
+
+        public List<string> SupportedExtensions { get; set; } = new();
+
         public ListDictionary<string, ImageParserInfo> ImageParsers { get; set; } = new();
 
         public ListDictionary<string, DocumentParserInfo> DocumentParsers { get; set; } = new();
 
-        public void AddImageParser(ImageParserInfo info)
+        public void AddDocumentParser(DocumentParserInfo info)
         {
             foreach (string ext in info.SupportedFileExtensions)
             {
-                ImageParsers.Add(ext, info);
+                DocumentParsers.Add(ext, info);
+
+                if (!SupportedDocumentExtensions.Contains(ext))
+                {
+                    SupportedDocumentExtensions.Add(ext);
+                }
+
+                if (!SupportedExtensions.Contains(ext))
+                {
+                    SupportedExtensions.Add(ext);
+                }
             }
         }
 
-        public void AddDocumentParser(DocumentParserInfo info)
+        public void AddImageParser(ImageParserInfo info)
         {
             foreach (string ext in info.SupportedFileExtensions)
             {
-                DocumentParsers.Add(ext, info);
+                ImageParsers.Add(ext, info);
+
+                if (!SupportedImageExtensions.Contains(ext))
+                {
+                    SupportedImageExtensions.Add(ext);
+                }
+
+                if (!SupportedExtensions.Contains(ext))
+                {
+                    SupportedExtensions.Add(ext);
+                }
             }
         }
 

PixiEditor.SDK/Internal/SDKManager.cs

@@ -12,9 +12,7 @@ namespace PixiEditor.SDK
 
         public FileParserList Parsers { get; } = new();
 
-        public List<string> SupportedFileExtensions { get; } = new();
-
-        public void AddExtension(Extension extension)
+        public void AddBaseExtension(Extension extension)
         {
             Extensions.Add(extension);
         }
@@ -72,28 +70,12 @@ namespace PixiEditor.SDK
 
                     foreach (DocumentParserInfo fileParserInformation in information.DocumentParsers)
                     {
-                        foreach (string fileExtension in fileParserInformation.SupportedFileExtensions)
-                        {
-                            Parsers.DocumentParsers.Add(fileExtension, fileParserInformation);
-
-                            if (!SupportedFileExtensions.Contains(fileExtension))
-                            {
-                                SupportedFileExtensions.Add(fileExtension);
-                            }
-                        }
+                        Parsers.AddDocumentParser(fileParserInformation);
                     }
 
                     foreach (ImageParserInfo fileParserInformation in information.ImageParsers)
                     {
-                        foreach (string fileExtension in fileParserInformation.SupportedFileExtensions)
-                        {
-                            Parsers.ImageParsers.Add(fileExtension, fileParserInformation);
-
-                            if (!SupportedFileExtensions.Contains(fileExtension))
-                            {
-                                SupportedFileExtensions.Add(fileExtension);
-                            }
-                        }
+                        Parsers.AddImageParser(fileParserInformation);
                     }
                 }
                 catch

PixiEditor/Helpers/FileFilterBuilder.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PixiEditor.Helpers
+{
+    public class FileFilterBuilder
+    {
+        private List<(string, string[])> filters = new List<(string, string[])>();
+
+        public void AddFilter(string name, params string[] fileExtensions)
+        {
+            if (fileExtensions != null && !fileExtensions.Any())
+            {
+                return;
+            }
+
+            filters.Add((name, fileExtensions));
+        }
+
+        public void AddFilter(string name, IEnumerable<string> fileExtensions)
+        {
+            AddFilter(name, fileExtensions.ToArray());
+        }
+
+        public string Build(bool includeAny, string anyName = "Any")
+        {
+            if (filters.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            StringBuilder builder = new StringBuilder();
+
+            if (includeAny)
+            {
+                builder.Append(BuildFilter(anyName, filters.SelectMany(x => x.Item2).ToArray()));
+                builder.Append('|');
+            }
+
+            builder.Append(BuildFilter(filters[0].Item1, filters[0].Item2));
+
+            foreach (var tuple in filters.Skip(1))
+            {
+                builder.Append('|');
+                builder.Append(BuildFilter(tuple.Item1, tuple.Item2));
+            }
+
+            return builder.ToString();
+        }
+
+        public override string ToString() => Build(false);
+
+        private static StringBuilder BuildFilter(string name, string[] extensions)
+        {
+            StringBuilder builder = new StringBuilder();
+
+            builder.Append(name);
+
+            builder.Append('|');
+
+            builder.Append(BuildExtension(extensions));
+
+            return builder;
+        }
+
+        private static StringBuilder BuildExtension(string[] extensions)
+        {
+            StringBuilder builder = new StringBuilder();
+
+            foreach (string extension in extensions)
+            {
+                builder.Append('*');
+
+                if (!extension.StartsWith('.'))
+                {
+                    builder.Append('.');
+                }
+
+                builder.Append(extension);
+                builder.Append("; ");
+            }
+
+            return builder;
+        }
+    }
+}

PixiEditor/Helpers/SDKHelper.cs

@@ -28,6 +28,48 @@ namespace PixiEditor.Helpers
             {
                 return GetCurrentManager().Parsers.CreateImageParser(extension, stream);
             }
+
+            public static string GetFileFilter()
+            {
+                FileFilterBuilder builder = new FileFilterBuilder();
+
+                SDKManager manager = GetCurrentManager();
+
+                builder.AddFilter("Documents", manager.Parsers.SupportedDocumentExtensions);
+                builder.AddFilter("Images", manager.Parsers.SupportedImageExtensions);
+
+                foreach (Extension extension in manager.Extensions)
+                {
+                    builder.AddFilter($"{extension.DisplayName} Documents", extension.SupportedDocumentFileExtensions);
+                    builder.AddFilter($"{extension.DisplayName} Images", extension.SupportedImageFileExtensions);
+                }
+
+                return builder.Build(true);
+            }
+
+            public static string GetDocumentFilter()
+            {
+                FileFilterBuilder builder = new FileFilterBuilder();
+
+                foreach (Extension extension in GetCurrentManager().Extensions)
+                {
+                    builder.AddFilter(extension.DisplayName, extension.SupportedDocumentFileExtensions);
+                }
+
+                return builder.Build(true);
+            }
+
+            public static string GetImageFilter()
+            {
+                FileFilterBuilder builder = new FileFilterBuilder();
+
+                foreach (Extension extension in GetCurrentManager().Extensions)
+                {
+                    builder.AddFilter(extension.DisplayName, extension.SupportedImageFileExtensions);
+                }
+
+                return builder.Build(true);
+            }
         }
     }
 }

PixiEditor/Models/IO/Importer.cs

@@ -55,7 +55,10 @@ namespace PixiEditor.Models.IO
 
             try
             {
-                return SDKHelper.FileParsers.CreateDocumentParser(Path.GetExtension(path), stream).Parse().ToDocument();
+                Document document = SDKHelper.FileParsers.CreateDocumentParser(Path.GetExtension(path), stream).Parse().ToDocument();
+                document.DocumentFilePath = path;
+
+                return document;
             }
             catch (Exception e)
             {
@@ -65,7 +68,7 @@ namespace PixiEditor.Models.IO
 
         public static bool IsSupportedFile(string path)
         {
-            return SDKHelper.GetCurrentManager().SupportedFileExtensions.Contains(path);
+            return SDKHelper.GetCurrentManager().Parsers.SupportedExtensions.Contains(Path.GetExtension(path));
         }
     }
 }

PixiEditor/Models/IO/Parsers/PixiParser.cs

@@ -1,13 +1,9 @@
 using PixiEditor.Parser;
 using PixiEditor.SDK.FileParsers;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace PixiEditor.Models.IO.Parsers
 {
+    [FileParser(".pixi")]
     public class PixiParser : DocumentParser
     {
         public override bool UseBigEndian => true;

PixiEditor/ViewModels/ImportFilePopupViewModel.cs

@@ -112,7 +112,7 @@ namespace PixiEditor.ViewModels
             {
                 Title = "Import path",
                 CheckPathExists = true,
-                Filter = "Image Files|*.png;*.jpeg;*.jpg"
+                Filter = SDKHelper.FileParsers.GetImageFilter()
             };
             if (path.ShowDialog() == true)
             {

PixiEditor/ViewModels/SubViewModels/Main/ExtensionViewModel.cs

@@ -14,7 +14,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
         {
             SDKManager = new SDKManager();
 
-            SDKManager.AddExtension(new BaseExtension());
+            SDKManager.AddBaseExtension(new BaseExtension());
 
             SDKManager.LoadExtensions(Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "PixiEditor", "Extensions"));
             SDKManager.SetupExtensions();

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -9,6 +9,7 @@ using Microsoft.Win32;
 using Newtonsoft.Json.Linq;
 using PixiEditor.Exceptions;
 using PixiEditor.Helpers;
+using PixiEditor.Helpers.Extensions;
 using PixiEditor.Models.Controllers;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Dialogs;
@@ -166,14 +167,21 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
         {
             try
             {
-                if (path.EndsWith(".pixi"))
+                FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
+                string extension = Path.GetExtension(path);
+
+                if (SDKHelper.GetCurrentManager().Parsers.DocumentParsers.ContainsKey(extension))
                 {
                     OpenDocument(path);
                 }
-                else
+                else if (SDKHelper.GetCurrentManager().Parsers.ImageParsers.ContainsKey(extension))
                 {
                     OpenFile(path);
                 }
+                else
+                {
+                    throw new Exception("No parser found");
+                }
 
                 Owner.ResetProgramStateValues();
             }
@@ -207,11 +215,8 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
         {
             OpenFileDialog dialog = new OpenFileDialog
             {
-                Filter =
-                "Any|*.pixi;*.png;*.jpg;*.jpeg;|" +
-                "PixiEditor Files | *.pixi|" +
-                "Image Files|*.png;*.jpg;*.jpeg;",
-                DefaultExt = "pixi"
+                Filter = SDKHelper.FileParsers.GetFileFilter(),
+                DefaultExt = ".pixi"
             };
 
             if ((bool)dialog.ShowDialog())