Bump version to 2.3

* redumplib: correct media type for Sega Nu

* redumplib: merge Namco System 246 and System 256

* redumplib: drop Namco System 357 / 369

This was not a disc-based system, none of its released forms
have a disc reader.

* redumplib: add SEGA ALLS

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "MPF.Library/Aaru/CICMMetadata"]
-	path = MPF.Library/Aaru/CICMMetadata
+	path = CICMMetadata
 	url = https://github.com/claunia/CICMMetadata

CHANGELIST.md

@@ -1,3 +1,167 @@
+### 2.3 (2022-02-05)
+- Start overhauling Redump information pulling, again
+- Add internal structure for special site codes
+- Add new tabs for special site information
+- Clean up default handling of fields
+- Try to handle multi-line fields during parsing
+- Fix CSSKey log handling
+- Show most read-only fields in new tab
+- Add horizontal scroll to user input
+- Tweak new disc information fields and tabs
+- Allow internal serial and volume label to be hidden
+- Be smarter about showing update checks
+- Ensure all fields are read-only on read-only tab
+- Add model for 2-layer ringcode guide
+- Add first attempt 2-layer ringcode guide
+- Add even more safety to clone
+- Sanitize filename after check
+- Handle pulled linebreaks better
+- Skip anti-modchip string in some cases
+- Handle pulled linebreaks better, again
+- Tweak more Disc Info window formatting
+- Skip unnecessary newlines in parsing
+- Force scroll visibility, tweak text sizes again
+- Fix newline skipping
+- Add missing continue statement
+- Add newlines for mutliline special fields
+- Omit volume label for "Audio CD"
+- Remove Enter/Escape registration on disc info window
+- Logically group more things in disc info window
+- Remove tab key from disc info window
+- Add `<tab>` processing
+- Unban newly opened consoles
+- Tweak minimalized layout a bit more
+- Add tab setting
+- Further disc info window tweaks
+- Changed IsEnabled to IsReadOnly
+- Fix scrolling issues in disc info window
+- Convert postgap and VCD fields to checkboxes
+- Adjust width ratios for disc info window
+- Fix IsReadOnly
+- Only include booleans if the value is true
+- Add hidden debug option for "ShowDebugViewMenuItem"
+- Fix incorrect header check
+- Make protection read-only field multiline
+- Reformat Saturn internal date
+- Fix Sega CD internal serial reading
+- Fix crash on invalid parameters
+- Differentiate XMID and XeMID
+- Conditionally pull region from Redump
+- Be smarter about volume labels
+- Use volume label in checks, not formatted version
+- Sync with Redump region and language selection
+- Try to delete old log archive before writing
+- Add support for all ISO language codes
+- Add support for all ISO region codes
+- Ensure ordering in output site tags
+- Make site code formatting helper method
+- Better helper method organization
+- Start supporting ordered tags and non-tags
+- Add more non-tag support; rearrange info window
+- Fix incorrect language three-letter code
+- Hook up additional Xbox field to disc info window
+- Fix non-tag tag shortnames
+- Fix parsing of non-tag tags again
+- Disable unnecessary cuesheet parsing
+- Fix incorrect region two-letter code
+- Adjust long names for some languages
+- Add Sierra ID to list of pseudo-tags
+- Add another hand-formatted version of SS tag
+- Move internal serial before volume label
+- Check for $SystemUpdate folder for X360 discs
+- Slightly rename UK and USA regions for UI
+- Add another hand-formatted version of SS tag
+- Add verification reminders for pulled tags
+- Read longer string for Saturn internal serial
+- Ensure version only pulled if one doesn't exist
+- Ensure Games pseudo-tag is multi-line
+- Add alternate pseudo-tag for Playable Demos
+- Make error clearer if something is unsupported in Check
+- Ensure drive is not null for volume labels
+- Check explicitly for no matches on Redump pull
+- Normalize PS1/PS2 executable names
+- Adjust paths for DIC just before dumping
+
+### 2.2 (2021-12-30)
+- Fix Saturn header finding
+- Add Pocket PC support
+- Add HD-DVD-Video support
+- Convert to using separate Redump library code
+- Update to Aaru v5.3.0-rc1
+- Update to BurnOutSharp 1.8.0
+- Update support packages
+- Add on-startup "check for updates" option
+- Update to Aaru v5.3.0-rc2
+- Add .NET 5.0 as build target
+- Remove .NET Core 3.1 and .NET 5.0 from AppVeyor build artifacts
+- Null-safeguard RedumpLib conversions
+- Move cuesheet code to separate DLL
+- Move CICMMetadata to top-level
+- Separate out remaining functionality into individual DLLs
+- Update to Aaru v5.3.0 LTS
+- Update to DIC 20211001
+- HTTP encode password for Redump login, again
+- Fix NullReferenceException in anti-modchip scans
+- Update arcade metadata (Shizmob)
+- Add JSON output option for MPF.Check
+- Fix JSON output serialization
+- Ensure corrupt directories on media don't throw errors
+- Add retry to Redump external calls
+- Make anti-modchip scans even safer
+- Remove lower bound checking on LBA values for DIC
+- Remove offset for audio discs on DIC output
+- Start adding regression tests for DIC
+- Ensure parameters box is safer during options save
+- Fix protection sanitization and add regression tests
+- Update to DIC 20211101
+- Add protection sanitization for StarForce
+- Trim filenames for DVD protection from DIC
+- Fill out internal tests around Redump library
+- Refine the "missing disc" text
+- Overhaul XeMID handling
+- Fix output dialog issues in Options window
+- Fix saving path settings if set from dialog
+- Allow default system if skipping system detection enabled
+- Add internal support for all Redump site codes
+- Use the Volume Label special site code
+- Capture newlines in Redump fields
+- Invert condition for volume label
+- Fix missing ISN usages
+- Fix ISN string
+- Validate track count when matching Redump
+- Allow for better matching of multi track discs
+- Temporarily disable pulling comments from Redump pages
+- Add safety around volume labels
+
+### 2.1 (2021-07-22)
+- Enum, no more
+- Sony works backward
+- Add experimental dark mode
+- Allow users to customize protection scanning
+- Fix negative offsets for `/a` flag
+- Always check for all DIC log files, just in case
+- Check for the zipped logs for dealing with overwrites
+- Be smarter about checking for zipped logs
+- Change offset value for HVN discs
+- Update to DIC 20210601
+- Fix Aaru command normalization
+- Handle carriage returns better
+- Add logging helper class
+- Set matcher on carriage return for log formatting
+- Replace dumping program output processing
+- Fix volume name detection for XBOX discs
+- Add new setting for including artifacts in serialzied JSON
+- Fix logging in to Redump for verifications
+- Gracefully handle timeouts during login
+- Update to DIC 20210701
+- Support `/mr` value parameter
+- Support new mainInfo header
+- Add BD to IBM-PC supported discs
+- Fix launching MPF on Windows 7
+- Fix log window background turning white
+- Add DMI/PFI/SS to log zipfile
+- Update to BurnOutSharp 1.7.0
+
 ### 2.0 (2021-04-23)
 - Rename DICUI to Media Preservation Frontend (MPF)
 - Add handling for BEh drive _mainInfo.txt changes

MPF.Check/MPF.Check.csproj

@@ -1,16 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
     <OutputType>Exe</OutputType>
-    <Prefer32Bit>true</Prefer32Bit>
     <Title>MPF Check</Title>
     <AssemblyName>MPF.Check</AssemblyName>
     <Description>Validator for various dumping programs</Description>
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
     <Copyright>Copyright (c)2019-2021</Copyright>
     <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.0</Version>
+    <Version>2.3</Version>
     <AssemblyVersion>$(Version)</AssemblyVersion>
     <FileVersion>$(Version)</FileVersion>
     <IncludeSource>true</IncludeSource>
@@ -28,10 +28,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.6.1" GeneratePathProperty="true">
+    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.8.0" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.0" />
+    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
   
   <ItemGroup>
@@ -43,6 +46,7 @@
       <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
       <Name>MPF.Library</Name>
     </ProjectReference>
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
   </ItemGroup>
 
 </Project>

MPF.Check/Program.cs

@@ -1,9 +1,13 @@
 using System;
 using System.IO;
+using System.Linq;
 using BurnOutSharp;
-using MPF.Data;
-using MPF.Redump;
-using MPF.Utilities;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using MPF.Core.Utilities;
+using MPF.Library;
+using RedumpLib.Data;
+using RedumpLib.Web;
 
 namespace MPF.Check
 {
@@ -33,7 +37,7 @@ namespace MPF.Check
             }
             else if (args[0] == "-ls" || args[0] == "--listsystems")
             {
-                ListKnownSystems();
+                ListSystems();
                 Console.ReadLine();
                 return;
             }
@@ -46,16 +50,16 @@ namespace MPF.Check
             }
 
             // Check the MediaType
-            var mediaType = Converters.ToMediaType(args[0].Trim('"'));
+            var mediaType = EnumConverter.ToMediaType(args[0].Trim('"'));
             if (mediaType == MediaType.NONE)
             {
                 DisplayHelp($"{args[0]} is not a recognized media type");
                 return;
             }
 
-            // Check the KnownSystem
-            var knownSystem = Converters.ToKnownSystem(args[1].Trim('"'));
-            if (knownSystem == KnownSystem.NONE)
+            // Check the RedumpSystem
+            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
+            if (knownSystem == null)
             {
                 DisplayHelp($"{args[1]} is not a recognized system");
                 return;
@@ -65,7 +69,7 @@ namespace MPF.Check
             string username = null, password = null;
             string internalProgram = "DiscImageCreator";
             string path = string.Empty;
-            bool scan = false, compress = false;
+            bool scan = false, compress = false, json = false;
 
             // Loop through and process options
             int startIndex = 2;
@@ -108,13 +112,19 @@ namespace MPF.Check
                 }
 
                 // Scan for protection (requires device path)
-                else if (args[startIndex].StartsWith("-s") || args[startIndex].StartsWith("--scan"))
+                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
                 {
                     scan = true;
                 }
 
+                // Output submission JSON
+                else if (args[startIndex].Equals("-j") || args[startIndex].Equals("--json"))
+                {
+                    json = true;
+                }
+
                 // Compress log and extraneous files
-                else if (args[startIndex].StartsWith("-z") || args[startIndex].StartsWith("--zip"))
+                else if (args[startIndex].Equals("-z") || args[startIndex].Equals("--zip"))
                 {
                     compress = true;
                 }
@@ -163,9 +173,11 @@ namespace MPF.Check
                 // Now populate an environment
                 var options = new Options
                 {
-                    InternalProgram = Converters.ToInternalProgram(internalProgram),
+                    InternalProgram = EnumConverter.ToInternalProgram(internalProgram),
                     ScanForProtection = scan && !string.IsNullOrWhiteSpace(path),
                     PromptForDiscInformation = false,
+                    ShowDiscEjectReminder = false,
+                    OutputSubmissionJSON = json,
                     CompressLogFiles = compress,
 
                     RedumpUsername = username,
@@ -194,7 +206,7 @@ namespace MPF.Check
                 Console.WriteLine(error);
 
             Console.WriteLine("Usage:");
-            Console.WriteLine("MPF.Check.exe <mediatype> <system> [options] </path/to/output.bin> ...");
+            Console.WriteLine("MPF.Check.exe <mediatype> <system> [options] </path/to/output.cue/iso> ...");
             Console.WriteLine();
             Console.WriteLine("Standalone Options:");
             Console.WriteLine("-h, -?                  Show this help text");
@@ -207,6 +219,7 @@ namespace MPF.Check
             Console.WriteLine("-u, --use <program>            Dumping program output type");
             Console.WriteLine("-p, --path <drivepath>         Physical drive path for additional checks");
             Console.WriteLine("-s, --scan                     Enable copy protection scan (requires --path)");
+            Console.WriteLine("-j, --json                     Enable submission JSON output");
             Console.WriteLine("-z, --zip                      Enable log file compression");
             Console.WriteLine();
         }
@@ -242,17 +255,19 @@ namespace MPF.Check
         }
 
         /// <summary>
-        /// List all known systems with their short usable names
+        /// List all systems with their short usable names
         /// </summary>
-        private static void ListKnownSystems()
+        private static void ListSystems()
         {
             Console.WriteLine("Supported Known Systems:");
-            foreach (var val in Enum.GetValues(typeof(KnownSystem)))
-            {
-                if (((KnownSystem)val) == KnownSystem.NONE)
-                    continue;
+            var knownSystems = Enum.GetValues(typeof(RedumpSystem))
+                .OfType<RedumpSystem?>()
+                .Where(s => s != null && !s.IsMarker() && s.GetCategory() != SystemCategory.NONE)
+                .OrderBy(s => s.LongName() ?? string.Empty);
 
-                Console.WriteLine($"{((KnownSystem?)val).ShortName()} - {((KnownSystem?)val).LongName()}");
+            foreach (var val in knownSystems)
+            {
+                Console.WriteLine($"{val.ShortName()} - {val.LongName()}");
             }
         }
 

MPF.Core/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+
+// Anything marked as internal can be used by the test methods
+[assembly: InternalsVisibleTo("MPF.Test")]

MPF.Core/Converters/EnumConverter.cs

@@ -0,0 +1,381 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Reflection;
+#if NET_FRAMEWORK
+using IMAPI2;
+#endif
+using MPF.Core.Data;
+using RedumpLib.Data;
+
+namespace MPF.Core.Converters
+{
+    public static class EnumConverter
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Convert drive type to internal version, if possible
+        /// </summary>
+        /// <param name="driveType">DriveType value to check</param>
+        /// <returns>InternalDriveType, if possible, null on error</returns>
+        public static InternalDriveType? ToInternalDriveType(this DriveType driveType)
+        {
+            switch (driveType)
+            {
+                case DriveType.CDRom:
+                    return InternalDriveType.Optical;
+                case DriveType.Fixed:
+                    return InternalDriveType.HardDisk;
+                case DriveType.Removable:
+                    return InternalDriveType.Removable;
+                default:
+                    return null;
+            }
+        }
+
+#if NET_FRAMEWORK
+        /// <summary>
+        /// Convert IMAPI physical media type to a MediaType
+        /// </summary>
+        /// <param name="type">IMAPI_MEDIA_PHYSICAL_TYPE value to check</param>
+        /// <returns>MediaType if possible, null on error</returns>
+        public static MediaType? IMAPIToMediaType(this IMAPI_MEDIA_PHYSICAL_TYPE type)
+        {
+            switch (type)
+            {
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN:
+                    return MediaType.NONE;
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW:
+                    return MediaType.CDROM;
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER:
+                    return MediaType.DVD;
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM:
+                    return MediaType.HDDVD;
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR:
+                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE:
+                    return MediaType.BluRay;
+                default:
+                    return null;
+            }
+        }
+#endif
+
+        #endregion
+
+        #region Convert to Long Name
+
+        /// <summary>
+        /// Long name method cache
+        /// </summary>
+        private static readonly ConcurrentDictionary<Type, MethodInfo> LongNameMethods = new ConcurrentDictionary<Type, MethodInfo>();
+
+        /// <summary>
+        /// Get the string representation of a generic enumerable value
+        /// </summary>
+        /// <param name="value">Enum value to convert</param>
+        /// <returns>String representation of that value if possible, empty string on error</returns>
+        public static string GetLongName(Enum value)
+        {
+            try
+            {
+                var sourceType = value?.GetType();
+                sourceType = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
+
+                if (!LongNameMethods.TryGetValue(sourceType, out MethodInfo method))
+                {
+                    
+                    method = typeof(RedumpLib.Data.Extensions).GetMethod("LongName", new[] { typeof(Nullable<>).MakeGenericType(sourceType) });
+                    if (method == null)
+                        method = typeof(EnumConverter).GetMethod("LongName", new[] { typeof(Nullable<>).MakeGenericType(sourceType) });
+
+                    LongNameMethods.TryAdd(sourceType, method);
+                }
+
+                if (method != null)
+                    return method.Invoke(null, new[] { value }) as string;
+                else
+                    return string.Empty;
+            }
+            catch
+            {
+                // Converter is not implemented for the given type
+                return string.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get the string representation of the InternalProgram enum values
+        /// </summary>
+        /// <param name="prog">InternalProgram value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this InternalProgram? prog)
+        {
+            switch (prog)
+            {
+                #region Dumping support
+
+                case InternalProgram.Aaru:
+                    return "Aaru";
+                case InternalProgram.DD:
+                    return "dd";
+                case InternalProgram.DiscImageCreator:
+                    return "DiscImageCreator";
+
+                #endregion
+
+                #region Verification support only
+
+                case InternalProgram.CleanRip:
+                    return "CleanRip";
+
+                case InternalProgram.DCDumper:
+                    return "DCDumper";
+
+                case InternalProgram.UmdImageCreator:
+                    return "UmdImageCreator";
+
+                #endregion
+
+                case InternalProgram.NONE:
+                default:
+                    return "Unknown";
+            }
+        }
+
+        #endregion
+
+        #region Convert From String
+
+        /// <summary>
+        /// Get the InternalProgram enum value for a given string
+        /// </summary>
+        /// <param name="internalProgram">String value to convert</param>
+        /// <returns>InternalProgram represented by the string, if possible</returns>
+        public static InternalProgram ToInternalProgram(string internalProgram)
+        {
+            switch (internalProgram.ToLowerInvariant())
+            {
+                // Dumping support
+                case "aaru":
+                case "chef":
+                case "dichef":
+                case "discimagechef":
+                    return InternalProgram.Aaru;
+                case "creator":
+                case "dic":
+                case "dicreator":
+                case "discimagecreator":
+                    return InternalProgram.DiscImageCreator;
+                case "dd":
+                    return InternalProgram.DD;
+
+                // Verification support only
+                case "cleanrip":
+                case "cr":
+                    return InternalProgram.CleanRip;
+                case "dc":
+                case "dcd":
+                case "dcdumper":
+                    return InternalProgram.DCDumper;
+                case "uic":
+                case "umd":
+                case "umdcreator":
+                case "umdimagecreator":
+                    return InternalProgram.UmdImageCreator;
+
+                default:
+                    return InternalProgram.NONE;
+            }
+        }
+
+        /// <summary>
+        /// Get the MediaType enum value for a given string
+        /// </summary>
+        /// <param name="type">String value to convert</param>
+        /// <returns>MediaType represented by the string, if possible</returns>
+        public static MediaType ToMediaType(string type)
+        {
+            switch (type.ToLowerInvariant())
+            {
+                #region Punched Media
+
+                case "aperture":
+                case "aperturecard":
+                case "aperture card":
+                    return MediaType.ApertureCard;
+                case "jacquardloom":
+                case "jacquardloomcard":
+                case "jacquard loom card":
+                    return MediaType.JacquardLoomCard;
+                case "magneticstripe":
+                case "magneticstripecard":
+                case "magnetic stripe card":
+                    return MediaType.MagneticStripeCard;
+                case "opticalphone":
+                case "opticalphonecard":
+                case "optical phonecard":
+                    return MediaType.OpticalPhonecard;
+                case "punchcard":
+                case "punchedcard":
+                case "punched card":
+                    return MediaType.PunchedCard;
+                case "punchtape":
+                case "punchedtape":
+                case "punched tape":
+                    return MediaType.PunchedTape;
+
+                #endregion
+
+                #region Tape
+
+                case "openreel":
+                case "openreeltape":
+                case "open reel tape":
+                    return MediaType.OpenReel;
+                case "datacart":
+                case "datacartridge":
+                case "datatapecartridge":
+                case "data tape cartridge":
+                    return MediaType.DataCartridge;
+                case "cassette":
+                case "cassettetape":
+                case "cassette tape":
+                    return MediaType.Cassette;
+
+                #endregion
+
+                #region Disc / Disc
+
+                case "bd":
+                case "bdrom":
+                case "bd-rom":
+                case "bluray":
+                    return MediaType.BluRay;
+                case "cd":
+                case "cdrom":
+                case "cd-rom":
+                    return MediaType.CDROM;
+                case "dvd":
+                case "dvd5":
+                case "dvd-5":
+                case "dvd9":
+                case "dvd-9":
+                case "dvdrom":
+                case "dvd-rom":
+                    return MediaType.DVD;
+                case "fd":
+                case "floppy":
+                case "floppydisk":
+                case "floppy disk":
+                case "floppy diskette":
+                    return MediaType.FloppyDisk;
+                case "floptical":
+                    return MediaType.Floptical;
+                case "gd":
+                case "gdrom":
+                case "gd-rom":
+                    return MediaType.GDROM;
+                case "hddvd":
+                case "hd-dvd":
+                case "hddvdrom":
+                case "hd-dvd-rom":
+                    return MediaType.HDDVD;
+                case "hdd":
+                case "harddisk":
+                case "hard disk":
+                    return MediaType.HardDisk;
+                case "bernoullidisk":
+                case "iomegabernoullidisk":
+                case "bernoulli disk":
+                case "iomega bernoulli disk":
+                    return MediaType.IomegaBernoulliDisk;
+                case "jaz":
+                case "iomegajaz":
+                case "iomega jaz":
+                    return MediaType.IomegaJaz;
+                case "zip":
+                case "zipdisk":
+                case "iomegazip":
+                case "iomega zip":
+                    return MediaType.IomegaZip;
+                case "ldrom":
+                case "lvrom":
+                case "ld-rom":
+                case "lv-rom":
+                case "laserdisc":
+                case "laservision":
+                case "ld-rom / lv-rom":
+                    return MediaType.LaserDisc;
+                case "64dd":
+                case "n64dd":
+                case "64dddisk":
+                case "n64dddisk":
+                case "64dd disk":
+                case "n64dd disk":
+                    return MediaType.Nintendo64DD;
+                case "fds":
+                case "famicom":
+                case "nfds":
+                case "nintendofamicom":
+                case "famicomdisksystem":
+                case "famicom disk system":
+                case "famicom disk system disk":
+                    return MediaType.NintendoFamicomDiskSystem;
+                case "gc":
+                case "gamecube":
+                case "nintendogamecube":
+                case "nintendo gamecube":
+                case "gamecube disc":
+                case "gamecube game disc":
+                    return MediaType.NintendoGameCubeGameDisc;
+                case "wii":
+                case "nintendowii":
+                case "nintendo wii":
+                case "nintendo wii disc":
+                case "wii optical disc":
+                    return MediaType.NintendoWiiOpticalDisc;
+                case "wiiu":
+                case "nintendowiiu":
+                case "nintendo wiiu":
+                case "nintendo wiiu disc":
+                case "wiiu optical disc":
+                case "wii u optical disc":
+                    return MediaType.NintendoWiiUOpticalDisc;
+                case "umd":
+                    return MediaType.UMD;
+
+                #endregion
+
+                // Unsorted Formats
+                case "cartridge":
+                    return MediaType.Cartridge;
+                case "ced":
+                case "rcaced":
+                case "rca ced":
+                case "videodisc":
+                case "rca videodisc":
+                    return MediaType.CED;
+
+                default:
+                    return MediaType.NONE;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Data/Constants.cs

@@ -1,7 +1,8 @@
 using System.Collections.Generic;
 using System.Linq;
+using RedumpLib.Data;
 
-namespace MPF.Data
+namespace MPF.Core.Data
 {
     /// <summary>
     /// Constant values for UI
@@ -16,10 +17,10 @@ namespace MPF.Data
         public static readonly byte[] SaturnSectorZeroStart = new byte[] { 0x53, 0x45, 0x47, 0x41, 0x20, 0x53, 0x45, 0x47, 0x41, 0x53, 0x41, 0x54, 0x55, 0x52, 0x4E, 0x20 };
 
         // Private lists of known drive speed ranges
-        private static IReadOnlyList<int> cd { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
-        private static IReadOnlyList<int> dvd { get; } = cd.Where(s => s <= 24).ToList();
-        private static IReadOnlyList<int> bd { get; } = cd.Where(s => s <= 16).ToList();
-        private static IReadOnlyList<int> unknown { get; } = new List<int> { 1 };
+        private static IReadOnlyList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
+        private static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
+        private static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
+        private static IReadOnlyList<int> Unknown { get; } = new List<int> { 1 };
 
         /// <summary>
         /// Get list of all drive speeds for a given MediaType
@@ -32,16 +33,16 @@ namespace MPF.Data
             {
                 case MediaType.CDROM:
                 case MediaType.GDROM:
-                    return cd;
+                    return CD;
                 case MediaType.DVD:
                 case MediaType.HDDVD:
                 case MediaType.NintendoGameCubeGameDisc:
                 case MediaType.NintendoWiiOpticalDisc:
-                    return dvd;
+                    return DVD;
                 case MediaType.BluRay:
-                    return bd;
+                    return BD;
                 default:
-                    return unknown;
+                    return Unknown;
             }
         }
     }
@@ -99,11 +100,7 @@ namespace MPF.Data
         public const string PlayStationEDCField = "EDC";
         public const string PlayStationAntiModchipField = "Anti-modchip";
         public const string PlayStationLibCryptField = "LibCrypt";
-        public const string XBOXDMIHash = "DMI.bin Hashes";
-        public const string XBOXPFIHash = "PFI.bin Hashes";
-        public const string XBOXSSHash = "SS.bin Hashes";
         public const string XBOXSSRanges = "Security Sector Ranges";
-        public const string XBOXSSVersion = "Security Sector Version";
 
         // Default values
 

MPF.Core/Data/Drive.cs

@@ -0,0 +1,484 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Management;
+using MPF.Core.Converters;
+using MPF.Core.Utilities;
+using RedumpLib.Data;
+#if NET_FRAMEWORK
+using IMAPI2;
+#else
+using Aaru.CommonTypes.Enums;
+using AaruDevices = Aaru.Devices;
+#endif
+
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Represents information for a single drive
+    /// </summary>
+    public class Drive
+    {
+        /// <summary>
+        /// Represents drive type
+        /// </summary>
+        public InternalDriveType? InternalDriveType { get; set; }
+
+        /// <summary>
+        /// Drive partition format
+        /// </summary>
+        public string DriveFormat => driveInfo?.DriveFormat;
+
+        /// <summary>
+        /// Windows drive letter
+        /// </summary>
+        public char Letter => driveInfo?.Name[0] ?? '\0';
+
+        /// <summary>
+        /// Windows drive path
+        /// </summary>
+        public string Name => driveInfo?.Name;
+
+        /// <summary>
+        /// Represents if Windows has marked the drive as active
+        /// </summary>
+        public bool MarkedActive => driveInfo?.IsReady ?? false;
+
+        /// <summary>
+        /// Media label as read by Windows
+        /// </summary>
+        /// <remarks>The try/catch is needed because Windows will throw an exception if the drive is not marked as active</remarks>
+        public string VolumeLabel
+        {
+            get
+            {
+                try
+                {
+                    return driveInfo?.VolumeLabel;
+                }
+                catch
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Media label as read by Windows, formatted to avoid odd outputs
+        /// </summary>
+        public string FormattedVolumeLabel
+        {
+            get
+            {
+                string volumeLabel = Template.DiscNotDetected;
+                if (driveInfo.IsReady)
+                {
+                    if (string.IsNullOrWhiteSpace(driveInfo.VolumeLabel))
+                        volumeLabel = "track";
+                    else
+                        volumeLabel = driveInfo.VolumeLabel;
+                }
+
+                foreach (char c in Path.GetInvalidFileNameChars())
+                    volumeLabel = volumeLabel.Replace(c, '_');
+
+                return volumeLabel;
+            }
+        }
+
+        /// <summary>
+        /// DriveInfo object representing the drive, if possible
+        /// </summary>
+        private readonly DriveInfo driveInfo;
+
+        public Drive(InternalDriveType? driveType, DriveInfo driveInfo)
+        {
+            this.InternalDriveType = driveType;
+            this.driveInfo = driveInfo;
+        }
+
+        /// <summary>
+        /// Create a list of active drives matched to their volume labels
+        /// </summary>
+        /// <param name="ignoreFixedDrives">Ture to ignore fixed drives from population, false otherwise</param>
+        /// <returns>Active drives, matched to labels, if possible</returns>
+        /// <remarks>
+        /// https://stackoverflow.com/questions/3060796/how-to-distinguish-between-usb-and-floppy-devices?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
+        /// https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx
+        /// </remarks>
+        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
+        {
+            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
+            if (!ignoreFixedDrives)
+            {
+                desiredDriveTypes.Add(DriveType.Fixed);
+                desiredDriveTypes.Add(DriveType.Removable);
+            }
+
+            // Get all supported drive types
+            var drives = DriveInfo.GetDrives()
+                .Where(d => desiredDriveTypes.Contains(d.DriveType))
+                .Select(d => new Drive(EnumConverter.ToInternalDriveType(d.DriveType), d))
+                .ToList();
+
+            // TODO: Management searcher stuff is not supported on other platforms
+            // Get the floppy drives and set the flag from removable
+            try
+            {
+                ManagementObjectSearcher searcher =
+                    new ManagementObjectSearcher("root\\CIMV2",
+                    "SELECT * FROM Win32_LogicalDisk");
+
+                var collection = searcher.Get();
+                foreach (ManagementObject queryObj in collection)
+                {
+                    uint? mediaType = (uint?)queryObj["MediaType"];
+                    if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
+                    {
+                        char devId = queryObj["DeviceID"].ToString()[0];
+                        drives.ForEach(d => { if (d.Letter == devId) { d.InternalDriveType = Data.InternalDriveType.Floppy; } });
+                    }
+                }
+            }
+            catch
+            {
+                // No-op
+            }
+
+            // Order the drives by drive letter
+            drives = drives.OrderBy(i => i.Letter).ToList();
+
+            return drives;
+        }
+
+        /// <summary>
+        /// Get the current media type from drive letter
+        /// </summary>
+        /// <param name="drive"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This may eventually be replaced by Aaru.Devices being able to be about 10x more accurate.
+        /// This will also end up making it so that IMAPI2 is no longer necessary. Unfortunately, that
+        /// will only work for .NET Core 3.1 and beyond.
+        /// </remarks>
+        public (MediaType?, string) GetMediaType()
+        {
+            // Take care of the non-optical stuff first
+            // TODO: See if any of these can be more granular, like Optical is
+            if (this.InternalDriveType == Data.InternalDriveType.Floppy)
+                return (MediaType.FloppyDisk, null);
+            else if (this.InternalDriveType == Data.InternalDriveType.HardDisk)
+                return (MediaType.HardDisk, null);
+            else if (this.InternalDriveType == Data.InternalDriveType.Removable)
+                return (MediaType.FlashDrive, null);
+
+#if NET_FRAMEWORK
+            // Get the current drive information
+            string deviceId = null;
+            bool loaded = false;
+            try
+            {
+                // Get the device ID first
+                var searcher = new ManagementObjectSearcher(
+                    "root\\CIMV2",
+                    $"SELECT * FROM Win32_CDROMDrive WHERE Id = '{this.Letter}:\'");
+
+                foreach (ManagementObject queryObj in searcher.Get())
+                {
+                    deviceId = (string)queryObj["DeviceID"];
+                    loaded = (bool)queryObj["MediaLoaded"];
+                }
+
+                // If we got no valid device, we don't care and just return
+                if (deviceId == null)
+                    return (null, "Device could not be found");
+                else if (!loaded)
+                    return (null, "Device is not reporting media loaded");
+
+                MsftDiscMaster2 discMaster = new MsftDiscMaster2();
+                deviceId = deviceId.ToLower().Replace('\\', '#').Replace('/', '#');
+                string id = null;
+                foreach (var disc in discMaster)
+                {
+                    if (disc.ToString().Contains(deviceId))
+                        id = disc.ToString();
+                }
+
+                // If we couldn't find the drive, we don't care and return
+                if (id == null)
+                    return (null, "Device ID could not be found");
+
+                // Create the required objects for reading from the drive
+                MsftDiscRecorder2 recorder = new MsftDiscRecorder2();
+                recorder.InitializeDiscRecorder(id);
+                MsftDiscFormat2Data dataWriter = new MsftDiscFormat2Data();
+
+                // If the recorder is not supported, just return
+                if (!dataWriter.IsRecorderSupported(recorder))
+                    return (null, "IMAPI2 recorder not supported");
+
+                // Otherwise, set the recorder to get information from
+                dataWriter.Recorder = recorder;
+
+                var media = dataWriter.CurrentPhysicalMediaType;
+                return (media.IMAPIToMediaType(), null);
+            }
+            catch (Exception ex)
+            {
+                return (null, ex.Message);
+            }
+#else
+            try
+            {
+                var device = new AaruDevices.Device(this.Name);
+                if (device.Error)
+                    return (null, "Could not open device");
+                else if (device.Type != DeviceType.ATAPI && device.Type != DeviceType.SCSI)
+                    return (null, "Device does not support media type detection");
+
+                // TODO: In order to get the disc type, Aaru.Core will need to be included as a
+                // package. Unfortunately, it currently has a conflict with one of the required libraries:
+                // System.Text.Encoding.CodePages (BOS uses >= 5.0.0, DotNetZip uses >= 4.5.0 && < 5.0.0)
+            }
+            catch (Exception ex)
+            {
+                return (null, ex.Message);
+            }
+
+            return (null, "Media detection only supported on .NET Framework");
+#endif
+        }
+
+        /// <summary>
+        /// Get the current system from drive
+        /// </summary>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public RedumpSystem? GetRedumpSystem(RedumpSystem? defaultValue)
+        {
+            string drivePath = $"{this.Letter}:\\";
+
+            // If we can't read the media in that drive, we can't do anything
+            if (!Directory.Exists(drivePath))
+                return defaultValue;
+
+            // We're going to assume for floppies, HDDs, and removable drives
+            // TODO: Try to be smarter about this
+            if (this.InternalDriveType != Data.InternalDriveType.Optical)
+                return RedumpSystem.IBMPCcompatible;
+
+            // Check volume labels first
+            RedumpSystem? systemFromLabel = GetRedumpSystemFromVolumeLabel();
+            if (systemFromLabel != null)
+                return systemFromLabel;
+
+            #region Consoles
+
+            // Microsoft Xbox 360
+            try
+            {
+                if (Directory.Exists(Path.Combine(drivePath, "$SystemUpdate"))
+                    && Directory.EnumerateFiles(Path.Combine(drivePath, "$SystemUpdate")).Any())
+                {
+                    return RedumpSystem.MicrosoftXbox360;
+                }
+            }
+            catch { }
+
+            // Sega Dreamcast
+            if (File.Exists(Path.Combine(drivePath, "IP.BIN")))
+            {
+                return RedumpSystem.SegaDreamcast;
+            }
+
+            // Sega Mega-CD / Sega-CD
+            if (File.Exists(Path.Combine(drivePath, "_BOOT", "IP.BIN"))
+                || File.Exists(Path.Combine(drivePath, "_BOOT", "SP.BIN"))
+                || File.Exists(Path.Combine(drivePath, "_BOOT", "SP_AS.BIN"))
+                || File.Exists(Path.Combine(drivePath, "FILESYSTEM.BIN")))
+            {
+                return RedumpSystem.SegaMegaCDSegaCD;
+            }
+
+            // Sega Saturn
+            try
+            {
+                byte[] sector = ReadSector(0);
+                if (sector != null)
+                {
+                    if (sector.StartsWith(Interface.SaturnSectorZeroStart))
+                        return RedumpSystem.SegaSaturn;
+                }
+            }
+            catch { }
+
+            // Sony PlayStation and Sony PlayStation 2
+            string psxExePath = Path.Combine(drivePath, "PSX.EXE");
+            string systemCnfPath = Path.Combine(drivePath, "SYSTEM.CNF");
+            if (File.Exists(systemCnfPath))
+            {
+                // Check for either BOOT or BOOT2
+                var systemCnf = new IniFile(systemCnfPath);
+                if (systemCnf.ContainsKey("BOOT"))
+                    return RedumpSystem.SonyPlayStation;
+                else if (systemCnf.ContainsKey("BOOT2"))
+                    return RedumpSystem.SonyPlayStation2;
+            }
+            else if (File.Exists(psxExePath))
+            {
+                return RedumpSystem.SonyPlayStation;
+            }
+
+            // V.Tech V.Flash / V.Smile Pro
+            if (File.Exists(Path.Combine(drivePath, "0SYSTEM")))
+            {
+                return RedumpSystem.VTechVFlashVSmilePro;
+            }
+
+            #endregion
+
+            #region Video Formats
+
+            // BD-Video
+            if (Directory.Exists(Path.Combine(drivePath, "BDMV")))
+            {
+                // Technically BD-Audio has this as well, but it's hard to split that out right now
+                return RedumpSystem.BDVideo;
+            }
+
+            // DVD-Audio and DVD-Video
+            try
+            {
+                if (Directory.Exists(Path.Combine(drivePath, "AUDIO_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(drivePath, "AUDIO_TS")).Any())
+                {
+                    return RedumpSystem.DVDAudio;
+                }
+
+                else if (Directory.Exists(Path.Combine(drivePath, "VIDEO_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VIDEO_TS")).Any())
+                {
+                    return RedumpSystem.DVDVideo;
+                }
+            }
+            catch { }
+
+            // HD-DVD-Video
+            try
+            {
+                if (Directory.Exists(Path.Combine(drivePath, "HVDVD_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(drivePath, "HVDVD_TS")).Any())
+                {
+                    return RedumpSystem.HDDVDVideo;
+                }
+            }
+            catch { }
+
+            // VCD
+            try
+            {
+                if (Directory.Exists(Path.Combine(drivePath, "VCD"))
+                    && Directory.EnumerateFiles(Path.Combine(drivePath, "VCD")).Any())
+                {
+                    return RedumpSystem.VideoCD;
+                }
+            }
+            catch { }
+
+            #endregion
+
+            // Default return
+            return defaultValue;
+        }
+
+        /// <summary>
+        /// Get the current system from the drive volume label
+        /// </summary>
+        /// <returns>The system based on volume label, null if none detected</returns>
+        public RedumpSystem? GetRedumpSystemFromVolumeLabel()
+        {
+            // If the volume label is empty, we can't do anything
+            if (string.IsNullOrWhiteSpace(this.VolumeLabel))
+                return null;
+
+            // Audio CD
+            if (this.VolumeLabel.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.AudioCD;
+
+            // Microsoft Xbox
+            if (this.VolumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+            else if (this.VolumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+
+            // Microsoft Xbox 360
+            if (this.VolumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (this.VolumeLabel.Equals("XGD2DVD_NTSC", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox360;
+
+            // Microsoft Xbox 360 - Too overly broad even if a lot of discs use this
+            //if (this.VolumeLabel.Equals("CD_ROM", StringComparison.OrdinalIgnoreCase))
+            //    return RedumpSystem.MicrosoftXbox360; // Also for Xbox One?
+            //if (this.VolumeLabel.Equals("DVD_ROM", StringComparison.OrdinalIgnoreCase))
+            //    return RedumpSystem.MicrosoftXbox360;
+
+            // Sony PlayStation 3
+            if (this.VolumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation3;
+
+            // Sony PlayStation 4
+            if (this.VolumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation4;
+
+            // Sony PlayStation 5
+            if (this.VolumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation5;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Read a sector with a specified size from the drive
+        /// </summary>
+        /// <param name="num">Sector number, non-negative</param>
+        /// <param name="size">Size of a sector in bytes</param>
+        /// <returns>Byte array representing the sector, null on error</returns>
+        public byte[] ReadSector(long num, int size = 2048)
+        {
+            // Missing drive leter is not supported
+            if (string.IsNullOrEmpty(this.driveInfo?.Name))
+                return null;
+
+            // We don't support negative sectors
+            if (num < 0)
+                return null;
+
+            // Wrap the following in case of device access errors
+            Stream fs = null;
+            try
+            {
+                // Open the drive as a device
+                fs = File.OpenRead($"\\\\?\\{this.Letter}:");
+
+                // Seek to the start of the sector, if possible
+                long start = num * size;
+                fs.Seek(start, SeekOrigin.Begin);
+
+                // Read and return the sector
+                byte[] buffer = new byte[size];
+                fs.Read(buffer, 0, size);
+                return buffer;
+            }
+            catch
+            {
+                return null;
+            }
+            finally
+            {
+                fs?.Dispose();
+            }
+        }
+    }
+}

MPF.Core/Data/Enumerations.cs

@@ -0,0 +1,31 @@
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Drive type for dumping
+    /// </summary>
+    public enum InternalDriveType
+    {
+        Optical,
+        Floppy,
+        HardDisk,
+        Removable,
+    }
+
+    /// <summary>
+    /// Program that is being used to dump media
+    /// </summary>
+    public enum InternalProgram
+    {
+        NONE = 0,
+
+        // Dumping support
+        Aaru,
+        DD,
+        DiscImageCreator,
+
+        // Verification support only
+        CleanRip,
+        DCDumper,
+        UmdImageCreator,
+    }
+}

MPF.Core/Data/IniFile.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 
-namespace MPF.Data
+namespace MPF.Core.Data
 {
     public class IniFile : IDictionary<string, string>
     {

MPF.Core/Data/Options.cs

@@ -1,14 +1,14 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using MPF.Utilities;
+using MPF.Core.Converters;
+using RedumpLib.Data;
 
-namespace MPF.Data
+namespace MPF.Core.Data
 {
     public class Options : IDictionary<string, string>, ICloneable
     {
-        private Dictionary<string, string> _settings;
+        private readonly Dictionary<string, string> _settings;
 
         #region Internal Program
 
@@ -47,7 +47,7 @@ namespace MPF.Data
             get
             {
                 string valueString = GetStringSetting(_settings, "InternalProgram", InternalProgram.DiscImageCreator.ToString());
-                var valueEnum = Converters.ToInternalProgram(valueString);
+                var valueEnum = EnumConverter.ToInternalProgram(valueString);
                 return valueEnum == InternalProgram.NONE ? InternalProgram.DiscImageCreator : valueEnum;
             }
             set
@@ -60,6 +60,24 @@ namespace MPF.Data
 
         #region UI Defaults
 
+        /// <summary>
+        /// Enable dark mode for UI elements
+        /// </summary>
+        public bool EnableDarkMode
+        {
+            get { return GetBooleanSetting(_settings, "EnableDarkMode", false); }
+            set { _settings["EnableDarkMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Check for updates on startup
+        /// </summary>
+        public bool CheckForUpdatesOnStartup
+        {
+            get { return GetBooleanSetting(_settings, "CheckForUpdatesOnStartup", true); }
+            set { _settings["CheckForUpdatesOnStartup"] = value.ToString(); }
+        }
+
         /// <summary>
         /// Default output path for dumps
         /// </summary>
@@ -72,20 +90,30 @@ namespace MPF.Data
         /// <summary>
         /// Default system if none can be detected
         /// </summary>
-        public KnownSystem DefaultSystem
+        public RedumpSystem? DefaultSystem
         {
             get
             {
-                string valueString = GetStringSetting(_settings, "DefaultSystem", KnownSystem.NONE.ToString());
-                var valueEnum = Converters.ToKnownSystem(valueString);
-                return valueEnum ?? KnownSystem.NONE;
+                string valueString = GetStringSetting(_settings, "DefaultSystem", null);
+                var valueEnum = Extensions.ToRedumpSystem(valueString);
+                return valueEnum;
             }
             set
             {
-                _settings["DefaultSystem"] = Converters.GetLongName(value);
+                _settings["DefaultSystem"] = value.LongName();
             }
         }
 
+        /// <summary>
+        /// Default output path for dumps
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public bool ShowDebugViewMenuItem
+        {
+            get { return GetBooleanSetting(_settings, "ShowDebugViewMenuItem", false); }
+            set { _settings["ShowDebugViewMenuItem"] = value.ToString(); }
+        }
+
         #endregion
 
         #region Dumping Speeds
@@ -251,6 +279,24 @@ namespace MPF.Data
             set { _settings["PromptForDiscInformation"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Enable tabs in all input fields
+        /// </summary>
+        public bool EnableTabsInInputFields
+        {
+            get { return GetBooleanSetting(_settings, "EnableTabsInInputFields", false); }
+            set { _settings["EnableTabsInInputFields"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show disc eject reminder before the disc information window is shown
+        /// </summary>
+        public bool ShowDiscEjectReminder
+        {
+            get { return GetBooleanSetting(_settings, "ShowDiscEjectReminder", true); }
+            set { _settings["ShowDiscEjectReminder"] = value.ToString(); }
+        }
+
         /// <summary>
         /// Eject the disc after dumping
         /// </summary>
@@ -287,6 +333,15 @@ namespace MPF.Data
             set { _settings["OutputSubmissionJSON"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Include log files in serialized JSON data
+        /// </summary>
+        public bool IncludeArtifacts
+        {
+            get { return GetBooleanSetting(_settings, "IncludeArtifacts", false); }
+            set { _settings["IncludeArtifacts"] = value.ToString(); }
+        }
+
         /// <summary>
         /// Compress output log files to reduce space
         /// </summary>
@@ -320,6 +375,46 @@ namespace MPF.Data
 
         #endregion
 
+        #region Protection Scanning Options
+
+        /// <summary>
+        /// Scan archive contents during protection scanning
+        /// </summary>
+        public bool ScanArchivesForProtection
+        {
+            get { return GetBooleanSetting(_settings, "ScanArchivesForProtection", true); }
+            set { _settings["ScanArchivesForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Scan for executable packers during protection scanning
+        /// </summary>
+        public bool ScanPackersForProtection
+        {
+            get { return GetBooleanSetting(_settings, "ScanPackersForProtection", false); }
+            set { _settings["ScanPackersForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Force scanning all files for protection
+        /// </summary>
+        public bool ForceScanningForProtection
+        {
+            get { return GetBooleanSetting(_settings, "ForceScanningForProtection", false); }
+            set { _settings["ForceScanningForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include debug information with scan results
+        /// </summary>
+        public bool IncludeDebugProtectionInformation
+        {
+            get { return GetBooleanSetting(_settings, "IncludeDebugProtectionInformation", false); }
+            set { _settings["IncludeDebugProtectionInformation"] = value.ToString(); }
+        }
+
+        #endregion
+
         #region Logging Options
 
         /// <summary>

MPF.Core/Data/ProcessingQueue.cs

@@ -3,7 +3,7 @@ using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace MPF.Data
+namespace MPF.Core.Data
 {
     public class ProcessingQueue<T> : IDisposable
     {
@@ -33,10 +33,7 @@ namespace MPF.Data
         /// <summary>
         /// Dispose the current instance
         /// </summary>
-        public void Dispose()
-        {
-            this.TokenSource.Cancel();
-        }
+        public void Dispose() => this.TokenSource.Cancel();
 
         /// <summary>
         /// Enqueue a new item for processing
@@ -62,6 +59,7 @@ namespace MPF.Data
                     if (this.TokenSource.IsCancellationRequested)
                         break;
 
+                    Thread.Sleep(10);
                     continue;
                 }
 

MPF.Core/Data/Result.cs

@@ -1,4 +1,4 @@
-namespace MPF.Data
+namespace MPF.Core.Data
 {
     /// <summary>
     /// Generic success/failure result object, with optional message

MPF.Core/Data/XgdInfo.cs

@@ -0,0 +1,423 @@
+using RedumpLib.Data;
+
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Contains information specific to an XGD disc
+    /// </summary>
+    /// <remarks>
+    /// XGD1 XMID Format Information:
+    ///
+    /// AABBBCCD
+    /// - AA        => The two-ASCII-character publisher identifier (see GetPublisher for details)
+    /// - BBB       => Game ID
+    /// - CC        => Version number
+    /// - D         => Region identifier (see GetRegion for details)
+    ///
+    /// XGD2/3 XeMID Format Information:
+    ///
+    /// AABCCCDDEFFGHH(IIIIIIII)
+    /// - AA        => The two-ASCII-character publisher identifier (see GetPublisher for details)
+    /// - B         => Platform identifier; 2 indicates Xbox 360.
+    /// - CCC       => Game ID
+    /// - DD        => SKU number (unique per SKU of a title)
+    /// - E         => Region identifier (see GetRegion for details)
+    /// - FF        => Base version; usually starts at 01 (can be 1 or 2 characters)
+    /// - G         => Media type identifier (see GetMediaSubtype for details)
+    /// - HH        => Disc number stored in [disc number][total discs] format
+    /// - IIIIIIII  => 8-hex-digit certification submission identifier; usually on test discs only
+    /// </remarks>
+    public class XgdInfo
+    {
+        #region Fields
+
+        /// <summary>
+        /// Indicates whether the information in this object is fully instantiated or not
+        /// </summary>
+        public bool Initialized { get; private set; }
+
+        /// <summary>
+        /// Raw XMID/XeMID string that all other information is derived from
+        /// </summary>
+        public string XMID { get; private set; }
+
+        /// <summary>
+        /// 2-character publisher identifier
+        /// </summary>
+        public string PublisherIdentifier { get; private set; }
+
+        /// <summary>
+        /// Platform disc is made for, 2 indicates Xbox 360
+        /// </summary>
+        public char? PlatformIdentifier { get; private set; }
+
+        /// <summary>
+        /// Game ID
+        /// </summary>
+        public string GameID { get; private set; }
+
+        /// <summary>
+        /// For XGD1:   Internal version number
+        /// For XGD2/3: Title-specific SKU
+        /// </summary>
+        public string SKU { get; private set; }
+
+        /// <summary>
+        /// Region identifier character
+        /// </summary>
+        public char RegionIdentifier { get; private set; }
+
+        /// <summary>
+        /// Base version of executables, usually starts at 01
+        /// </summary>
+        /// <remarks>
+        /// TODO: Check if this is always 2 characters for XGD2/3
+        /// </remarks>
+        public string BaseVersion { get; private set; }
+
+        /// <summary>
+        /// Media subtype identifier
+        /// </summary>
+        public char MediaSubtypeIdentifier { get; private set; }
+
+        /// <summary>
+        /// Disc number stored in [disc number][total discs] format
+        /// </summary>
+        public string DiscNumberIdentifier { get; private set; }
+
+        /// <summary>
+        /// 8-hex-digit certification submission identifier; usually on test discs only
+        /// </summary>
+        public string CertificationSubmissionIdentifier { get; private set; }
+
+        #endregion
+
+        #region Auto-Generated Information
+
+        /// <summary>
+        /// Human-readable name derived from the publisher identifier
+        /// </summary>
+        public string PublisherName => GetPublisher(this.PublisherIdentifier);
+
+        /// <summary>
+        /// Internally represented region
+        /// </summary>
+        public Region? InternalRegion => GetRegion(this.RegionIdentifier);
+
+        /// <summary>
+        /// Human-readable subtype derived from the media identifier
+        /// </summary>
+        public string MediaSubtype => GetMediaSubtype(this.MediaSubtypeIdentifier);
+
+        #endregion
+
+        /// <summary>
+        /// Populate a set of XGD information from a Master ID (XMID/XeMID) string
+        /// </summary>
+        /// <param name="xmid">XMID/XeMID string representing the DMI information</param>
+        /// <param name="validate">True if value validation should be performed, false otherwise</param>
+        public XgdInfo(string xmid, bool validate = false)
+        {
+            this.Initialized = false;
+            if (string.IsNullOrWhiteSpace(xmid))
+                return;
+
+            this.XMID = xmid.TrimEnd('\0');
+            if (string.IsNullOrWhiteSpace(this.XMID))
+                return;
+
+            // XGD1 information is 8 characters
+            if (this.XMID.Length == 8)
+                this.Initialized = ParseXGD1XMID(this.XMID, validate);
+
+            // XGD2/3 information is semi-variable length
+            else if (this.XMID.Length == 13 || this.XMID.Length == 14 || this.XMID.Length == 21 || this.XMID.Length == 22)
+                this.Initialized = ParseXGD23XeMID(this.XMID, validate);
+        }
+
+        /// <summary>
+        /// Get the human-readable serial string
+        /// </summary>
+        /// <returns>Formatted serial string, null on error</returns>
+        public string GetSerial()
+        {
+            if (!this.Initialized)
+                return null;
+
+            try
+            {
+                // XGD1 doesn't use PlatformIdentifier
+                if (this.PlatformIdentifier == null)
+                    return $"{this.PublisherIdentifier}-{this.GameID}";
+
+                // XGD2/3 uses a specific identifier
+                else if (this.PlatformIdentifier == '2')
+                    return $"{this.PublisherIdentifier}-{this.PlatformIdentifier}{this.GameID}";
+
+                return null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the human-readable version string
+        /// </summary>
+        /// <returns>Formatted version string, null on error</returns>
+        /// <remarks>This may differ for XGD2/3 in the future</remarks>
+        public string GetVersion()
+        {
+            if (!this.Initialized)
+                return null;
+
+            try
+            {
+                // XGD1 doesn't use PlatformIdentifier
+                if (this.PlatformIdentifier == null)
+                    return $"1.{this.SKU}";
+
+                // XGD2/3 uses a specific identifier
+                else if (this.PlatformIdentifier == '2')
+                    return $"1.{this.SKU}";
+
+                return null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Parse an XGD1 XMID string
+        /// </summary>
+        /// <param name="xmid">XMID string to attempt to parse</param>
+        /// <param name="validate">True if value validation should be performed, false otherwise</param>
+        /// <returns>True if the XMID could be parsed, false otherwise</returns>
+        private bool ParseXGD1XMID(string xmid, bool validate)
+        {
+            if (xmid == null || xmid.Length != 8)
+                return false;
+
+            this.PublisherIdentifier = xmid.Substring(0, 2);
+            if (validate && string.IsNullOrEmpty(this.PublisherName))
+                return false;
+
+            this.GameID = xmid.Substring(2, 3);
+            this.SKU = xmid.Substring(5, 2);
+            this.RegionIdentifier = xmid[7];
+            if (validate && this.InternalRegion == null)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Parse an XGD2/3 XeMID string
+        /// </summary>
+        /// <param name="xemid">XeMID string to attempt to parse</param>
+        /// <param name="validate">True if value validation should be performed, false otherwise</param>
+        /// <returns>True if the XeMID could be parsed, false otherwise</returns>
+        private bool ParseXGD23XeMID(string xemid, bool validate)
+        {
+            if (xemid == null
+                || (xemid.Length != 13 && xemid.Length != 14
+                    && xemid.Length != 21 && xemid.Length != 22))
+                return false;
+
+            this.PublisherIdentifier = xemid.Substring(0, 2);
+            if (validate && string.IsNullOrEmpty(this.PublisherName))
+                return false;
+
+            this.PlatformIdentifier = xemid[2];
+            if (validate && this.PlatformIdentifier != '2')
+                return false;
+
+            this.GameID = xemid.Substring(3, 3);
+            this.SKU = xemid.Substring(6, 2);
+            this.RegionIdentifier = xemid[8];
+            if (validate && this.InternalRegion == null)
+                return false;
+
+            if (xemid.Length == 13 || xemid.Length == 21)
+            {
+                this.BaseVersion = xemid.Substring(9, 1);
+                this.MediaSubtypeIdentifier = xemid[10];
+                if (validate && string.IsNullOrEmpty(this.MediaSubtype))
+                    return false;
+
+                this.DiscNumberIdentifier = xemid.Substring(11, 2);
+            }
+            else if (xemid.Length == 14 || xemid.Length == 22)
+            {
+                this.BaseVersion = xemid.Substring(9, 2);
+                this.MediaSubtypeIdentifier = xemid[11];
+                if (validate && string.IsNullOrEmpty(this.MediaSubtype))
+                    return false;
+
+                this.DiscNumberIdentifier = xemid.Substring(12, 2);
+            }
+
+            if (xemid.Length == 21)
+                this.CertificationSubmissionIdentifier = xemid.Substring(13);
+            else if (xemid.Length == 22)
+                this.CertificationSubmissionIdentifier = xemid.Substring(14);
+
+            return true;
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Determine the XGD type based on the XGD2/3 media type identifier character
+        /// </summary>
+        /// <param name="mediaTypeIdentifier">Character denoting the media type</param>
+        /// <returns>Media subtype as a string, if possible</returns>
+        private static string GetMediaSubtype(char mediaTypeIdentifier)
+        {
+            switch (mediaTypeIdentifier)
+            {
+                case 'F': return "XGD3";
+                case 'X': return "XGD2";
+                case 'Z': return "Games on Demand / Marketplace Demo";
+                default: return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the full name of the publisher from the 2-character identifier
+        /// </summary>
+        /// <param name="publisherIdentifier">Case-sensitive 2-character identifier</param>
+        /// <returns>Publisher name, if possible</returns>
+        /// <see cref="https://xboxdevwiki.net/Xbe#Title_ID"/>
+        private static string GetPublisher(string publisherIdentifier)
+        {
+            switch (publisherIdentifier)
+            {
+                case "AC": return "Acclaim Entertainment";
+                case "AH": return "ARUSH Entertainment";
+                case "AQ": return "Aqua System";
+                case "AS": return "ASK";
+                case "AT": return "Atlus";
+                case "AV": return "Activision";
+                case "AY": return "Aspyr Media";
+                case "BA": return "Bandai";
+                case "BL": return "Black Box";
+                case "BM": return "BAM! Entertainment";
+                case "BR": return "Broccoli Co.";
+                case "BS": return "Bethesda Softworks";
+                case "BU": return "Bunkasha Co.";
+                case "BV": return "Buena Vista Games";
+                case "BW": return "BBC Multimedia";
+                case "BZ": return "Blizzard";
+                case "CC": return "Capcom";
+                case "CK": return "Kemco Corporation"; // TODO: Confirm
+                case "CM": return "Codemasters";
+                case "CV": return "Crave Entertainment";
+                case "DC": return "DreamCatcher Interactive";
+                case "DX": return "Davilex";
+                case "EA": return "Electronic Arts (EA)";
+                case "EC": return "Encore inc";
+                case "EL": return "Enlight Software";
+                case "EM": return "Empire Interactive";
+                case "ES": return "Eidos Interactive";
+                case "FI": return "Fox Interactive";
+                case "FS": return "From Software";
+                case "GE": return "Genki Co.";
+                case "GV": return "Groove Games";
+                case "HE": return "Tru Blu (Entertainment division of Home Entertainment Suppliers)";
+                case "HP": return "Hip games";
+                case "HU": return "Hudson Soft";
+                case "HW": return "Highwaystar";
+                case "IA": return "Mad Catz Interactive";
+                case "IF": return "Idea Factory";
+                case "IG": return "Infogrames";
+                case "IL": return "Interlex Corporation";
+                case "IM": return "Imagine Media";
+                case "IO": return "Ignition Entertainment";
+                case "IP": return "Interplay Entertainment";
+                case "IX": return "InXile Entertainment"; // TODO: Confirm
+                case "JA": return "Jaleco";
+                case "JW": return "JoWooD";
+                case "KB": return "Kemco"; // TODO: Confirm
+                case "KI": return "Kids Station Inc."; // TODO: Confirm
+                case "KN": return "Konami";
+                case "KO": return "KOEI";
+                case "KU": return "Kobi and / or GAE (formerly Global A Entertainment)"; // TODO: Confirm
+                case "LA": return "LucasArts";
+                case "LS": return "Black Bean Games (publishing arm of Leader S.p.A.)";
+                case "MD": return "Metro3D";
+                case "ME": return "Medix";
+                case "MI": return "Microïds";
+                case "MJ": return "Majesco Entertainment";
+                case "MM": return "Myelin Media";
+                case "MP": return "MediaQuest"; // TODO: Confirm
+                case "MS": return "Microsoft Game Studios";
+                case "MW": return "Midway Games";
+                case "MX": return "Empire Interactive"; // TODO: Confirm
+                case "NK": return "NewKidCo";
+                case "NL": return "NovaLogic";
+                case "NM": return "Namco";
+                case "OX": return "Oxygen Interactive";
+                case "PC": return "Playlogic Entertainment";
+                case "PL": return "Phantagram Co., Ltd.";
+                case "RA": return "Rage";
+                case "SA": return "Sammy";
+                case "SC": return "SCi Games";
+                case "SE": return "SEGA";
+                case "SN": return "SNK";
+                case "SS": return "Simon & Schuster";
+                case "SU": return "Success Corporation";
+                case "SW": return "Swing! Deutschland";
+                case "TA": return "Takara";
+                case "TC": return "Tecmo";
+                case "TD": return "The 3DO Company (or just 3DO)";
+                case "TK": return "Takuyo";
+                case "TM": return "TDK Mediactive";
+                case "TQ": return "THQ";
+                case "TS": return "Titus Interactive";
+                case "TT": return "Take-Two Interactive Software";
+                case "US": return "Ubisoft";
+                case "VC": return "Victor Interactive Software";
+                case "VN": return "Vivendi Universal (just took Interplays publishing rights)"; // TODO: Confirm
+                case "VU": return "Vivendi Universal Games";
+                case "VV": return "Vivendi Universal Games"; // TODO: Confirm
+                case "WE": return "Wanadoo Edition";
+                case "WR": return "Warner Bros. Interactive Entertainment"; // TODO: Confirm
+                case "XI": return "XPEC Entertainment and Idea Factory";
+                case "XK": return "Xbox kiosk disk?"; // TODO: Confirm
+                case "XL": return "Xbox special bundled or live demo disk?"; // TODO: Confirm
+                case "XM": return "Evolved Games"; // TODO: Confirm
+                case "XP": return "XPEC Entertainment";
+                case "XR": return "Panorama";
+                case "YB": return "YBM Sisa (South-Korea)";
+                case "ZD": return "Zushi Games (formerly Zoo Digital Publishing)";
+                default: return null;
+            }
+        }
+
+        /// <summary>
+        /// Determine the region based on the XGD serial character
+        /// </summary>
+        /// <param name="region">Character denoting the region</param>
+        /// <returns>Region, if possible</returns>
+        private static Region? GetRegion(char region)
+        {
+            switch (region)
+            {
+                case 'W': return Region.World;
+                case 'A': return Region.UnitedStatesOfAmerica;
+                case 'J': return Region.JapanAsia;
+                case 'E': return Region.Europe;
+                case 'K': return Region.USAJapan;
+                case 'L': return Region.USAEurope;
+                case 'H': return Region.JapanEurope;
+                default: return null;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Hashing/Hasher.cs

@@ -1,11 +1,27 @@
 using System;
 using System.Linq;
 using System.Security.Cryptography;
-using MPF.Data;
-using OptimizedCRC;
 
-namespace MPF.Hashing
+namespace MPF.Core.Hashing
 {
+    /// <summary>
+    /// Available hashing types
+    /// </summary>
+    [Flags]
+    public enum Hash
+    {
+        CRC = 1 << 0,
+        MD5 = 1 << 1,
+        SHA1 = 1 << 2,
+        SHA256 = 1 << 3,
+        SHA384 = 1 << 4,
+        SHA512 = 1 << 5,
+
+        // Special combinations
+        Standard = CRC | MD5 | SHA1,
+        All = CRC | MD5 | SHA1 | SHA256 | SHA384 | SHA512,
+    }
+
     /// <summary>
     /// Async hashing class wraper
     /// </summary>
@@ -28,7 +44,7 @@ namespace MPF.Hashing
             switch (HashType)
             {
                 case Hash.CRC:
-                    _hasher = new OptimizedCRC.OptimizedCRC();
+                    _hasher = new OptimizedCRC();
                     break;
 
                 case Hash.MD5:
@@ -66,7 +82,7 @@ namespace MPF.Hashing
             switch (HashType)
             {
                 case Hash.CRC:
-                    (_hasher as OptimizedCRC.OptimizedCRC).Update(buffer, 0, size);
+                    (_hasher as OptimizedCRC).Update(buffer, 0, size);
                     break;
 
                 case Hash.MD5:
@@ -88,7 +104,7 @@ namespace MPF.Hashing
             switch (HashType)
             {
                 case Hash.CRC:
-                    (_hasher as OptimizedCRC.OptimizedCRC).Update(emptyBuffer, 0, 0);
+                    (_hasher as OptimizedCRC).Update(emptyBuffer, 0, 0);
                     break;
 
                 case Hash.MD5:
@@ -109,7 +125,7 @@ namespace MPF.Hashing
             switch (HashType)
             {
                 case Hash.CRC:
-                    return BitConverter.GetBytes((_hasher as OptimizedCRC.OptimizedCRC).Value).Reverse().ToArray();
+                    return BitConverter.GetBytes((_hasher as OptimizedCRC).Value).Reverse().ToArray();
 
                 case Hash.MD5:
                 case Hash.SHA1:

MPF.Core/Hashing/OptimizedCRC.cs

@@ -24,7 +24,8 @@
 
 using System;
 
-namespace OptimizedCRC
+//namespace OptimizedCRC
+namespace MPF.Core.Hashing
 {
     internal class OptimizedCRC : IDisposable
     {

MPF.Core/Hashing/ThreadLoadBuffer.cs

@@ -2,7 +2,8 @@
 using System.IO;
 using System.Threading;
 
-namespace Compress.ThreadReaders
+//namespace Compress.ThreadReaders
+namespace MPF.Core.Hashing
 {
     public class ThreadLoadBuffer : IDisposable
     {

MPF.Core/MPF.Core.csproj

@@ -0,0 +1,65 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2021</Copyright>
+    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+    <Version>2.3</Version>
+    <AssemblyVersion>$(Version)</AssemblyVersion>
+    <FileVersion>$(Version)</FileVersion>
+    <IncludeSource>true</IncludeSource>
+    <IncludeSymbols>true</IncludeSymbols>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
+    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
+    <NrtShowRevision>false</NrtShowRevision>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
+    <DefineConstants>NET_FRAMEWORK</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
+    <COMReference Include="IMAPI2">
+      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+    <COMReference Include="IMAPI2FS">
+      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="System.Management" Version="6.0.0-rc.1.21451.13" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'!='net48'">
+    <PackageReference Include="Aaru.Devices" Version="5.3.0-rc2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="System.Management" />
+  </ItemGroup>
+
+</Project>

MPF.Core/Utilities/BinaryReaderExtensions.cs

@@ -1,12 +1,12 @@
 using System;
 using System.IO;
 
-namespace MPF.Utilities
+namespace MPF.Core.Utilities
 {
     /// <summary>
     /// Big endian reading overloads for BinaryReader
     /// </summary>
-    internal static class BinaryReaderExtensions
+    public static class BinaryReaderExtensions
     {
         /// <summary>
         /// Reads the specified number of bytes from the stream, starting from a specified point in the byte array.

MPF.Core/Utilities/EnumExtensions.cs

@@ -0,0 +1,144 @@
+using RedumpLib.Data;
+
+namespace MPF.Core.Utilities
+{
+    public static class EnumExtensions
+    {
+        /// <summary>
+        /// Determine if a system is okay if it's not detected by Windows
+        /// </summary>
+        /// <param name="system">RedumpSystem value to check</param>
+        /// <returns>True if Windows show see a disc when dumping, false otherwise</returns>
+        public static bool DetectedByWindows(this RedumpSystem? system)
+        {
+            switch (system)
+            {
+                case RedumpSystem.AmericanLaserGames3DO:
+                case RedumpSystem.AppleMacintosh:
+                case RedumpSystem.Atari3DO:
+                case RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem:
+                case RedumpSystem.NewJatreCDi:
+                case RedumpSystem.NintendoGameCube:
+                case RedumpSystem.NintendoWii:
+                case RedumpSystem.NintendoWiiU:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.PhilipsCDiDigitalVideo:
+                case RedumpSystem.Panasonic3DOInteractiveMultiplayer:
+                case RedumpSystem.PanasonicM2:
+                case RedumpSystem.PioneerLaserActive:
+                case RedumpSystem.SuperAudioCD:
+                    return false;
+                default:
+                    return true;
+            }
+        }
+
+        /// <summary>
+        /// Determine if the media supports drive speeds
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
+        public static bool DoesSupportDriveSpeed(this MediaType? type)
+        {
+            switch (type)
+            {
+                case MediaType.CDROM:
+                case MediaType.DVD:
+                case MediaType.GDROM:
+                case MediaType.HDDVD:
+                case MediaType.BluRay:
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determine if a system has reversed ringcodes
+        /// </summary>
+        /// <param name="system">RedumpSystem value to check</param>
+        /// <returns>True if the system has reversed ringcodes, false otherwise</returns>
+        public static bool HasReversedRingcodes(this RedumpSystem? system)
+        {
+            switch (system)
+            {
+                case RedumpSystem.SonyPlayStation2:
+                case RedumpSystem.SonyPlayStation3:
+                case RedumpSystem.SonyPlayStation4:
+                //case RedumpSystem.SonyPlayStation5:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determine if a system is considered audio-only
+        /// </summary>
+        /// <param name="system">RedumpSystem value to check</param>
+        /// <returns>True if the system is audio-only, false otherwise</returns>
+        /// <remarks>
+        /// Philips CD-i should NOT be in this list. It's being included until there's a
+        /// reasonable distinction between CD-i and CD-i ready on the database side.
+        /// </remarks>
+        public static bool IsAudio(this RedumpSystem? system)
+        {
+            switch (system)
+            {
+                case RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem:
+                case RedumpSystem.AudioCD:
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.HasbroVideoNow:
+                case RedumpSystem.HasbroVideoNowColor:
+                case RedumpSystem.HasbroVideoNowJr:
+                case RedumpSystem.HasbroVideoNowXP:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.SuperAudioCD:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determine if a system is a marker value
+        /// </summary>
+        /// <param name="system">RedumpSystem value to check</param>
+        /// <returns>True if the system is a marker value, false otherwise</returns>
+        public static bool IsMarker(this RedumpSystem? system)
+        {
+            switch (system)
+            {
+                case RedumpSystem.MarkerArcadeEnd:
+                case RedumpSystem.MarkerComputerEnd:
+                case RedumpSystem.MarkerDiscBasedConsoleEnd:
+                // case RedumpSystem.MarkerOtherConsoleEnd:
+                case RedumpSystem.MarkerOtherEnd:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Determine if a system is considered XGD
+        /// </summary>
+        /// <param name="system">RedumpSystem value to check</param>
+        /// <returns>True if the system is XGD, false otherwise</returns>
+        public static bool IsXGD(this RedumpSystem? system)
+        {
+            switch (system)
+            {
+                case RedumpSystem.MicrosoftXbox:
+                case RedumpSystem.MicrosoftXbox360:
+                case RedumpSystem.MicrosoftXboxOne:
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}

MPF.Core/Utilities/Logging.cs

@@ -0,0 +1,121 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MPF.Core.Utilities
+{
+    public static class Logging
+    {
+        /// <summary>
+        /// Process a chunk of text and send it to a handler
+        /// </summary>
+        /// <param name="reader">TextReader representing the input</param>
+        /// <param name="baseClass">Invoking class, passed on to the event handler</param>
+        /// <param name="handler">Event handler to be invoked to write to log</param>
+        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<string> handler)
+        {
+            // Initialize the required variables
+            char[] buffer = new char[256];
+            int read = 0;
+            var sb = new StringBuilder();
+
+            try
+            {
+                while (true)
+                {
+                    // Try to read the next chunk of characters
+                    read = await reader.ReadAsync(buffer, 0, buffer.Length);
+                    if (read == 0)
+                    {
+                        Thread.Sleep(10);
+                        continue;
+                    }
+
+                    // Convert the characters into a string
+                    string line = new string(buffer, 0, read);
+
+                    // If we have no newline characters, store in the string builder
+                    if (!line.Contains("\r") && !line.Contains("\n"))
+                        sb.Append(line);
+
+                    // If we have a newline, append and log
+                    else if (line.Contains("\n") || line.Contains("\r\n"))
+                        ProcessNewLines(sb, line, baseClass, handler);
+
+                    // If we have a carriage return only, append and log first and last instances
+                    else if (line.Contains("\r"))
+                        ProcessCarriageReturns(sb, line, baseClass, handler);
+                }
+            }
+            catch { }
+            finally
+            {
+                handler?.Invoke(baseClass, sb.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Process a chunk that contains newlines
+        /// </summary>
+        /// <param name="sb">StringBuilder to write from and append to</param>
+        /// <param name="line">Current line to process</param>
+        /// <param name="baseClass">Invoking class, passed on to the event handler</param>
+        /// <param name="handler">Event handler to be invoked to write to log</param>
+        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+        {
+            line = line.Replace("\r\n", "\n");
+            var split = line.Split('\n');
+            for (int i = 0; i < split.Length; i++)
+            {
+                // If the chunk contains a carriage return, handle it like a separate line
+                if (split[i].Contains("\r"))
+                {
+                    ProcessCarriageReturns(sb, split[i], baseClass, handler);
+                    continue;
+                }
+
+                // For the first item, append to anything existing and then write out
+                if (i == 0)
+                {
+                    sb.Append(split[i]);
+                    handler?.Invoke(baseClass, sb.ToString());
+                    sb.Clear();
+                }
+
+                // For the last item, just append so it's dealt with the next time
+                else if (i == split.Length - 1)
+                {
+                    sb.Append(split[i]);
+                }
+
+                // For everything else, directly write out
+                else
+                {
+                    handler?.Invoke(baseClass, split[i]);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Process a chunk that contains carriage returns
+        /// </summary>
+        /// <param name="sb">StringBuilder to write from and append to</param>
+        /// <param name="line">Current line to process</param>
+        /// <param name="baseClass">Invoking class, passed on to the event handler</param>
+        /// <param name="handler">Event handler to be invoked to write to log</param>
+        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+        {
+            var split = line.Split('\r');
+
+            // Append and log the first
+            sb.Append(split[0]);
+            handler?.Invoke(baseClass, sb.ToString());
+
+            // Append the last
+            sb.Clear();
+            sb.Append($"\r{split[split.Length - 1]}");
+        }
+    }
+}

MPF.Core/Utilities/Tools.cs

@@ -1,8 +1,11 @@
 using System;
+using System.Net;
 using System.Reflection;
-using MPF.Redump;
+using MPF.Core.Data;
+using Newtonsoft.Json.Linq;
+using RedumpLib.Data;
 
-namespace MPF.Utilities
+namespace MPF.Core.Utilities
 {
     public static class Tools
     {
@@ -70,6 +73,54 @@ namespace MPF.Utilities
 
         #endregion
 
+        #region Support
+
+        /// <summary>
+        /// Verify that, given a system and a media type, they are correct
+        /// </summary>
+        public static Result GetSupportStatus(RedumpSystem? system, MediaType? type)
+        {
+            // No system chosen, update status
+            if (system == null)
+                return Result.Failure("Please select a valid system");
+
+            // If we're on an unsupported type, update the status accordingly
+            switch (type)
+            {
+                // Fully supported types
+                case MediaType.BluRay:
+                case MediaType.CDROM:
+                case MediaType.DVD:
+                case MediaType.FloppyDisk:
+                case MediaType.HardDisk:
+                case MediaType.CompactFlash:
+                case MediaType.SDCard:
+                case MediaType.FlashDrive:
+                case MediaType.HDDVD:
+                    return Result.Success($"{type.LongName()} ready to dump");
+
+                // Partially supported types
+                case MediaType.GDROM:
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return Result.Success($"{type.LongName()} partially supported for dumping");
+
+                // Special case for other supported tools
+                case MediaType.UMD:
+                    return Result.Failure($"{type.LongName()} supported for submission info parsing");
+
+                // Specifically unknown type
+                case MediaType.NONE:
+                    return Result.Failure($"Please select a valid media type");
+
+                // Undumpable but recognized types
+                default:
+                    return Result.Failure($"{type.LongName()} media are not supported for dumping");
+            }
+        }
+
+        #endregion
+
         #region Versioning
 
         /// <summary>
@@ -82,14 +133,14 @@ namespace MPF.Utilities
         /// </returns>
         public static (bool different, string message, string url) CheckForNewVersion()
         {
-            // Get current assembly version
-            var assemblyVersion = Assembly.GetEntryAssembly().GetName().Version;
-            string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}" + (assemblyVersion.Build != 0 ? $".{assemblyVersion.Build}" : string.Empty);
-
-            // Get the latest tag from GitHub
-            using (var client = new RedumpWebClient())
+            try
             {
-                (string tag, string url) = client.GetRemoteVersionAndUrl();
+                // Get current assembly version
+                var assemblyVersion = Assembly.GetEntryAssembly().GetName().Version;
+                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}" + (assemblyVersion.Build != 0 ? $".{assemblyVersion.Build}" : string.Empty);
+
+                // Get the latest tag from GitHub
+                (string tag, string url) = GetRemoteVersionAndUrl();
                 bool different = version != tag;
 
                 string message = $"Local version: {version}"
@@ -100,6 +151,10 @@ namespace MPF.Utilities
 
                 return (different, message, url);
             }
+            catch (Exception ex)
+            {
+                return (false, ex.ToString(), null);
+            }
         }
 
         /// <summary>
@@ -111,6 +166,26 @@ namespace MPF.Utilities
             return assemblyVersion.InformationalVersion;
         }
 
+        /// <summary>
+        /// Get the latest version of MPF from GitHub and the release URL
+        /// </summary>
+        private static (string tag, string url) GetRemoteVersionAndUrl()
+        {
+            using (WebClient wc = new WebClient())
+            {
+                wc.Headers["User-Agent"] = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0";
+
+                // TODO: Figure out a better way than having this hardcoded...
+                string url = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
+                string latestReleaseJsonString = wc.DownloadString(url);
+                var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
+                string latestTag = latestReleaseJson["tag_name"].ToString();
+                string releaseUrl = latestReleaseJson["html_url"].ToString();
+
+                return (latestTag, releaseUrl);
+            }
+        }
+
         #endregion
     }
 }

MPF.CueSheets/CueFile.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 
 /// <remarks>
@@ -71,10 +72,23 @@ namespace MPF.CueSheets
         /// <param name="fileType">File type to set</param>
         /// <param name="cueLines">Lines array to pull from</param>
         /// <param name="i">Reference to index in array</param>
-        public CueFile(string fileName, string fileType, string[] cueLines, ref int i)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public CueFile(string fileName, string fileType, string[] cueLines, ref int i, bool throwOnError = false)
         {
-            if (cueLines == null || i < 0 || i > cueLines.Length)
-                return; // TODO: Make this throw an exception
+            if (cueLines == null)
+            {
+                if (throwOnError)
+                    throw new ArgumentNullException(nameof(cueLines));
+
+                return;
+            }
+            else if (i < 0 || i > cueLines.Length)
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException();
+
+                return;
+            }
 
             // Set the current fields
             this.FileName = fileName.Trim('"');
@@ -102,14 +116,24 @@ namespace MPF.CueSheets
                     // Read track information
                     case "TRACK":
                         if (splitLine.Length < 3)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"TRACK line malformed: {line}");
+
+                            continue;
+                        }
 
                         if (this.Tracks == null)
                             this.Tracks = new List<CueTrack>();
 
                         var track = new CueTrack(splitLine[1], splitLine[2], cueLines, ref i);
                         if (track == default)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"TRACK line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Tracks.Add(track);
                         break;
@@ -126,11 +150,24 @@ namespace MPF.CueSheets
         /// Write the FILE out to a stream
         /// </summary>
         /// <param name="sw">StreamWriter to write to</param>
-        public void Write(StreamWriter sw)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public void Write(StreamWriter sw, bool throwOnError = false)
         {
             // If we don't have any tracks, it's invalid
-            if (this.Tracks == null || this.Tracks.Count == 0)
-                return; // TODO: Make this throw an exception
+            if (this.Tracks == null)
+            {
+                if (throwOnError)
+                    throw new ArgumentNullException(nameof(this.Tracks));
+
+                return;
+            }
+            else if (this.Tracks.Count == 0)
+            {
+                if (throwOnError)
+                    throw new ArgumentException("No tracks provided to write");
+
+                return;
+            }
 
             sw.WriteLine($"FILE \"{this.FileName}\" {FromFileType(this.FileType)}");
 

MPF.CueSheets/CueIndex.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Linq;
 
 /// <remarks>
@@ -45,47 +46,103 @@ namespace MPF.CueSheets
         /// </summary>
         /// <param name="index">Index to set</param>
         /// <param name="startTime">Start time to set</param>
-        public CueIndex(string index, string startTime)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public CueIndex(string index, string startTime, bool throwOnError = false)
         {
             // Set the current fields
             if (!int.TryParse(index, out int parsedIndex))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new ArgumentException($"Index was not a number: {index}");
+
+                return;
+            }
             else if (parsedIndex < 0 || parsedIndex > 99)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Index must be between 0 and 99: {parsedIndex}");
+
+                return;
+            }
 
             // Ignore empty lines
             if (string.IsNullOrWhiteSpace(startTime))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new ArgumentException("Start time was null or whitespace");
+
+                return;
+            }
 
             // Ignore lines that don't contain the correct information
             if (startTime.Length != 8 || startTime.Count(c => c == ':') != 2)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Start time was not in a recognized format: {startTime}");
+
+                return;
+            }
 
             // Split the line
             string[] splitTime = startTime.Split(':');
             if (splitTime.Length != 3)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Start time was not in a recognized format: {startTime}");
+
+                return;
+            }
 
             // Parse the lengths
             int[] lengthSegments = new int[3];
 
             // Minutes
             if (!int.TryParse(splitTime[0], out lengthSegments[0]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Minutes segment was not a number: {splitTime[0]}");
+
+                return;
+            }
             else if (lengthSegments[0] < 0)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
+
+                return;
+            }
 
             // Seconds
             if (!int.TryParse(splitTime[1], out lengthSegments[1]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Seconds segment was not a number: {splitTime[1]}");
+
+                return;
+            }
             else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
+
+                return;
+            }
 
             // Frames
             if (!int.TryParse(splitTime[2], out lengthSegments[2]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Frames segment was not a number: {splitTime[2]}");
+
+                return;
+            }
             else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
+
+                return;
+            }
 
             // Set the values
             this.Index = parsedIndex;

MPF.CueSheets/CueSheet.cs

@@ -56,7 +56,8 @@ namespace MPF.CueSheets
         /// Create a cuesheet from a file, if possible
         /// </summary>
         /// <param name="filename"></param>
-        public CueSheet(string filename)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public CueSheet(string filename, bool throwOnError = false)
         {
             // Check that the file exists
             if (!File.Exists(filename))
@@ -97,7 +98,12 @@ namespace MPF.CueSheets
                     // Read MCN
                     case "CATALOG":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"CATALOG line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Catalog = splitLine[1];
                         break;
@@ -105,7 +111,12 @@ namespace MPF.CueSheets
                     // Read external CD-Text file path
                     case "CDTEXTFILE":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"CDTEXTFILE line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.CdTextFile = splitLine[1];
                         break;
@@ -113,7 +124,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced performer
                     case "PERFORMER":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"PERFORMER line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Performer = splitLine[1];
                         break;
@@ -121,7 +137,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced songwriter
                     case "SONGWRITER":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"SONGWRITER line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Songwriter = splitLine[1];
                         break;
@@ -129,7 +150,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced title
                     case "TITLE":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"TITLE line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Title = splitLine[1];
                         break;
@@ -137,14 +163,24 @@ namespace MPF.CueSheets
                     // Read file information
                     case "FILE":
                         if (splitLine.Length < 3)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"FILE line malformed: {line}");
+
+                            continue;
+                        }
 
                         if (this.Files == null)
                             this.Files = new List<CueFile>();
 
                         var file = new CueFile(splitLine[1], splitLine[2], cueLines, ref i);
                         if (file == default)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"FILE line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Files.Add(file);
                         break;
@@ -168,11 +204,24 @@ namespace MPF.CueSheets
         /// Write the cuesheet out to a stream
         /// </summary>
         /// <param name="stream">Stream to write to</param>
-        public void Write(Stream stream)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public void Write(Stream stream, bool throwOnError = false)
         {
             // If we don't have any files, it's invalid
-            if (this.Files == null || this.Files.Count == 0)
-                return; // TODO: Make this throw an exception
+            if (this.Files == null)
+            {
+                if (throwOnError)
+                    throw new ArgumentNullException(nameof(this.Files));
+
+                return;
+            }
+            else if (this.Files.Count == 0)
+            {
+                if (throwOnError)
+                    throw new ArgumentException("No files provided to write");
+
+                return;
+            }
 
             using (var sw = new StreamWriter(stream, Encoding.ASCII, 1024, true))
             {

MPF.CueSheets/CueTrack.cs

@@ -156,16 +156,39 @@ namespace MPF.CueSheets
         /// <param name="dataType">Data type to set</param>
         /// <param name="cueLines">Lines array to pull from</param>
         /// <param name="i">Reference to index in array</param>
-        public CueTrack(string number, string dataType, string[] cueLines, ref int i)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public CueTrack(string number, string dataType, string[] cueLines, ref int i, bool throwOnError = false)
         {
-            if (cueLines == null || i < 0 || i > cueLines.Length)
-                return; // TODO: Make this throw an exception
+            if (cueLines == null)
+            {
+                if (throwOnError)
+                    throw new ArgumentNullException(nameof(cueLines));
+
+                return;
+            }
+            else if (i < 0 || i > cueLines.Length)
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException();
+
+                return;
+            }
 
             // Set the current fields
             if (!int.TryParse(number, out int parsedNumber))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new ArgumentException($"Number was not a number: {number}");
+
+                return;
+            }
             else if (parsedNumber < 1 || parsedNumber > 99)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Index must be between 1 and 99: {parsedNumber}");
+
+                return;
+            }
 
             this.Number = parsedNumber;
             this.DataType = GetDataType(dataType);
@@ -192,7 +215,12 @@ namespace MPF.CueSheets
                     // Read flag information
                     case "FLAGS":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"FLAGS line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Flags = GetFlags(splitLine);
                         break;
@@ -200,7 +228,12 @@ namespace MPF.CueSheets
                     // Read International Standard Recording Code
                     case "ISRC":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"ISRC line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.ISRC = splitLine[1];
                         break;
@@ -208,7 +241,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced performer
                     case "PERFORMER":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"PERFORMER line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Performer = splitLine[1];
                         break;
@@ -216,7 +254,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced songwriter
                     case "SONGWRITER":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"SONGWRITER line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Songwriter = splitLine[1];
                         break;
@@ -224,7 +267,12 @@ namespace MPF.CueSheets
                     // Read CD-Text enhanced title
                     case "TITLE":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"TITLE line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Title = splitLine[1];
                         break;
@@ -232,11 +280,21 @@ namespace MPF.CueSheets
                     // Read pregap information
                     case "PREGAP":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"PREGAP line malformed: {line}");
+
+                            continue;
+                        }
 
                         var pregap = new PreGap(splitLine[1]);
                         if (pregap == default)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"PREGAP line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.PreGap = pregap;
                         break;
@@ -244,14 +302,24 @@ namespace MPF.CueSheets
                     // Read index information
                     case "INDEX":
                         if (splitLine.Length < 3)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"INDEX line malformed: {line}");
+
+                            continue;
+                        }
 
                         if (this.Indices == null)
                             this.Indices = new List<CueIndex>();
 
                         var index = new CueIndex(splitLine[1], splitLine[2]);
                         if (index == default)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"INDEX line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.Indices.Add(index);
                         break;
@@ -259,11 +327,21 @@ namespace MPF.CueSheets
                     // Read postgap information
                     case "POSTGAP":
                         if (splitLine.Length < 2)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"POSTGAP line malformed: {line}");
+
+                            continue;
+                        }
 
                         var postgap = new PostGap(splitLine[1]);
                         if (postgap == default)
-                            continue; // TODO: Make this throw an exception
+                        {
+                            if (throwOnError)
+                                throw new FormatException($"POSTGAP line malformed: {line}");
+
+                            continue;
+                        }
 
                         this.PostGap = postgap;
                         break;
@@ -279,12 +357,25 @@ namespace MPF.CueSheets
         /// <summary>
         /// Write the TRACK out to a stream
         /// </summary>
-        /// <param name="sw">StreamWriter to write to</param>
-        public void Write(StreamWriter sw)
+        /// <param name="sw">StreamWriter to write to</param
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public void Write(StreamWriter sw, bool throwOnError = false)
         {
             // If we don't have any indices, it's invalid
-            if (this.Indices == null || this.Indices.Count == 0)
-                return; // TODO: Make this throw an exception
+            if (this.Indices == null)
+            {
+                if (throwOnError)
+                    throw new ArgumentNullException(nameof(this.Indices));
+
+                return;
+            }
+            else if (this.Indices.Count == 0)
+            {
+                if (throwOnError)
+                    throw new ArgumentException("No indices provided to write");
+
+                return;
+            }
 
             sw.WriteLine($"  TRACK {this.Number:D2} {FromDataType(this.DataType)}");
 
@@ -402,7 +493,6 @@ namespace MPF.CueSheets
 
             foreach (string flagString in flagStrings)
             {
-                // TODO: Make default throw an exception
                 switch (flagString.ToLowerInvariant())
                 {
                     case "flags":

MPF.CueSheets/MPF.CueSheets.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2021</Copyright>
+    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+    <Version>2.3</Version>
+    <AssemblyVersion>$(Version)</AssemblyVersion>
+    <FileVersion>$(Version)</FileVersion>
+    <IncludeSource>true</IncludeSource>
+    <IncludeSymbols>true</IncludeSymbols>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
+    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
+    <NrtShowRevision>false</NrtShowRevision>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

MPF.CueSheets/PostGap.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Linq;
 
 /// <remarks>
@@ -38,41 +39,87 @@ namespace MPF.CueSheets
         /// Create a POSTGAP from a mm:ss:ff length
         /// </summary>
         /// <param name="length">String to get length information from</param>
-        public PostGap(string length)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public PostGap(string length, bool throwOnError = false)
         {
             // Ignore empty lines
             if (string.IsNullOrWhiteSpace(length))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new ArgumentException("Length was null or whitespace");
+
+                return;
+            }
 
             // Ignore lines that don't contain the correct information
             if (length.Length != 8 || length.Count(c => c == ':') != 2)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Length was not in a recognized format: {length}");
+
+                return;
+            }
 
             // Split the line
             string[] splitLength = length.Split(':');
             if (splitLength.Length != 3)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Length was not in a recognized format: {length}");
+
+                return;
+            }
 
             // Parse the lengths
             int[] lengthSegments = new int[3];
 
             // Minutes
             if (!int.TryParse(splitLength[0], out lengthSegments[0]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Minutes segment was not a number: {splitLength[0]}");
+
+                return;
+            }
             else if (lengthSegments[0] < 0)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
+
+                return;
+            }
 
             // Seconds
             if (!int.TryParse(splitLength[1], out lengthSegments[1]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Seconds segment was not a number: {splitLength[1]}");
+
+                return;
+            }
             else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
+
+                return;
+            }
 
             // Frames
             if (!int.TryParse(splitLength[2], out lengthSegments[2]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Frames segment was not a number: {splitLength[2]}");
+
+                return;
+            }
             else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
+
+                return;
+            }
 
             // Set the values
             this.Minutes = lengthSegments[0];

MPF.CueSheets/PreGap.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Linq;
 
 /// <remarks>
@@ -39,41 +40,87 @@ namespace MPF.CueSheets
         /// Create a PREGAP from a mm:ss:ff length
         /// </summary>
         /// <param name="length">String to get length information from</param>
-        public PreGap(string length)
+        /// <param name="throwOnError">True if errors throw an exception, false otherwise</param>
+        public PreGap(string length, bool throwOnError = false)
         {
             // Ignore empty lines
             if (string.IsNullOrWhiteSpace(length))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new ArgumentException("Length was null or whitespace");
+
+                return;
+            }
 
             // Ignore lines that don't contain the correct information
             if (length.Length != 8 || length.Count(c => c == ':') != 2)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Length was not in a recognized format: {length}");
+
+                return;
+            }
 
             // Split the line
             string[] splitLength = length.Split(':');
             if (splitLength.Length != 3)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Length was not in a recognized format: {length}");
+
+                return;
+            }
 
             // Parse the lengths
             int[] lengthSegments = new int[3];
 
             // Minutes
             if (!int.TryParse(splitLength[0], out lengthSegments[0]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Minutes segment was not a number: {splitLength[0]}");
+
+                return;
+            }
             else if (lengthSegments[0] < 0)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Minutes segment must be 0 or greater: {lengthSegments[0]}");
+
+                return;
+            }
 
             // Seconds
             if (!int.TryParse(splitLength[1], out lengthSegments[1]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Seconds segment was not a number: {splitLength[1]}");
+
+                return;
+            }
             else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Seconds segment must be between 0 and 60: {lengthSegments[1]}");
+
+                return;
+            }
 
             // Frames
             if (!int.TryParse(splitLength[2], out lengthSegments[2]))
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new FormatException($"Frames segment was not a number: {splitLength[2]}");
+
+                return;
+            }
             else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
-                return; // TODO: Make this throw an exception
+            {
+                if (throwOnError)
+                    throw new IndexOutOfRangeException($"Frames segment must be between 0 and 75: {lengthSegments[2]}");
+
+                return;
+            }
 
             // Set the values
             this.Minutes = lengthSegments[0];

MPF.Library/Aaru/Converters.cs

@@ -1,424 +0,0 @@
-using MPF.Data;
-
-namespace MPF.Aaru
-{
-    public static class Converters
-    {
-        #region Cross-enumeration conversions
-
-        /// <summary>
-        /// Get the default extension for a given disc type
-        /// </summary>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>Valid extension (with leading '.'), null on error</returns>
-        public static string Extension(MediaType? type)
-        {
-            // Aaru has a single, unified output format by default
-            return ".aaruf";
-        }
-
-        #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                // Database Family
-                case Command.DatabaseStats:
-                    return $"{CommandStrings.DatabasePrefixLong} {CommandStrings.DatabaseStats}";
-                case Command.DatabaseUpdate:
-                    return $"{CommandStrings.DatabasePrefixLong} {CommandStrings.DatabaseUpdate}";
-
-                // Device Family
-                case Command.DeviceInfo:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceInfo}";
-                case Command.DeviceList:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceList}";
-                case Command.DeviceReport:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceReport}";
-
-                // Filesystem Family
-                case Command.FilesystemExtract:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemExtract}";
-                case Command.FilesystemList:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemListLong}";
-                case Command.FilesystemOptions:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemOptions}";
-
-                // Image Family
-                case Command.ImageAnalyze:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageAnalyze}";
-                case Command.ImageChecksum:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageChecksumLong}";
-                case Command.ImageCompare:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageCompareLong}";
-                case Command.ImageConvert:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageConvert}";
-                case Command.ImageCreateSidecar:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageCreateSidecar}";
-                case Command.ImageDecode:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageDecode}";
-                case Command.ImageEntropy:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageEntropy}";
-                case Command.ImageInfo:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageInfo}";
-                case Command.ImageOptions:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageOptions}";
-                case Command.ImagePrint:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImagePrint}";
-                case Command.ImageVerify:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageVerify}";
-
-                // Media Family
-                case Command.MediaDump:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaDump}";
-                case Command.MediaInfo:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaInfo}";
-                case Command.MediaScan:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaScan}";
-
-                // Standalone Commands
-                case Command.Configure:
-                    return CommandStrings.Configure;
-                case Command.Formats:
-                    return CommandStrings.Formats;
-                case Command.ListEncodings:
-                    return CommandStrings.ListEncodings;
-                case Command.ListNamespaces:
-                    return CommandStrings.ListNamespaces;
-                case Command.Remote:
-                    return CommandStrings.Remote;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                // Boolean flags
-                case Flag.Adler32:
-                    return FlagStrings.Adler32Long;
-                case Flag.Clear:
-                    return FlagStrings.ClearLong;
-                case Flag.ClearAll:
-                    return FlagStrings.ClearAllLong;
-                case Flag.CRC16:
-                    return FlagStrings.CRC16Long;
-                case Flag.CRC32:
-                    return FlagStrings.CRC32Long;
-                case Flag.CRC64:
-                    return FlagStrings.CRC64Long;
-                case Flag.Debug:
-                    return FlagStrings.DebugLong;
-                case Flag.DiskTags:
-                    return FlagStrings.DiskTagsLong;
-                case Flag.DuplicatedSectors:
-                    return FlagStrings.DuplicatedSectorsLong;
-                case Flag.Eject:
-                    return FlagStrings.EjectLong;
-                case Flag.ExtendedAttributes:
-                    return FlagStrings.ExtendedAttributesLong;
-                case Flag.Filesystems:
-                    return FlagStrings.FilesystemsLong;
-                case Flag.FirstPregap:
-                    return FlagStrings.FirstPregapLong;
-                case Flag.FixOffset:
-                    return FlagStrings.FixOffsetLong;
-                case Flag.FixSubchannel:
-                    return FlagStrings.FixSubchannelLong;
-                case Flag.FixSubchannelCrc:
-                    return FlagStrings.FixSubchannelCrcLong;
-                case Flag.FixSubchannelPosition:
-                    return FlagStrings.FixSubchannelPositionLong;
-                case Flag.Fletcher16:
-                    return FlagStrings.Fletcher16Long;
-                case Flag.Fletcher32:
-                    return FlagStrings.Fletcher32Long;
-                case Flag.Force:
-                    return FlagStrings.ForceLong;
-                case Flag.GenerateSubchannels:
-                    return FlagStrings.GenerateSubchannelsLong;
-                case Flag.Help:
-                    return FlagStrings.HelpLong;
-                case Flag.LongFormat:
-                    return FlagStrings.LongFormatLong;
-                case Flag.LongSectors:
-                    return FlagStrings.LongSectorsLong;
-                case Flag.MD5:
-                    return FlagStrings.MD5Long;
-                case Flag.Metadata:
-                    return FlagStrings.MetadataLong;
-                case Flag.Partitions:
-                    return FlagStrings.PartitionsLong;
-                case Flag.Persistent:
-                    return FlagStrings.PersistentLong;
-                case Flag.Private:
-                    return FlagStrings.PrivateLong;
-                case Flag.Resume:
-                    return FlagStrings.ResumeLong;
-                case Flag.RetrySubchannel:
-                    return FlagStrings.RetrySubchannelLong;
-                case Flag.SectorTags:
-                    return FlagStrings.SectorTagsLong;
-                case Flag.SeparatedTracks:
-                    return FlagStrings.SeparatedTracksLong;
-                case Flag.SHA1:
-                    return FlagStrings.SHA1Long;
-                case Flag.SHA256:
-                    return FlagStrings.SHA256Long;
-                case Flag.SHA384:
-                    return FlagStrings.SHA384Long;
-                case Flag.SHA512:
-                    return FlagStrings.SHA512Long;
-                case Flag.SkipCdiReadyHole:
-                    return FlagStrings.SkipCdiReadyHoleLong;
-                case Flag.SpamSum:
-                    return FlagStrings.SpamSumLong;
-                case Flag.StopOnError:
-                    return FlagStrings.StopOnErrorLong;
-                case Flag.Tape:
-                    return FlagStrings.TapeLong;
-                case Flag.Trim:
-                    return FlagStrings.TrimLong;
-                case Flag.Verbose:
-                    return FlagStrings.VerboseLong;
-                case Flag.VerifyDisc:
-                    return FlagStrings.VerifyDiscLong;
-                case Flag.VerifySectors:
-                    return FlagStrings.VerifySectorsLong;
-                case Flag.Version:
-                    return FlagStrings.VersionLong;
-                case Flag.WholeDisc:
-                    return FlagStrings.WholeDiscLong;
-
-                // Int8 flags
-                case Flag.Speed:
-                    return FlagStrings.SpeedLong;
-
-                // Int16 flags
-                case Flag.RetryPasses:
-                    return FlagStrings.RetryPassesLong;
-                case Flag.Width:
-                    return FlagStrings.WidthLong;
-
-                // Int32 flags
-                case Flag.BlockSize:
-                    return FlagStrings.BlockSizeLong;
-                case Flag.Count:
-                    return FlagStrings.CountLong;
-                case Flag.MediaLastSequence:
-                    return FlagStrings.MediaLastSequenceLong;
-                case Flag.MediaSequence:
-                    return FlagStrings.MediaSequenceLong;
-                case Flag.Skip:
-                    return FlagStrings.SkipLong;
-
-                // Int64 flags
-                case Flag.Length:
-                    return FlagStrings.LengthLong;
-                case Flag.Start:
-                    return FlagStrings.StartLong;
-
-                // String flags
-                case Flag.Comments:
-                    return FlagStrings.CommentsLong;
-                case Flag.Creator:
-                    return FlagStrings.CreatorLong;
-                case Flag.DriveManufacturer:
-                    return FlagStrings.DriveManufacturerLong;
-                case Flag.DriveModel:
-                    return FlagStrings.DriveModelLong;
-                case Flag.DriveRevision:
-                    return FlagStrings.DriveRevisionLong;
-                case Flag.DriveSerial:
-                    return FlagStrings.DriveSerialLong;
-                case Flag.Encoding:
-                    return FlagStrings.EncodingLong;
-                case Flag.FormatConvert:
-                    return FlagStrings.FormatConvertLong;
-                case Flag.FormatDump:
-                    return FlagStrings.FormatDumpLong;
-                case Flag.ImgBurnLog:
-                    return FlagStrings.ImgBurnLogLong;
-                case Flag.MediaBarcode:
-                    return FlagStrings.MediaBarcodeLong;
-                case Flag.MediaManufacturer:
-                    return FlagStrings.MediaManufacturerLong;
-                case Flag.MediaModel:
-                    return FlagStrings.MediaModelLong;
-                case Flag.MediaPartNumber:
-                    return FlagStrings.MediaPartNumberLong;
-                case Flag.MediaSerial:
-                    return FlagStrings.MediaSerialLong;
-                case Flag.MediaTitle:
-                    return FlagStrings.MediaTitleLong;
-                case Flag.MHDDLog:
-                    return FlagStrings.MHDDLogLong;
-                case Flag.Namespace:
-                    return FlagStrings.NamespaceLong;
-                case Flag.Options:
-                    return FlagStrings.OptionsLong;
-                case Flag.OutputPrefix:
-                    return FlagStrings.OutputPrefixLong;
-                case Flag.ResumeFile:
-                    return FlagStrings.ResumeFileLong;
-                case Flag.Subchannel:
-                    return FlagStrings.SubchannelLong;
-                case Flag.XMLSidecar:
-                    return FlagStrings.XMLSidecarLong;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="commandOne">First part of String value to convert</param>
-        /// <param name="commandTwo">Second part of String value to convert</param>
-        /// <param name="useSecond">Output bool if the second command was used</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string commandOne, string commandTwo, out bool useSecond)
-        {
-            useSecond = false;
-            switch (commandOne)
-            {
-                // Database Family
-                case CommandStrings.DatabasePrefixShort:
-                case CommandStrings.DatabasePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.DatabaseStats:
-                            return Command.DatabaseStats;
-                        case CommandStrings.DatabaseUpdate:
-                            return Command.DatabaseUpdate;
-                    }
-
-                    break;
-
-                // Device Family
-                case CommandStrings.DevicePrefixShort:
-                case CommandStrings.DevicePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.DeviceInfo:
-                            return Command.DeviceInfo;
-                        case CommandStrings.DeviceList:
-                            return Command.DeviceList;
-                        case CommandStrings.DeviceReport:
-                            return Command.DeviceReport;
-                    }
-
-                    break;
-
-                // Filesystem Family
-                case CommandStrings.FilesystemPrefixShort:
-                case CommandStrings.FilesystemPrefixShortAlt:
-                case CommandStrings.FilesystemPrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.FilesystemExtract:
-                            return Command.FilesystemExtract;
-                        case CommandStrings.FilesystemListShort:
-                        case CommandStrings.FilesystemListLong:
-                            return Command.FilesystemList;
-                        case CommandStrings.DatabaseStats:
-                            return Command.FilesystemOptions;
-                    }
-
-                    break;
-
-                // Image Family
-                case CommandStrings.ImagePrefixShort:
-                case CommandStrings.ImagePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.ImageAnalyze:
-                            return Command.ImageAnalyze;
-                        case CommandStrings.ImageChecksumShort:
-                        case CommandStrings.ImageChecksumLong:
-                            return Command.ImageChecksum;
-                        case CommandStrings.ImageCompareShort:
-                        case CommandStrings.ImageCompareLong:
-                            return Command.ImageCompare;
-                        case CommandStrings.ImageConvert:
-                            return Command.ImageConvert;
-                        case CommandStrings.ImageCreateSidecar:
-                            return Command.ImageCreateSidecar;
-                        case CommandStrings.ImageDecode:
-                            return Command.ImageDecode;
-                        case CommandStrings.ImageEntropy:
-                            return Command.ImageEntropy;
-                        case CommandStrings.ImageInfo:
-                            return Command.ImageInfo;
-                        case CommandStrings.ImageOptions:
-                            return Command.ImageOptions;
-                        case CommandStrings.ImagePrint:
-                            return Command.ImagePrint;
-                        case CommandStrings.ImageVerify:
-                            return Command.ImageVerify;
-                    }
-
-                    break;
-
-                // Media Family
-                case CommandStrings.MediaPrefixShort:
-                case CommandStrings.MediaPrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.MediaDump:
-                            return Command.MediaDump;
-                        case CommandStrings.MediaInfo:
-                            return Command.MediaInfo;
-                        case CommandStrings.MediaScan:
-                            return Command.MediaScan;
-                    }
-
-                    break;
-
-                // Standalone Commands
-                case CommandStrings.Configure:
-                    return Command.Configure;
-                case CommandStrings.Formats:
-                    return Command.Formats;
-                case CommandStrings.ListEncodings:
-                    return Command.ListEncodings;
-                case CommandStrings.ListNamespaces:
-                    return Command.ListNamespaces;
-                case CommandStrings.Remote:
-                    return Command.Remote;
-            }
-
-            return Command.NONE;
-        }
-
-        #endregion
-    }
-}

MPF.Library/Aaru/Enumerations.cs

@@ -1,149 +0,0 @@
-namespace MPF.Aaru
-{
-    /// <summary>
-    /// Supported Aaru commands
-    /// </summary>
-    public enum Command : int
-    {
-        NONE = 0,
-
-        // Database Family
-        DatabaseStats,
-        DatabaseUpdate,
-
-        // Device Family
-        DeviceInfo,
-        DeviceList,
-        DeviceReport,
-
-        // Filesystem Family
-        FilesystemExtract,
-        FilesystemList,
-        FilesystemOptions,
-
-        // Image Family
-        ImageAnalyze,
-        ImageChecksum,
-        ImageCompare,
-        ImageConvert,
-        ImageCreateSidecar,
-        ImageDecode,
-        ImageEntropy,
-        ImageInfo,
-        ImageOptions,
-        ImagePrint,
-        ImageVerify,
-
-        // Media Family
-        MediaDump,
-        MediaInfo,
-        MediaScan,
-
-        // Standalone Commands
-        Configure,
-        Formats,
-        ListEncodings,
-        ListNamespaces,
-        Remote,
-    }
-
-    /// <summary>
-    /// Supported Aaru flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-
-        // Boolean flags
-        Adler32,
-        Clear,
-        ClearAll,
-        CRC16,
-        CRC32,
-        CRC64,
-        Debug,
-        DiskTags,
-        DuplicatedSectors,
-        Eject,
-        ExtendedAttributes,
-        Filesystems,
-        FirstPregap,
-        FixOffset,
-        FixSubchannel,
-        FixSubchannelCrc,
-        FixSubchannelPosition,
-        Fletcher16,
-        Fletcher32,
-        Force,
-        GenerateSubchannels,
-        Help,
-        LongFormat,
-        LongSectors,
-        MD5,
-        Metadata,
-        Partitions,
-        Persistent,
-        Private,
-        Resume,
-        RetrySubchannel,
-        SectorTags,
-        SeparatedTracks,
-        SHA1,
-        SHA256,
-        SHA384,
-        SHA512,
-        SkipCdiReadyHole,
-        SpamSum,
-        StopOnError,
-        Tape,
-        Trim,
-        Verbose,
-        VerifyDisc,
-        VerifySectors,
-        Version,
-        WholeDisc,
-
-        // Int8 flags
-        Speed,
-
-        // Int16 flags
-        RetryPasses,
-        Width,
-
-        // Int32 flags
-        BlockSize,
-        Count,
-        MediaLastSequence,
-        MediaSequence,
-        Skip,
-
-        // Int64 flags
-        Length,
-        Start,
-
-        // String flags
-        Comments,
-        Creator,
-        DriveManufacturer,
-        DriveModel,
-        DriveRevision,
-        DriveSerial,
-        Encoding,
-        FormatConvert,
-        FormatDump,
-        ImgBurnLog,
-        MediaBarcode,
-        MediaManufacturer,
-        MediaModel,
-        MediaPartNumber,
-        MediaSerial,
-        MediaTitle,
-        MHDDLog,
-        Namespace,
-        Options,
-        OutputPrefix,
-        ResumeFile,
-        Subchannel,
-        XMLSidecar,
-    }
-}

MPF.Library/DD/Converters.cs

@@ -1,104 +0,0 @@
-using MPF.Data;
-
-namespace MPF.DD
-{
-    public static class Converters
-    {
-        #region Cross-enumeration conversions
-
-        /// <summary>
-        /// Get the default extension for a given disc type
-        /// </summary>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>Valid extension (with leading '.'), null on error</returns>
-        public static string Extension(MediaType? type)
-        {
-            // DD has a single, unified output format by default
-            return ".bin";
-        }
-
-        #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                case Command.List:
-                    return CommandStrings.List;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                // Boolean flags
-                case Flag.Progress:
-                    return FlagStrings.Progress;
-                case Flag.Size:
-                    return FlagStrings.Size;
-
-                // Int64 flags
-                case Flag.BlockSize:
-                    return FlagStrings.BlockSize;
-                case Flag.Count:
-                    return FlagStrings.Count;
-                case Flag.Seek:
-                    return FlagStrings.Seek;
-                case Flag.Skip:
-                    return FlagStrings.Skip;
-
-                // String flags
-                case Flag.Filter:
-                    return FlagStrings.Filter;
-                case Flag.InputFile:
-                    return FlagStrings.InputFile;
-                case Flag.OutputFile:
-                    return FlagStrings.OutputFile;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="command">String value to convert</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string command)
-        {
-            switch (command)
-            {
-                case CommandStrings.List:
-                    return Command.List;
-
-                default:
-                    return Command.NONE;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Library/DD/Enumerations.cs

@@ -1,34 +0,0 @@
-namespace MPF.DD
-{
-    /// <summary>
-    /// Supported DD commands
-    /// </summary>
-    public enum Command: int
-    {
-        NONE = 0, // For DD, this represents a normal dump
-        List,
-    }
-
-    /// <summary>
-    /// Supported DD flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-
-        // Boolean flags
-        Progress,
-        Size,
-
-        // Int64 flags
-        BlockSize,
-        Count,
-        Seek,
-        Skip,
-
-        // String flags
-        Filter,
-        InputFile,
-        OutputFile,
-    }
-}

MPF.Library/DD/Parameters.cs

@@ -1,617 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using MPF.Data;
-using MPF.Utilities;
-
-namespace MPF.DD
-{
-    /// <summary>
-    /// Represents a generic set of DD parameters
-    /// </summary>
-    public class Parameters : BaseParameters
-    {
-        #region Generic Dumping Information
-
-        /// <inheritdoc/>
-        public override string InputPath => InputFileValue;
-
-        /// <inheritdoc/>
-        public override string OutputPath => OutputFileValue;
-
-        /// <inheritdoc/>
-        /// <inheritdoc/>
-        public override int? Speed
-        {
-            get { return 1; }
-            set { }
-        }
-
-        #endregion
-
-        #region Metadata
-
-        /// <summary>
-        /// Base command to run
-        /// </summary>
-        public Command BaseCommand { get; set; }
-
-        /// <inheritdoc/>
-        public override InternalProgram InternalProgram => InternalProgram.DD;
-
-        #endregion
-
-        /// <summary>
-        /// Set of flags to pass to the executable
-        /// </summary>
-        protected Dictionary<Flag, bool?> _flags = new Dictionary<Flag, bool?>();
-        public bool? this[Flag key]
-        {
-            get
-            {
-                if (_flags.ContainsKey(key))
-                    return _flags[key];
-
-                return null;
-            }
-            set
-            {
-                _flags[key] = value;
-            }
-        }
-        protected internal IEnumerable<Flag> Keys => _flags.Keys;
-
-        #region Flag Values
-
-        public long? BlockSizeValue { get; set; }
-
-        public long? CountValue { get; set; }
-
-        // fixed, removable, disk, partition
-        public string FilterValue { get; set; }
-
-        public string InputFileValue { get; set; }
-
-        public string OutputFileValue { get; set; }
-
-        public long? SeekValue { get; set; }
-
-        public long? SkipValue { get; set; }
-
-        #endregion
-
-        /// <inheritdoc/>
-        public Parameters(string parameters) : base(parameters) { }
-
-        /// <inheritdoc/>
-        public Parameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
-            : base(system, type, driveLetter, filename, driveSpeed, options)
-        {
-        }
-
-        #region BaseParameters Implementations
-
-        /// <inheritdoc/>
-        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath)
-        {
-            // TODO: Figure out what sort of output files are expected... just `.bin`?
-            return (true, new List<string>());
-        }
-
-        /// <inheritdoc/>
-        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, Drive drive, bool includeArtifacts)
-        {
-            // TODO: Fill in submission info specifics for DD
-            string outputDirectory = Path.GetDirectoryName(basePath);
-
-            switch (this.Type)
-            {
-                // Determine type-specific differences
-            }
-
-            switch (this.System)
-            {
-                case KnownSystem.KonamiPython2:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string pythonTwoSerial, out RedumpRegion? pythonTwoRegion, out string pythonTwoDate))
-                    {
-                        info.CommonDiscInfo.Comments += $"Internal Disc Serial: {pythonTwoSerial}\n";
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? pythonTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = pythonTwoDate;
-                    }
-
-                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
-                    break;
-
-                case KnownSystem.SonyPlayStation:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationSerial, out RedumpRegion? playstationRegion, out string playstationDate))
-                    {
-                        info.CommonDiscInfo.Comments += $"Internal Disc Serial: {playstationSerial}\n";
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = playstationDate;
-                    }
-
-                    info.CopyProtection.AntiModchip = GetPlayStationAntiModchipDetected(drive?.Letter) ? YesNo.Yes : YesNo.No;
-                    break;
-
-                case KnownSystem.SonyPlayStation2:
-                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationTwoSerial, out RedumpRegion? playstationTwoRegion, out string playstationTwoDate))
-                    {
-                        info.CommonDiscInfo.Comments += $"Internal Disc Serial: {playstationTwoSerial}\n";
-                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationTwoRegion;
-                        info.CommonDiscInfo.EXEDateBuildDate = playstationTwoDate;
-                    }
-
-                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
-                    break;
-
-                case KnownSystem.SonyPlayStation4:
-                    info.VersionAndEditions.Version = GetPlayStation4Version(drive?.Letter) ?? "";
-                    break;
-
-                case KnownSystem.SonyPlayStation5:
-                    info.VersionAndEditions.Version = GetPlayStation5Version(drive?.Letter) ?? "";
-                    break;
-            }
-        }
-
-        /// <inheritdoc/>
-        public override string GenerateParameters()
-        {
-            List<string> parameters = new List<string>();
-
-            if (BaseCommand != Command.NONE)
-                parameters.Add(Converters.LongName(BaseCommand));
-
-            #region Boolean flags
-
-            // Progress
-            if (GetSupportedCommands(Flag.Progress).Contains(BaseCommand))
-            {
-                if (this[Flag.Progress] == true)
-                    parameters.Add($"{this[Flag.Progress]}");
-            }
-
-            // Size
-            if (GetSupportedCommands(Flag.Size).Contains(BaseCommand))
-            {
-                if (this[Flag.Size] == true)
-                    parameters.Add($"{this[Flag.Size]}");
-            }
-
-            #endregion
-
-            #region Int64 flags
-
-            // Block Size
-            if (GetSupportedCommands(Flag.BlockSize).Contains(BaseCommand))
-            {
-                if (this[Flag.BlockSize] == true && BlockSizeValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.BlockSize)}={BlockSizeValue}");
-            }
-
-            // Count
-            if (GetSupportedCommands(Flag.Count).Contains(BaseCommand))
-            {
-                if (this[Flag.Count] == true && CountValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Count)}={CountValue}");
-            }
-
-            // Seek
-            if (GetSupportedCommands(Flag.Seek).Contains(BaseCommand))
-            {
-                if (this[Flag.Seek] == true && SeekValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Seek)}={SeekValue}");
-            }
-
-            // Skip
-            if (GetSupportedCommands(Flag.Skip).Contains(BaseCommand))
-            {
-                if (this[Flag.Skip] == true && SkipValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Skip)}={SkipValue}");
-            }
-
-            #endregion
-
-            #region String flags
-
-            // Filter
-            if (GetSupportedCommands(Flag.Filter).Contains(BaseCommand))
-            {
-                if (this[Flag.Filter] == true && FilterValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Filter)}={FilterValue}");
-            }
-
-            // Input File
-            if (GetSupportedCommands(Flag.InputFile).Contains(BaseCommand))
-            {
-                if (this[Flag.InputFile] == true && InputFileValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.InputFile)}={InputFileValue}");
-                else
-                    return null;
-            }
-
-            // Output File
-            if (GetSupportedCommands(Flag.OutputFile).Contains(BaseCommand))
-            {
-                if (this[Flag.OutputFile] == true && OutputFileValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.OutputFile)}={OutputFileValue}");
-                else
-                    return null;
-            }
-
-            #endregion
-
-            return string.Empty;
-        }
-
-        /// <inheritdoc/>
-        public override string GetDefaultExtension(MediaType? mediaType) => Converters.Extension(mediaType);
-
-        /// <inheritdoc/>
-        public override bool IsDumpingCommand()
-        {
-            switch (this.BaseCommand)
-            {
-                case Command.List:
-                    return false;
-                default:
-                    return true;
-            }
-        }
-
-        /// <inheritdoc/>
-        protected override void ResetValues()
-        {
-            BaseCommand = Command.NONE;
-
-            _flags = new Dictionary<Flag, bool?>();
-
-            BlockSizeValue = null;
-            CountValue = null;
-            InputFileValue = null;
-            OutputFileValue = null;
-            SeekValue = null;
-            SkipValue = null;
-        }
-
-        /// <inheritdoc/>
-        protected override void SetDefaultParameters(char driveLetter, string filename, int? driveSpeed, Options options)
-        {
-            BaseCommand = Command.NONE;
-
-            this[Flag.InputFile] = true;
-            InputFileValue = $"\\\\?\\{driveLetter}:";
-
-            this[Flag.OutputFile] = true;
-            OutputFileValue = filename;
-
-            // TODO: Add more common block sizes
-            this[Flag.BlockSize] = true;
-            switch (this.Type)
-            {
-                case MediaType.FloppyDisk:
-                    BlockSizeValue = 1440 * 1024;
-                    break;
-
-                default:
-                    BlockSizeValue = 1024 * 1024 * 1024;
-                    break;
-            }
-
-            this[Flag.Progress] = true;
-            this[Flag.Size] = true;
-        }
-
-        /// <inheritdoc/>
-        protected override bool ValidateAndSetParameters(string parameters)
-        {
-            // The string has to be valid by itself first
-            if (string.IsNullOrWhiteSpace(parameters))
-                return false;
-
-            // Now split the string into parts for easier validation
-            // https://stackoverflow.com/questions/14655023/split-a-string-that-has-white-spaces-unless-they-are-enclosed-within-quotes
-            parameters = parameters.Trim();
-            List<string> parts = Regex.Matches(parameters, @"[\""].+?[\""]|[^ ]+")
-                .Cast<Match>()
-                .Select(m => m.Value)
-                .ToList();
-
-            // Determine what the commandline should look like given the first item
-            int start = 0;
-            BaseCommand = Converters.StringToCommand(parts[0]);
-            if (BaseCommand != Command.NONE)
-                start = 1;
-
-            // Loop through all auxilary flags, if necessary
-            int i = 0;
-            for (i = start; i < parts.Count; i++)
-            {
-                // Flag read-out values
-                long? longValue = null;
-                string stringValue = null;
-
-                // Keep a count of keys to determine if we should break out to filename handling or not
-                int keyCount = Keys.Count();
-
-                #region Boolean flags
-
-                // Progress
-                ProcessBooleanParameter(parts, FlagStrings.Progress, Flag.Progress, ref i);
-
-                // Size
-                ProcessBooleanParameter(parts, FlagStrings.Size, Flag.Size, ref i);
-
-                #endregion
-
-                #region Int64 flags
-
-                // Block Size
-                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, Flag.BlockSize, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
-                    BlockSizeValue = longValue;
-
-                // Count
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, Flag.Count, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
-                    CountValue = longValue;
-
-                // Seek
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, Flag.Seek, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
-                    SeekValue = longValue;
-
-                // Skip
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, Flag.Skip, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
-                    SkipValue = longValue;
-
-                #endregion
-
-                #region String flags
-
-                // Filter (fixed, removable, disk, partition)
-                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, Flag.Filter, ref i);
-                if (!string.IsNullOrEmpty(stringValue))
-                    FilterValue = stringValue;
-
-                // Input File
-                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, Flag.InputFile, ref i);
-                if (string.Equals(stringValue, string.Empty))
-                    return false;
-                else if (stringValue != null)
-                    InputFileValue = stringValue;
-
-                // Output File
-                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, Flag.OutputFile, ref i);
-                if (string.Equals(stringValue, string.Empty))
-                    return false;
-                else if (stringValue != null)
-                    OutputFileValue = stringValue;
-
-                #endregion
-            }
-
-            return true;
-        }
-
-        #endregion
-
-        #region Private Extra Methods
-
-        /// <summary>
-        /// Get the list of commands that use a given flag
-        /// </summary>
-        /// <param name="flag">Flag value to get commands for</param>
-        /// <returns>List of Commands, if possible</returns>
-        private static List<Command> GetSupportedCommands(Flag flag)
-        {
-            var commands = new List<Command>();
-            switch (flag)
-            {
-                #region Boolean flags
-
-                case Flag.Progress:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Size:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                #region Int64 flags
-
-                case Flag.BlockSize:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Count:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Seek:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Skip:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                #region String flags
-
-                case Flag.Filter:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.InputFile:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.OutputFile:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                case Flag.NONE:
-                default:
-                    return commands;
-            }
-
-            return commands;
-        }
-
-        #endregion
-
-        #region Process Parameter Helpers
-
-        /// <summary>
-        /// Process a boolean parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        private bool ProcessBooleanParameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return false;
-
-            if (parts[i] == flagString)
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return false;
-
-                this[flag] = true;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Process an Int64 parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
-        private long? ProcessInt64Parameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return null;
-
-            if (parts[i].StartsWith(flagString))
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return null;
-
-                string[] commandParts = parts[i].Split('=');
-                if (commandParts.Length != 2)
-                    return null;
-
-                string valuePart = commandParts[1];
-                long factor = 1;
-
-                // Characters
-                if (valuePart.EndsWith("c", StringComparison.Ordinal))
-                {
-                    factor = 1;
-                    valuePart.TrimEnd('c');
-                }
-
-                // Words
-                else if (valuePart.EndsWith("w", StringComparison.Ordinal))
-                {
-                    factor = 2;
-                    valuePart.TrimEnd('w');
-                }
-
-                // Double Words
-                else if (valuePart.EndsWith("d", StringComparison.Ordinal))
-                {
-                    factor = 4;
-                    valuePart.TrimEnd('d');
-                }
-
-                // Quad Words
-                else if (valuePart.EndsWith("q", StringComparison.Ordinal))
-                {
-                    factor = 8;
-                    valuePart.TrimEnd('q');
-                }
-
-                // Kilobytes
-                else if (valuePart.EndsWith("k", StringComparison.Ordinal))
-                {
-                    factor = 1024;
-                    valuePart.TrimEnd('k');
-                }
-
-                // Megabytes
-                else if (valuePart.EndsWith("M", StringComparison.Ordinal))
-                {
-                    factor = 1024 * 1024;
-                    valuePart.TrimEnd('M');
-                }
-
-                // Gigabytes
-                else if (valuePart.EndsWith("G", StringComparison.Ordinal))
-                {
-                    factor = 1024 * 1024 * 1024;
-                    valuePart.TrimEnd('G');
-                }
-
-                if (!IsValidInt64(valuePart))
-                    return null;
-
-                this[flag] = true;
-                return long.Parse(valuePart) * factor;
-            }
-
-            return Int64.MinValue;
-        }
-
-        /// <summary>
-        /// Process a string parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>String value if possible, string.Empty on missing, null on error</returns>
-        private string ProcessStringParameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return null;
-
-            if (parts[i] == flagString)
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return null;
-
-                string[] commandParts = parts[i].Split('=');
-                if (commandParts.Length != 2)
-                    return null;
-
-                string valuePart = commandParts[1];
-
-                this[flag] = true;
-                return valuePart.Trim('"');
-            }
-
-            return string.Empty;
-        }
-
-        #endregion
-    }
-}

MPF.Library/Data/Drive.cs

@@ -1,106 +0,0 @@
-using System.IO;
-
-namespace MPF.Data
-{
-    /// <summary>
-    /// Represents information for a single drive
-    /// </summary>
-    public class Drive
-    {
-        /// <summary>
-        /// Represents drive type
-        /// </summary>
-        public InternalDriveType? InternalDriveType { get; set; }
-
-        /// <summary>
-        /// Drive partition format
-        /// </summary>
-        public string DriveFormat { get { return driveInfo.DriveFormat; } }
-
-        /// <summary>
-        /// Windows drive letter
-        /// </summary>
-        public char Letter { get { return driveInfo?.Name[0] ?? '\0'; } }
-
-        /// <summary>
-        /// Represents if Windows has marked the drive as active
-        /// </summary>
-        public bool MarkedActive { get { return driveInfo.IsReady; } }
-
-        /// <summary>
-        /// Media label as read by Windows
-        /// </summary>
-        public string VolumeLabel
-        {
-            get
-            {
-                string volumeLabel = Template.DiscNotDetected;
-                if (driveInfo.IsReady)
-                {
-                    if (string.IsNullOrWhiteSpace(driveInfo.VolumeLabel))
-                        volumeLabel = "track";
-                    else
-                        volumeLabel = driveInfo.VolumeLabel;
-                }
-
-                foreach (char c in Path.GetInvalidFileNameChars())
-                    volumeLabel = volumeLabel.Replace(c, '_');
-
-                return volumeLabel;
-            }
-        }
-
-        /// <summary>
-        /// DriveInfo object representing the drive, if possible
-        /// </summary>
-        private readonly DriveInfo driveInfo;
-
-        public Drive(InternalDriveType? driveType, DriveInfo driveInfo)
-        {
-            this.InternalDriveType = driveType;
-            this.driveInfo = driveInfo;
-        }
-
-        /// <summary>
-        /// Read a sector with a specified size from the drive
-        /// </summary>
-        /// <param name="num">Sector number, non-negative</param>
-        /// <param name="size">Size of a sector in bytes</param>
-        /// <returns>Byte array representing the sector, null on error</returns>
-        public byte[] ReadSector(long num, int size = 2048)
-        {
-            // Missing drive leter is not supported
-            if (string.IsNullOrEmpty(this.driveInfo?.Name))
-                return null;
-
-            // We don't support negative sectors
-            if (num < 0)
-                return null;
-
-            // Wrap the following in case of device access errors
-            Stream fs = null;
-            try
-            {
-                // Open the drive as a device
-                fs = File.OpenRead($"\\\\?\\{this.Letter}:");
-
-                // Seek to the start of the sector, if possible
-                long start = num * size;
-                fs.Seek(start, SeekOrigin.Begin);
-
-                // Read and return the sector
-                byte[] buffer = new byte[size];
-                fs.Read(buffer, 0, size);
-                return buffer;
-            }
-            catch
-            {
-                return null;
-            }
-            finally
-            {
-                fs?.Dispose();
-            }
-        }
-    }
-}

MPF.Library/Data/Enumerations.cs

@@ -1,777 +0,0 @@
-using System;
-
-namespace MPF.Data
-{
-    /// <summary>
-    /// Available hashing types
-    /// </summary>
-    [Flags]
-    public enum Hash
-    {
-        CRC = 1 << 0,
-        MD5 = 1 << 1,
-        SHA1 = 1 << 2,
-        SHA256 = 1 << 3,
-        SHA384 = 1 << 4,
-        SHA512 = 1 << 5,
-
-        // Special combinations
-        Standard = CRC | MD5 | SHA1,
-        All = CRC | MD5 | SHA1 | SHA256 | SHA384 | SHA512,
-    }
-
-    /// <summary>
-    /// Drive type for dumping
-    /// </summary>
-    public enum InternalDriveType
-    {
-        Optical,
-        Floppy,
-        HardDisk,
-        Removable,
-    }
-
-    /// <summary>
-    /// Program that is being used to dump media
-    /// </summary>
-    public enum InternalProgram
-    {
-        NONE = 0,
-
-        // Dumping support
-        Aaru,
-        DD,
-        DiscImageCreator,
-
-        // Verification support only
-        CleanRip,
-        DCDumper,
-        UmdImageCreator,
-    }
-
-    /// <summary>
-    /// Known systems
-    /// </summary>
-    public enum KnownSystem
-    {
-        NONE = 0,
-
-        #region Disc-Based Consoles
-
-        AtariJaguarCD,
-        BandaiPlaydiaQuickInteractiveSystem,
-        BandaiApplePippin,
-        CommodoreAmigaCD32,
-        CommodoreAmigaCDTV,
-        EnvizionsEVOSmartConsole,
-        FujitsuFMTownsMarty,
-        HasbroVideoNow,
-        HasbroVideoNowColor,
-        HasbroVideoNowJr,
-        HasbroVideoNowXP,
-        MattelFisherPriceiXL,
-        MattelHyperscan,
-        MicrosoftXBOX,
-        MicrosoftXBOX360,
-        MicrosoftXBOXOne,
-        MicrosoftXboxSeriesXS,
-        NECPCEngineTurboGrafxCD,
-        NECPCFX,
-        NintendoGameCube,
-        NintendoSonySuperNESCDROMSystem,
-        NintendoWii,
-        NintendoWiiU,
-        Panasonic3DOInteractiveMultiplayer, // The 3DO Company 3DO Interactive Multiplayer
-        PhilipsCDi,
-        PioneerLaserActive,
-        SegaCDMegaCD,
-        SegaDreamcast,
-        SegaSaturn,
-        SNKNeoGeoCD,
-        SonyPlayStation,
-        SonyPlayStation2,
-        SonyPlayStation3,
-        SonyPlayStation4,
-        SonyPlayStation5,
-        SonyPlayStationPortable,
-        TandyMemorexVisualInformationSystem,
-        VMLabsNuon,
-        VTechVFlashVSmilePro,
-        ZAPiTGamesGameWaveFamilyEntertainmentSystem,
-
-        MarkerDiscBasedConsoleEnd,
-
-        #endregion
-
-        #region Cartridge-Based and Other Consoles
-
-        /*
-        AmstradGX4000,
-        APFMicrocomputerSystem,
-        Atari2600VCS,
-        Atari5200,
-        Atari7800,
-        AtariJaguar,
-        AtariXEVideoGameSystem,
-        Audiosonic1292AdvancedProgrammableVideoSystem,
-        BallyAstrocade,
-        BitCorporationDina,
-        CasioLoopy,
-        CasioPV1000,
-        Commodore64GamesSystem,
-        DaewooElectronicsZemmix,
-        EmersonArcadia2001,
-        EpochCassetteVision,
-        EpochSuperCassetteVision,
-        FairchildChannelF,
-        FuntechSuperACan,
-        GeneralConsumerElectricVectrex,
-        HeberBBCBridgeCompanion,
-        IntertonVC4000,
-        JungleTacVii,
-        LeapFrogClickStart,
-        LJNVideoArt,
-        MagnavoxOdyssey2,
-        MattelIntellivision,
-        NECPCEngineTurboGrafx16,
-        NichibutsuMyVision,
-        Nintendo64,
-        Nintendo64DD,
-        NintendoFamilyComputerNintendoEntertainmentSystem,
-        NintendoFamilyComputerDiskSystem,
-        NintendoSuperFamicomSuperNintendoEntertainmentSystem,
-        NintendoSwitch,
-        PhilipsVideopacPlusG7400,
-        RCAStudioII,
-        Sega32X,
-        SegaMarkIIIMasterSystem,
-        SegaMegaDriveGenesis,
-        SegaSG1000,
-        SNKNeoGeo,
-        SSDCOMPANYLIMITEDXaviXPORT,
-        ViewMasterInteractiveVision,
-        VTechCreatiVision,
-        VTechVSmile,
-        VTechSocrates,
-        WorldsOfWonderActionMax,
-
-        MarkerOtherConsoleEnd,
-        */
-
-        #endregion
-
-        #region Computers
-
-        AcornArchimedes,
-        AppleMacintosh,
-        CommodoreAmiga,
-        FujitsuFMTowns,
-        IBMPCCompatible,
-        NECPC88,
-        NECPC98,
-        SharpX68000,
-
-        MarkerComputerEnd,
-
-        #endregion
-
-        #region Arcade
-
-        AmigaCUBOCD32,
-        AmericanLaserGames3DO,
-        Atari3DO,
-        Atronic,
-        AUSCOMSystem1,
-        BallyGameMagic,
-        CapcomCPSystemIII,
-        funworldPhotoPlay,
-        GlobalVRVarious,
-        GlobalVRVortek,
-        GlobalVRVortekV3,
-        ICEPCHardware,
-        IncredibleTechnologiesEagle,
-        IncredibleTechnologiesVarious,
-        KonamieAmusement,
-        KonamiFirebeat,
-        KonamiGVSystem,
-        KonamiM2,
-        KonamiPython,
-        KonamiPython2,
-        KonamiSystem573,
-        KonamiTwinkle,
-        KonamiVarious,
-        MeritIndustriesBoardwalk,
-        MeritIndustriesMegaTouchForce,
-        MeritIndustriesMegaTouchION,
-        MeritIndustriesMegaTouchMaxx,
-        MeritIndustriesMegaTouchXL,
-        NamcoCapcomSystem256,
-        NamcoCapcomTaitoSystem246,
-        NamcoSegaNintendoTriforce,
-        NamcoSystem12,
-        NamcoSystem357,
-        NewJatreCDi,
-        NichibutsuHighRateSystem,
-        NichibutsuSuperCD,
-        NichibutsuXRateSystem,
-        PanasonicM2,
-        PhotoPlayVarious,
-        RawThrillsVarious,
-        SegaChihiro,
-        SegaEuropaR,
-        SegaLindbergh,
-        SegaNaomi,
-        SegaNaomi2,
-        SegaNu,
-        SegaRingEdge,
-        SegaRingEdge2,
-        SegaRingWide,
-        SegaTitanVideo,
-        SegaSystem32,
-        SeibuCATSSystem,
-        TABAustriaQuizard,
-        TsunamiTsuMoMultiGameMotionSystem,
-
-        MarkerArcadeEnd,
-
-        #endregion
-
-        #region Other
-
-        AudioCD,
-        BDVideo,
-        DVDAudio,
-        DVDVideo,
-        EnhancedCD,
-        HDDVDVideo,
-        NavisoftNaviken21,
-        PalmOS,
-        PhotoCD,
-        PlayStationGameSharkUpdates,
-        RainbowDisc,
-        SegaPrologue21,
-        SuperAudioCD,
-        TaoiKTV,
-        TomyKissSite,
-        VideoCD,
-
-        MarkerOtherEnd,
-
-        #endregion
-    }
-
-    /// <summary>
-    /// Known system category
-    /// </summary>
-    public enum KnownSystemCategory
-    {
-        DiscBasedConsole = 0,
-        OtherConsole,
-        Computer,
-        Arcade,
-        Other,
-        Custom
-    };
-
-    /// <summary>
-    /// Known media types
-    /// </summary>
-    public enum MediaType
-    {
-        NONE = 0,
-
-        #region Punched Media
-
-        ApertureCard,
-        JacquardLoomCard,
-        MagneticStripeCard,
-        OpticalPhonecard,
-        PunchedCard,
-        PunchedTape,
-
-        #endregion
-
-        #region Tape
-
-        Cassette,
-        DataCartridge,
-        OpenReel,
-
-        #endregion
-
-        #region Disc / Disc
-
-        BluRay,
-        CDROM,
-        DVD,
-        FloppyDisk,
-        Floptical,
-        GDROM,
-        HDDVD,
-        HardDisk,
-        IomegaBernoulliDisk,
-        IomegaJaz,
-        IomegaZip,
-        LaserDisc, // LD-ROM and LV-ROM variants
-        Nintendo64DD,
-        NintendoFamicomDiskSystem,
-        NintendoGameCubeGameDisc,
-        NintendoWiiOpticalDisc,
-        NintendoWiiUOpticalDisc,
-        UMD,
-
-        #endregion
-
-        // Unsorted Formats
-        Cartridge,
-        CED,
-        CompactFlash,
-        MMC,
-        SDCard,
-        FlashDrive,
-    }
-
-    /// <summary>
-    /// Physical media types
-    /// </summary>
-    /// <see cref="https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cimwin32a/win32-physicalmedia"/>
-    public enum PhysicalMediaType : ushort
-    {
-        Unknown = 0,
-        Other = 1,
-        TapeCartridge = 2,
-        QICCartridge = 3,
-        AITCartridge = 4,
-        DTFCartridge = 5,
-        DATCartridge = 6,
-        EightMillimeterTapeCartridge = 7,
-        NineteenMillimeterTapeCartridge = 8,
-        DLTCartridge = 9,
-        HalfInchMagneticTapeCartridge = 10,
-        CartridgeDisk = 11,
-        JAZDisk = 12,
-        ZIPDisk = 13,
-        SyQuestDisk = 14,
-        WinchesterRemovableDisk = 15,
-        CDROM = 16,
-        CDROMXA = 17,
-        CDI = 18,
-        CDRecordable = 19,
-        WORM = 20,
-        MagnetoOptical = 21,
-        DVD = 22,
-        DVDPlusRW = 23,
-        DVDRAM = 24,
-        DVDROM = 25,
-        DVDVideo = 26,
-        Divx = 27,
-        FloppyDiskette = 28,
-        HardDisk = 29,
-        MemoryCard = 30,
-        HardCopy = 31,
-        ClikDisk = 32,
-        CDRW = 33,
-        CDDA = 34,
-        CDPlus = 35,
-        DVDRecordable = 36,
-        DVDMinusRW = 37,
-        DVDAudio = 38,
-        DVD5 = 39,
-        DVD9 = 40,
-        DVD10 = 41,
-        DVD18 = 42,
-        MagnetoOpticalRewriteable = 43,
-        MagnetoOpticalWriteOnce = 44,
-        MagnetoOpticalRewriteableLIMDOW = 45,
-        PhaseChangeWriteOnce = 46,
-        PhaseChangeRewriteable = 47,
-        PhaseChangeDualRewriteable = 48,
-        AblativeWriteOnce = 49,
-        NearFieldRecording = 50,
-        MiniQic = 51,
-        Travan = 52,
-        EightMillimeterMetalParticle = 53,
-        EightMillimeterAdvancedMetalEvaporate = 54,
-        NCTP = 55,
-        LTOUltrium = 56,
-        LTOAccelis = 57,
-        NineTrackTape = 58,
-        EighteenTrackTape = 59,
-        ThirtySixTrackTape = 60,
-        Magstar3590 = 61,
-        MagstarMP = 62,
-        D2Tape = 63,
-        TapeDSTSmall = 64,
-        TapeDSTMedium = 65,
-        TapeDSTLarge = 66,
-    }
-
-    /// <summary>
-    /// Redump disc category
-    /// </summary>
-    public enum RedumpDiscCategory
-    {
-        Games = 1,
-        Demos = 2,
-        Video = 3,
-        Audio = 4,
-        Multimedia = 5,
-        Applications = 6,
-        Coverdiscs = 7,
-        Educational = 8,
-        BonusDiscs = 9,
-        Preproduction = 10,
-        AddOns = 11,
-    }
-
-    /// <summary>
-    /// Redump dump status
-    /// </summary>
-    public enum RedumpDumpStatus
-    {
-        BadDumpRed = 2,
-        PossibleBadDumpYellow = 3,
-        OriginalMediaBlue = 4,
-        TwoOrMoreDumpsGreen = 5,
-    }
-
-    /// <summary>
-    /// Redump supported langauge
-    /// </summary>
-    public enum RedumpLanguage
-    {
-        Afrikaans,
-        Albanian,
-        Arabic,
-        Basque,
-        Bulgarian,
-        Catalan,
-        Chinese,
-        Croatian,
-        Czech,
-        Danish,
-        Dutch,
-        English,
-        Estonian,
-        Finnish,
-        French,
-        Gaelic,
-        German,
-        Greek,
-        Hebrew,
-        Hindi,
-        Hungarian,
-        Indonesian,
-        Icelandic,
-        Italian,
-        Japanese,
-        Korean,
-        Latin,
-        Latvian,
-        Lithuanian,
-        Macedonian,
-        Norwegian,
-        Polish,
-        Portuguese,
-        Punjabi,
-        Romanian,
-        Russian,
-        Serbian,
-        Slovak,
-        Slovenian,
-        Spanish,
-        Swedish,
-        Tamil,
-        Thai,
-        Turkish,
-        Ukrainian,
-    }
-
-    /// <summary>
-    /// Redump PS2 language selection via
-    /// </summary>
-    public enum RedumpLanguageSelection
-    {
-        BiosSettings,
-        LanguageSelector,
-        OptionsMenu,
-    }
-
-    /// <summary>
-    /// Supported Redump region
-    /// </summary>
-    public enum RedumpRegion
-    {
-        Argentina,
-        Asia,
-        AsiaEurope,
-        AsiaUSA,
-        Australia,
-        AustraliaGermany,
-        AustraliaNewZealand,
-        Austria,
-        AustriaSwitzerland,
-        Belgium,
-        BelgiumNetherlands,
-        Brazil,
-        Bulgaria,
-        Canada,
-        China,
-        Croatia,
-        Czech,
-        Denmark,
-        Estonia,
-        Europe,
-        EuropeAsia,
-        EuropeAustralia,
-        EuropeCanada,
-        EuropeGermany,
-        Export,
-        Finland,
-        France,
-        FranceSpain,
-        Germany,
-        GreaterChina,
-        Greece,
-        Hungary,
-        Iceland,
-        India,
-        Ireland,
-        Israel,
-        Italy,
-        Japan,
-        JapanAsia,
-        JapanEurope,
-        JapanKorea,
-        JapanUSA,
-        Korea,
-        LatinAmerica,
-        Lithuania,
-        Netherlands,
-        NewZealand,
-        Norway,
-        Poland,
-        Portugal,
-        Romania,
-        Russia,
-        Scandinavia,
-        Serbia,
-        Singapore,
-        Slovakia,
-        SouthAfrica,
-        Spain,
-        SpainPortugal,
-        Sweden,
-        Switzerland,
-        Taiwan,
-        Thailand,
-        Turkey,
-        UnitedArabEmirates,
-        UK,
-        UKAustralia,
-        Ukraine,
-        USA,
-        USAAsia,
-        USAAustralia,
-        USABrazil,
-        USACanada,
-        USAEurope,
-        USAGermany,
-        USAJapan,
-        USAKorea,
-        World,
-    }
-
-    /// <summary>
-    /// List of all known Redump systems
-    /// </summary>
-    public enum RedumpSystem
-    {
-        // Special BIOS sets
-        MicrosoftXboxBIOS,
-        NintendoGameCubeBIOS,
-        SonyPlayStationBIOS,
-        SonyPlayStation2BIOS,
-
-        // Regular systems
-        AcornArchimedes,
-        AppleMacintosh,
-        AtariJaguarCDInteractiveMultimediaSystem,
-        AudioCD,
-        BandaiPippin,
-        BandaiPlaydiaQuickInteractiveSystem,
-        BDVideo,
-        CommodoreAmigaCD,
-        CommodoreAmigaCD32,
-        CommodoreAmigaCDTV,
-        DVDVideo,
-        EnhancedCD,
-        FujitsuFMTownsseries,
-        funworldPhotoPlay,
-        HasbroVideoNow,
-        HasbroVideoNowColor,
-        HasbroVideoNowJr,
-        HasbroVideoNowXP,
-        IBMPCcompatible,
-        IncredibleTechnologiesEagle,
-        KonamieAmusement,
-        KonamiFireBeat,
-        KonamiM2,
-        KonamiSystem573,
-        KonamiSystemGV,
-        KonamiTwinkle,
-        MattelFisherPriceiXL,
-        MattelHyperScan,
-        MemorexVisualInformationSystem,
-        MicrosoftXbox,
-        MicrosoftXbox360,
-        MicrosoftXboxOne,
-        MicrosoftXboxSeriesXS,
-        NamcoSegaNintendoTriforce,
-        NamcoSystem12,
-        NamcoSystem246,
-        NavisoftNaviken21,
-        NECPCEngineCDTurboGrafxCD,
-        NECPC88series,
-        NECPC98series,
-        NECPCFXPCFXGA,
-        NintendoGameCube,
-        NintendoWii,
-        NintendoWiiU,
-        PalmOS,
-        Panasonic3DOInteractiveMultiplayer,
-        PanasonicM2,
-        PhilipsCDi,
-        PhotoCD,
-        PlayStationGameSharkUpdates,
-        SegaChihiro,
-        SegaDreamcast,
-        SegaLindbergh,
-        SegaMegaCDSegaCD,
-        SegaNaomi,
-        SegaNaomi2,
-        SegaPrologue21,
-        SegaRingEdge,
-        SegaRingEdge2,
-        SegaSaturn,
-        SegaTitanVideo,
-        SharpX68000,
-        SNKNeoGeoCD,
-        SonyPlayStation,
-        SonyPlayStation2,
-        SonyPlayStation3,
-        SonyPlayStation4,
-        SonyPlayStation5,
-        SonyPlayStationPortable,
-        TABAustriaQuizard,
-        TaoiKTV,
-        TomyKissSite,
-        VideoCD,
-        VMLabsNUON,
-        VTechVFlashVSmilePro,
-        ZAPiTGamesGameWaveFamilyEntertainmentSystem,
-    }
-
-    /// <summary>
-    /// Generic yes/no values for Redump
-    /// </summary>
-    public enum YesNo
-    {
-        NULL = 0,
-        No = 1,
-        Yes = 2,
-    }
-
-    #region Win32_CDROMDrive
-
-    // https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-cdromdrive
-
-    /// <summary>
-    /// Availability and status of the device
-    /// </summary>
-    public enum Availability : ushort
-    {
-        Other = 1,
-        Unknown = 2,
-        RunningFullPower = 3,
-        Warning = 4,
-        InTest = 5,
-        NotApplicable = 6,
-        PowerOff = 7,
-        OffLine = 8,
-        OffDuty = 9,
-        Degraded = 10,
-        NotInstalled = 11,
-        InstallError = 12,
-        PowerSaveUnknown = 13,
-        PowerSaveLowPowerMode = 14,
-        PowerSaveStandby = 15,
-        PowerCycle = 16,
-        PowerSaveWarning = 17,
-        Paused = 18,
-        NotReady = 19,
-        NotConfigured = 20,
-        Quiesced = 21,
-    }
-
-    /// <summary>
-    /// Optical drive capabilities
-    /// </summary>
-    public enum Capabilities : ushort
-    {
-        Unknown = 0,
-        Other = 1,
-        SequentialAccess = 2,
-        RandomAccess = 3,
-        SupportsWriting = 4,
-        Encryption = 5,
-        Compression = 6,
-        SupportsRemoveableMedia = 7,
-        ManualCleaning = 8,
-        AutomaticCleaning = 9,
-        SMARTNotification = 10,
-        SupportsDualSidedMedia = 11,
-        PredismountEjectNotRequired = 12,
-    }
-
-    /// <summary>
-    /// File system flags
-    /// </summary>
-    [Flags]
-    public enum FileSystemFlags : uint
-    {
-        None = 0,
-        CaseSensitiveSearch = 1,
-        CasePreservedNames = 2,
-        UnicodeOnDisk = 4,
-        PersistentACLs = 8,
-        FileCompression = 16,
-        VolumeQuotas = 32,
-        SupportsSparseFiles = 64,
-        SupportsReparsePoints = 128,
-        SupportsRemoteStorage = 256,
-        SupportsLongNames = 16384,
-        VolumeIsCompressed = 32768,
-        ReadOnlyVolume = 524288,
-        SupportsObjectIDS = 65536,
-        SupportsEncryption = 131072,
-        SupportsNamedStreams = 262144,
-    }
-
-    /// <summary>
-    /// Specific power-related capabilities of a logical device
-    /// </summary>
-    public enum PowerManagementCapabilities : ushort
-    {
-        Unknown = 0,
-        NotSupported = 1,
-        Disabled = 2,
-        Enabled = 3,
-        PowerSavingModesEnteredAutomatically = 4,
-        PowerStateSettable = 5,
-        PowerCyclingSupported = 6,
-        TimedPowerOnSupported = 7,
-    }
-
-    #endregion
-}

MPF.Library/DiscImageCreator/Converters.cs

@@ -1,341 +0,0 @@
-using MPF.Data;
-
-namespace MPF.DiscImageCreator
-{
-    public static class Converters
-    {
-        #region Cross-enumeration conversions
-
-        /// <summary>
-        /// Get the most common known system for a given MediaType
-        /// </summary>
-        /// <param name="baseCommand">Command value to check</param>
-        /// <returns>KnownSystem if possible, null on error</returns>
-        public static KnownSystem? ToKnownSystem(Command baseCommand)
-        {
-            switch (baseCommand)
-            {
-                case Command.Audio:
-                    return KnownSystem.AudioCD;
-                case Command.CompactDisc:
-                case Command.Data:
-                case Command.DigitalVideoDisc:
-                case Command.Disk:
-                case Command.Floppy:
-                case Command.Tape:
-                    return KnownSystem.IBMPCCompatible;
-                case Command.GDROM:
-                case Command.Swap:
-                    return KnownSystem.SegaDreamcast;
-                case Command.BluRay:
-                    return KnownSystem.SonyPlayStation3;
-                case Command.SACD:
-                    return KnownSystem.SuperAudioCD;
-                case Command.XBOX:
-                case Command.XBOXSwap:
-                    return KnownSystem.MicrosoftXBOX;
-                case Command.XGD2Swap:
-                case Command.XGD3Swap:
-                    return KnownSystem.MicrosoftXBOX360;
-                default:
-                    return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the MediaType associated with a given base command
-        /// </summary>
-        /// <param name="baseCommand">Command value to check</param>
-        /// <returns>MediaType if possible, null on error</returns>
-        /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
-        public static MediaType? ToMediaType(Command baseCommand)
-        {
-            switch (baseCommand)
-            {
-                case Command.Audio:
-                case Command.CompactDisc:
-                case Command.Data:
-                case Command.SACD:
-                    return MediaType.CDROM;
-                case Command.GDROM:
-                case Command.Swap:
-                    return MediaType.GDROM;
-                case Command.DigitalVideoDisc:
-                case Command.XBOX:
-                case Command.XBOXSwap:
-                case Command.XGD2Swap:
-                case Command.XGD3Swap:
-                    return MediaType.DVD;
-                case Command.BluRay:
-                    return MediaType.BluRay;
-
-                // Non-optical
-                case Command.Floppy:
-                    return MediaType.FloppyDisk;
-                case Command.Disk:
-                    return MediaType.HardDisk;
-                case Command.Tape:
-                    return MediaType.DataCartridge;
-                default:
-                    return null;
-            }
-        }
-
-        /// <summary>
-        /// Get the default extension for a given disc type
-        /// </summary>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>Valid extension (with leading '.'), null on error</returns>
-        public static string Extension(MediaType? type)
-        {
-            switch (type)
-            {
-                case MediaType.CDROM:
-                case MediaType.GDROM:
-                case MediaType.Cartridge:
-                case MediaType.HardDisk:
-                case MediaType.CompactFlash:
-                case MediaType.MMC:
-                case MediaType.SDCard:
-                case MediaType.FlashDrive:
-                    return ".bin";
-                case MediaType.DVD:
-                case MediaType.HDDVD:
-                case MediaType.BluRay:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return ".iso";
-                case MediaType.LaserDisc:
-                case MediaType.NintendoGameCubeGameDisc:
-                    return ".raw";
-                case MediaType.NintendoWiiUOpticalDisc:
-                    return ".wud";
-                case MediaType.FloppyDisk:
-                    return ".img";
-                case MediaType.Cassette:
-                    return ".wav";
-                case MediaType.NONE:
-                default:
-                    return null;
-            }
-        }
-
-        #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                case Command.Audio:
-                    return CommandStrings.Audio;
-                case Command.BluRay:
-                    return CommandStrings.BluRay;
-                case Command.Close:
-                    return CommandStrings.Close;
-                case Command.CompactDisc:
-                    return CommandStrings.CompactDisc;
-                case Command.Data:
-                    return CommandStrings.Data;
-                case Command.DigitalVideoDisc:
-                    return CommandStrings.DigitalVideoDisc;
-                case Command.Disk:
-                    return CommandStrings.Disk;
-                case Command.DriveSpeed:
-                    return CommandStrings.DriveSpeed;
-                case Command.Eject:
-                    return CommandStrings.Eject;
-                case Command.Floppy:
-                    return CommandStrings.Floppy;
-                case Command.GDROM:
-                    return CommandStrings.GDROM;
-                case Command.MDS:
-                    return CommandStrings.MDS;
-                case Command.Merge:
-                    return CommandStrings.Merge;
-                case Command.Reset:
-                    return CommandStrings.Reset;
-                case Command.SACD:
-                    return CommandStrings.SACD;
-                case Command.Start:
-                    return CommandStrings.Start;
-                case Command.Stop:
-                    return CommandStrings.Stop;
-                case Command.Sub:
-                    return CommandStrings.Sub;
-                case Command.Swap:
-                    return CommandStrings.Swap;
-                case Command.Tape:
-                    return CommandStrings.Tape;
-                case Command.XBOX:
-                    return CommandStrings.XBOX;
-                case Command.XBOXSwap:
-                    return CommandStrings.XBOXSwap;
-                case Command.XGD2Swap:
-                    return CommandStrings.XGD2Swap;
-                case Command.XGD3Swap:
-                    return CommandStrings.XGD3Swap;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                case Flag.AddOffset:
-                    return FlagStrings.AddOffset;
-                case Flag.AMSF:
-                    return FlagStrings.AMSF;
-                case Flag.AtariJaguar:
-                    return FlagStrings.AtariJaguar;
-                case Flag.BEOpcode:
-                    return FlagStrings.BEOpcode;
-                case Flag.C2Opcode:
-                    return FlagStrings.C2Opcode;
-                case Flag.CopyrightManagementInformation:
-                    return FlagStrings.CopyrightManagementInformation;
-                case Flag.D8Opcode:
-                    return FlagStrings.D8Opcode;
-                case Flag.DisableBeep:
-                    return FlagStrings.DisableBeep;
-                case Flag.ExtractMicroSoftCabFile:
-                    return FlagStrings.ExtractMicroSoftCabFile;
-                case Flag.Fix:
-                    return FlagStrings.Fix;
-                case Flag.ForceUnitAccess:
-                    return FlagStrings.ForceUnitAccess;
-                case Flag.MultiSectorRead:
-                    return FlagStrings.MultiSectorRead;
-                case Flag.MultiSession:
-                    return FlagStrings.MultiSession;
-                case Flag.NoFixSubP:
-                    return FlagStrings.NoFixSubP;
-                case Flag.NoFixSubQ:
-                    return FlagStrings.NoFixSubQ;
-                case Flag.NoFixSubQLibCrypt:
-                    return FlagStrings.NoFixSubQLibCrypt;
-                case Flag.NoFixSubRtoW:
-                    return FlagStrings.NoFixSubRtoW;
-                case Flag.NoFixSubQSecuROM:
-                    return FlagStrings.NoFixSubQSecuROM;
-                case Flag.NoSkipSS:
-                    return FlagStrings.NoSkipSS;
-                case Flag.PadSector:
-                    return FlagStrings.PadSector;
-                case Flag.Raw:
-                    return FlagStrings.Raw;
-                case Flag.Resume:
-                    return FlagStrings.Resume;
-                case Flag.Reverse:
-                    return FlagStrings.Reverse;
-                case Flag.ScanAntiMod:
-                    return FlagStrings.ScanAntiMod;
-                case Flag.ScanFileProtect:
-                    return FlagStrings.ScanFileProtect;
-                case Flag.ScanSectorProtect:
-                    return FlagStrings.ScanSectorProtect;
-                case Flag.SeventyFour:
-                    return FlagStrings.SeventyFour;
-                case Flag.SkipSector:
-                    return FlagStrings.SkipSector;
-                case Flag.SubchannelReadLevel:
-                    return FlagStrings.SubchannelReadLevel;
-                case Flag.UseAnchorVolumeDescriptorPointer:
-                    return FlagStrings.UseAnchorVolumeDescriptorPointer;
-                case Flag.VideoNow:
-                    return FlagStrings.VideoNow;
-                case Flag.VideoNowColor:
-                    return FlagStrings.VideoNowColor;
-                case Flag.VideoNowXP:
-                    return FlagStrings.VideoNowXP;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="command">String value to convert</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string command)
-        {
-            switch (command)
-            {
-                case CommandStrings.Audio:
-                    return Command.Audio;
-                case CommandStrings.BluRay:
-                    return Command.BluRay;
-                case CommandStrings.Close:
-                    return Command.Close;
-                case CommandStrings.CompactDisc:
-                    return Command.CompactDisc;
-                case CommandStrings.Data:
-                    return Command.Data;
-                case CommandStrings.DigitalVideoDisc:
-                    return Command.DigitalVideoDisc;
-                case CommandStrings.Disk:
-                    return Command.Disk;
-                case CommandStrings.DriveSpeed:
-                    return Command.DriveSpeed;
-                case CommandStrings.Eject:
-                    return Command.Eject;
-                case CommandStrings.Floppy:
-                    return Command.Floppy;
-                case CommandStrings.GDROM:
-                    return Command.GDROM;
-                case CommandStrings.MDS:
-                    return Command.MDS;
-                case CommandStrings.Merge:
-                    return Command.Merge;
-                case CommandStrings.Reset:
-                    return Command.Reset;
-                case CommandStrings.SACD:
-                    return Command.SACD;
-                case CommandStrings.Start:
-                    return Command.Start;
-                case CommandStrings.Stop:
-                    return Command.Stop;
-                case CommandStrings.Sub:
-                    return Command.Sub;
-                case CommandStrings.Swap:
-                    return Command.Swap;
-                case CommandStrings.Tape:
-                    return Command.Tape;
-                case CommandStrings.XBOX:
-                    return Command.XBOX;
-                case CommandStrings.XBOXSwap:
-                    return Command.XBOXSwap;
-                case CommandStrings.XGD2Swap:
-                    return Command.XGD2Swap;
-                case CommandStrings.XGD3Swap:
-                    return Command.XGD3Swap;
-
-                default:
-                    return Command.NONE;
-            }
-        }
-
-        #endregion
-    }
-}

MPF.Library/DiscImageCreator/Enumerations.cs

@@ -1,75 +0,0 @@
-namespace MPF.DiscImageCreator
-{
-    /// <summary>
-    /// Supported DiscImageCreator commands
-    /// </summary>
-    public enum Command : int
-    {
-        NONE = 0,
-        Audio,
-        BluRay,
-        Close,
-        CompactDisc,
-        Data,
-        DigitalVideoDisc,
-        Disk,
-        DriveSpeed,
-        Eject,
-        Floppy,
-        GDROM,
-        MDS,
-        Merge,
-        Reset,
-        SACD,
-        Start,
-        Stop,
-        Sub,
-        Swap,
-        Tape,
-        XBOX,
-        XBOXSwap,
-        XGD2Swap,
-        XGD3Swap,
-    }
-
-    /// <summary>
-    /// Supported DiscImageCreator flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-        AddOffset,
-        AMSF,
-        AtariJaguar,
-        BEOpcode,
-        C2Opcode,
-        CopyrightManagementInformation,
-        D8Opcode,
-        DisableBeep,
-        ExtractMicroSoftCabFile,
-        Fix,
-        ForceUnitAccess,
-        MultiSectorRead,
-        MultiSession,
-        NoFixSubP,
-        NoFixSubQ,
-        NoFixSubQLibCrypt,
-        NoFixSubRtoW,
-        NoFixSubQSecuROM,
-        NoSkipSS,
-        PadSector,
-        Raw,
-        Resume,
-        Reverse,
-        ScanAntiMod,
-        ScanFileProtect,
-        ScanSectorProtect,
-        SeventyFour,
-        SkipSector,
-        SubchannelReadLevel,
-        UseAnchorVolumeDescriptorPointer,
-        VideoNow,
-        VideoNowColor,
-        VideoNowXP,
-    }
-}

MPF.Library/DumpEnvironment.cs

@@ -0,0 +1,535 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+using BurnOutSharp;
+using MPF.Core.Data;
+using MPF.Core.Utilities;
+using MPF.Modules;
+using RedumpLib.Data;
+
+namespace MPF.Library
+{
+    /// <summary>
+    /// Represents the state of all settings to be used during dumping
+    /// </summary>
+    public class DumpEnvironment
+    {
+        #region Output paths
+
+        /// <summary>
+        /// Base output directory to write files to
+        /// </summary>
+        public string OutputDirectory { get; private set; }
+
+        /// <summary>
+        /// Base output filename for output
+        /// </summary>
+        public string OutputFilename { get; private set; }
+
+        #endregion
+
+        #region UI information
+
+        /// <summary>
+        /// Drive object representing the current drive
+        /// </summary>
+        public Drive Drive { get; private set; }
+
+        /// <summary>
+        /// Currently selected system
+        /// </summary>
+        public RedumpSystem? System { get; private set; }
+
+        /// <summary>
+        /// Currently selected media type
+        /// </summary>
+        public MediaType? Type { get; private set; }
+
+        /// <summary>
+        /// Options object representing user-defined options
+        /// </summary>
+        public Options Options { get; private set; }
+
+        /// <summary>
+        /// Parameters object representing what to send to the internal program
+        /// </summary>
+        public BaseParameters Parameters { get; private set; }
+
+        #endregion
+        
+        #region Event Handlers
+
+        /// <summary>
+        /// Generic way of reporting a message
+        /// </summary>
+        public EventHandler<string> ReportStatus;
+
+        /// <summary>
+        /// Queue of items that need to be logged
+        /// </summary>
+        private ProcessingQueue<string> outputQueue;
+
+        /// <summary>
+        /// Event handler for data returned from a process
+        /// </summary>
+        private void OutputToLog(object proc, string args) => outputQueue.Enqueue(args);
+
+        /// <summary>
+        /// Process the outputs in the queue
+        /// </summary>
+        private void ProcessOutputs(string nextOutput) => ReportStatus.Invoke(this, nextOutput);
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for a full DumpEnvironment object from user information
+        /// </summary>
+        /// <param name="options"></param>
+        /// <param name="outputDirectory"></param>
+        /// <param name="outputFilename"></param>
+        /// <param name="drive"></param>
+        /// <param name="system"></param>
+        /// <param name="type"></param>
+        /// <param name="parameters"></param>
+        public DumpEnvironment(Options options,
+            string outputDirectory,
+            string outputFilename,
+            Drive drive,
+            RedumpSystem? system,
+            MediaType? type,
+            string parameters)
+        {
+            // Set options object
+            this.Options = options;
+
+            // Output paths
+            (this.OutputDirectory, this.OutputFilename) = InfoTool.NormalizeOutputPaths(outputDirectory, outputFilename);
+
+            // UI information
+            this.Drive = drive;
+            this.System = system ?? options.DefaultSystem;
+            this.Type = type ?? MediaType.NONE;
+            
+            // Dumping program
+            SetParameters(parameters);
+        }
+
+        #region Public Functionality
+
+        /// <summary>
+        /// Adjust output paths if we're using DiscImageCreator
+        /// </summary>
+        public void AdjustPathsForDiscImageCreator()
+        {
+            // Only DiscImageCreator has issues with paths
+            if (this.Parameters.InternalProgram != InternalProgram.DiscImageCreator)
+                return;
+
+            // Replace all instances in the output directory
+            this.OutputDirectory = this.OutputDirectory.Replace('.', '_');
+
+            // Currently, only periods in directories matter
+            // Leave the following code commented in case filename handling breaks again
+
+            // Replace all instances in the output filename, except the extension
+            //string tempFilename = Path.GetFileNameWithoutExtension(this.OutputFilename)
+            //    .Replace('.', '_');
+            //string tempExtension = Path.GetExtension(this.OutputFilename)?.TrimStart('.');
+            //this.OutputFilename = $"{tempFilename}.{tempExtension}";
+        }
+
+        /// <summary>
+        /// Set the parameters object based on the internal program and parameters string
+        /// </summary>
+        /// <param name="parameters">String representation of the parameters</param>
+        public void SetParameters(string parameters)
+        {
+            switch (Options.InternalProgram)
+            {
+                // Dumping support
+                case InternalProgram.Aaru:
+                    this.Parameters = new Modules.Aaru.Parameters(parameters) { ExecutablePath = Options.AaruPath };
+                    break;
+
+                case InternalProgram.DD:
+                    this.Parameters = new Modules.DD.Parameters(parameters) { ExecutablePath = Options.DDPath };
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    this.Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
+                    break;
+
+                // Verification support only
+                case InternalProgram.CleanRip:
+                    this.Parameters = new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null };
+                    break;
+
+                case InternalProgram.DCDumper:
+                    this.Parameters = null; // TODO: Create correct parameter type when supported
+                    break;
+
+                case InternalProgram.UmdImageCreator:
+                    this.Parameters = new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null };
+                    break;
+
+                // This should never happen, but it needs a fallback
+                default:
+                    this.Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
+                    break;
+            }
+
+            // Set system and type
+            this.Parameters.System = this.System;
+            this.Parameters.Type = this.Type;
+        }
+
+        /// <summary>
+        /// Get the full parameter string for either DiscImageCreator or Aaru
+        /// </summary>
+        /// <param name="driveSpeed">Nullable int representing the drive speed</param>
+        /// <returns>String representing the params, null on error</returns>
+        public string GetFullParameters(int? driveSpeed)
+        {
+            // Populate with the correct params for inputs (if we're not on the default option)
+            if (System != null && Type != MediaType.NONE)
+            {
+                // If drive letter is invalid, skip this
+                if (Drive == null)
+                    return null;
+
+                // Set the proper parameters
+                string filename = OutputDirectory + Path.DirectorySeparatorChar + OutputFilename;
+                switch (Options.InternalProgram)
+                {
+                    case InternalProgram.Aaru:
+                        Parameters = new Modules.Aaru.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
+                        break;
+
+                    case InternalProgram.DD:
+                        Parameters = new Modules.DD.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
+                        break;
+
+                    case InternalProgram.DiscImageCreator:
+                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
+                        break;
+
+                    // This should never happen, but it needs a fallback
+                    default:
+                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Letter, filename, driveSpeed, Options);
+                        break;
+                }
+
+                // Generate and return the param string
+                return Parameters.GenerateParameters();
+            }
+
+            return null;
+        }
+
+        #endregion
+
+        #region Dumping
+
+        /// <summary>
+        /// Cancel an in-progress dumping process
+        /// </summary>
+        public void CancelDumping() => Parameters.KillInternalProgram();
+
+        /// <summary>
+        /// Eject the disc using DiscImageCreator
+        /// </summary>
+        public async Task<string> EjectDisc() =>
+            await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Eject);
+
+        /// <summary>
+        /// Reset the current drive using DiscImageCreator
+        /// </summary>
+        public async Task<string> ResetDrive() =>
+            await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Reset);
+
+        /// <summary>
+        /// Execute the initial invocation of the dumping programs
+        /// </summary>
+        /// <param name="progress">Optional result progress callback</param>
+        public async Task<Result> Run(IProgress<Result> progress = null)
+        {
+            // Check that we have the basics for dumping
+            Result result = IsValidForDump();
+            if (!result)
+                return result;
+
+            // Invoke output processing, if needed
+            if (!Options.ToolsInSeparateWindow)
+            {
+                outputQueue = new ProcessingQueue<string>(ProcessOutputs);
+                Parameters.ReportStatus += OutputToLog;
+            }
+
+            // Execute internal tool
+            progress?.Report(Result.Success($"Executing {Options.InternalProgram}... {(Options.ToolsInSeparateWindow ? "please wait!" : "see log for output!")}"));
+            Directory.CreateDirectory(OutputDirectory);
+            await Task.Run(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
+            progress?.Report(Result.Success($"{Options.InternalProgram} has finished!"));
+
+            // Execute additional tools
+            progress?.Report(Result.Success("Running any additional tools... see log for output!"));
+            result = await Task.Run(() => ExecuteAdditionalTools());
+            progress?.Report(result);
+
+            // Remove event handler if needed
+            if (!Options.ToolsInSeparateWindow)
+            {
+                outputQueue.Dispose();
+                Parameters.ReportStatus -= OutputToLog;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Verify that the current environment has a complete dump and create submission info is possible
+        /// </summary>
+        /// <param name="resultProgress">Optional result progress callback</param>
+        /// <param name="protectionProgress">Optional protection progress callback</param>
+        /// <param name="processUserInfo">Optional user prompt to deal with submission information</param>
+        /// <returns>Result instance with the outcome</returns>
+        public async Task<Result> VerifyAndSaveDumpOutput(
+            IProgress<Result> resultProgress = null,
+            IProgress<ProtectionProgress> protectionProgress = null,
+            Func<SubmissionInfo, (bool?, SubmissionInfo)> processUserInfo = null)
+        {
+            resultProgress?.Report(Result.Success("Gathering submission information... please wait!"));
+
+            // Check to make sure that the output had all the correct files
+            (bool foundFiles, List<string> missingFiles) = InfoTool.FoundAllFiles(this.OutputDirectory, this.OutputFilename, this.Parameters, false);
+            if (!foundFiles)
+            {
+                resultProgress?.Report(Result.Failure($"There were files missing from the output:\n{string.Join("\n", missingFiles)}"));
+                return Result.Failure("Error! Please check output directory as dump may be incomplete!");
+            }
+
+            // Extract the information from the output files
+            resultProgress?.Report(Result.Success("Extracting output information from output files..."));
+            SubmissionInfo submissionInfo = await InfoTool.ExtractOutputInformation(
+                this.OutputDirectory,
+                this.OutputFilename,
+                this.Drive,
+                this.System,
+                this.Type,
+                this.Options,
+                this.Parameters,
+                resultProgress,
+                protectionProgress);
+            resultProgress?.Report(Result.Success("Extracting information complete!"));
+
+            // Eject the disc automatically if configured to
+            if (Options.EjectAfterDump == true)
+            {
+                resultProgress?.Report(Result.Success($"Ejecting disc in drive {Drive.Letter}"));
+                await EjectDisc();
+            }
+
+            // Reset the drive automatically if configured to
+            if (Options.InternalProgram == InternalProgram.DiscImageCreator && Options.DICResetDriveAfterDump)
+            {
+                resultProgress?.Report(Result.Success($"Resetting drive {Drive.Letter}"));
+                await ResetDrive();
+            }
+
+            // Get user-modifiable information if confugured to
+            if (Options.PromptForDiscInformation && processUserInfo != null)
+            {
+                resultProgress?.Report(Result.Success("Waiting for additional disc information..."));
+
+                bool? filledInfo;
+                (filledInfo, submissionInfo) = processUserInfo(submissionInfo);
+
+                if (filledInfo == true)
+                    resultProgress?.Report(Result.Success("Additional disc information added!"));
+                else
+                    resultProgress?.Report(Result.Success("Disc information skipped!"));
+            }
+
+            // Process special fields for site codes
+            resultProgress?.Report(Result.Success("Processing site codes..."));
+            InfoTool.ProcessSpecialFields(submissionInfo);
+            resultProgress?.Report(Result.Success("Processing complete!"));
+
+            // Format the information for the text output
+            resultProgress?.Report(Result.Success("Formatting information..."));
+            List<string> formattedValues = InfoTool.FormatOutputData(submissionInfo);
+            resultProgress?.Report(Result.Success("Formatting complete!"));
+
+            // Write the text output
+            resultProgress?.Report(Result.Success("Writing information to !submissionInfo.txt..."));
+            bool success = InfoTool.WriteOutputData(this.OutputDirectory, formattedValues);
+            if (success)
+                resultProgress?.Report(Result.Success("Writing complete!"));
+            else
+                resultProgress?.Report(Result.Failure("Writing could not complete!"));
+
+            // Write the JSON output, if required
+            if (Options.OutputSubmissionJSON)
+            {
+                resultProgress?.Report(Result.Success("Writing information to !submissionInfo.json.gz..."));
+                success = InfoTool.WriteOutputData(this.OutputDirectory, submissionInfo);
+                if (success)
+                    resultProgress?.Report(Result.Success("Writing complete!"));
+                else
+                    resultProgress?.Report(Result.Failure("Writing could not complete!"));
+            }
+
+            // Conpress the logs, if required
+            if (Options.CompressLogFiles)
+            {
+                resultProgress?.Report(Result.Success("Compressing log files..."));
+                success = InfoTool.CompressLogFiles(this.OutputDirectory, this.OutputFilename, this.Parameters);
+                if (success)
+                    resultProgress?.Report(Result.Success("Compression complete!"));
+                else
+                    resultProgress?.Report(Result.Failure("Compression could not complete!"));
+            }
+
+            resultProgress?.Report(Result.Success("Submission information process complete!"));
+            return Result.Success();
+        }
+
+        /// <summary>
+        /// Checks if the parameters are valid
+        /// </summary>
+        /// <returns>True if the configuration is valid, false otherwise</returns>
+        internal bool ParametersValid()
+        {
+            bool parametersValid = Parameters.IsValid();
+            bool floppyValid = !(Drive.InternalDriveType == InternalDriveType.Floppy ^ Type == MediaType.FloppyDisk);
+
+            // TODO: HardDisk being in the Removable category is a hack, fix this later
+            bool removableDiskValid = !((Drive.InternalDriveType == InternalDriveType.Removable || Drive.InternalDriveType == InternalDriveType.HardDisk)
+                ^ (Type == MediaType.CompactFlash || Type == MediaType.SDCard || Type == MediaType.FlashDrive || Type == MediaType.HardDisk));
+
+            return parametersValid && floppyValid && removableDiskValid;
+        }
+
+        /// <summary>
+        /// Run any additional tools given a DumpEnvironment
+        /// </summary>
+        /// <returns>Result instance with the outcome</returns>
+        private Result ExecuteAdditionalTools() => Result.Success("No external tools needed!");
+
+        /// <summary>
+        /// Run internal program async with an input set of parameters
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <returns>Standard output from commandline window</returns>
+        private async Task<string> ExecuteInternalProgram(BaseParameters parameters)
+        {
+            Process childProcess;
+            string output = await Task.Run(() =>
+            {
+                childProcess = new Process()
+                {
+                    StartInfo = new ProcessStartInfo()
+                    {
+                        FileName = parameters.ExecutablePath,
+                        Arguments = parameters.GenerateParameters(),
+                        CreateNoWindow = true,
+                        UseShellExecute = false,
+                        RedirectStandardInput = true,
+                        RedirectStandardOutput = true,
+                    },
+                };
+                childProcess.Start();
+                childProcess.WaitForExit(1000);
+
+                // Just in case, we want to push a button 5 times to clear any errors
+                for (int i = 0; i < 5; i++)
+                    childProcess.StandardInput.WriteLine("Y");
+
+                string stdout = childProcess.StandardOutput.ReadToEnd();
+                childProcess.Dispose();
+                return stdout;
+            });
+
+            return output;
+        }
+
+        /// <summary>
+        /// Validate the current environment is ready for a dump
+        /// </summary>
+        /// <returns>Result instance with the outcome</returns>
+        private Result IsValidForDump()
+        {
+            // Validate that everything is good
+            if (!ParametersValid())
+                return Result.Failure("Error! Current configuration is not supported!");
+
+            // Fix the output paths, just in case
+            (OutputDirectory, OutputFilename) = InfoTool.NormalizeOutputPaths(OutputDirectory, OutputFilename);
+
+            // Validate that the output path isn't on the dumping drive
+            string fullOutputPath = Path.GetFullPath(Path.Combine(OutputDirectory, OutputFilename));
+            if (fullOutputPath[0] == Drive.Letter)
+                return Result.Failure($"Error! Cannot output to same drive that is being dumped!");
+
+            // Validate that the required program exists
+            if (!File.Exists(Parameters.ExecutablePath))
+                return Result.Failure($"Error! {Parameters.ExecutablePath} does not exist!");
+
+            // Validate that the dumping drive doesn't contain the executable
+            string fullExecutablePath = Path.GetFullPath(Parameters.ExecutablePath);
+            if (fullExecutablePath[0] == Drive.Letter)
+                return Result.Failure("$Error! Cannot dump same drive that executable resides on!");
+
+            // Validate that the current configuration is supported
+            return Tools.GetSupportStatus(System, Type);
+        }
+
+        /// <summary>
+        /// Validate that DIscImageCreator is able to be found
+        /// </summary>
+        /// <returns>True if DiscImageCreator is found properly, false otherwise</returns>
+        private bool RequiredProgramsExist()
+        {
+            // Validate that the path is configured
+            if (string.IsNullOrWhiteSpace(Options.DiscImageCreatorPath))
+                return false;
+
+            // Validate that the required program exists
+            if (!File.Exists(Options.DiscImageCreatorPath))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Run a standalone DiscImageCreator command
+        /// </summary>
+        /// <param name="command">Command string to run</param>
+        /// <returns>The output of the command on success, null on error</returns>
+        private async Task<string> RunStandaloneDiscImageCreatorCommand(string command)
+        {
+            // Validate that DiscImageCreator is all set
+            if (!RequiredProgramsExist())
+                return null;
+
+            // Validate we're not trying to eject a non-optical
+            if (Drive.InternalDriveType != InternalDriveType.Optical)
+                return null;
+
+            CancelDumping();
+
+            var parameters = new Modules.DiscImageCreator.Parameters(string.Empty)
+            {
+                BaseCommand = command,
+                DriveLetter = Drive.Letter.ToString(),
+                ExecutablePath = Options.DiscImageCreatorPath,
+            };
+
+            return await ExecuteInternalProgram(parameters);
+        }
+
+        #endregion
+    }
+}

MPF.Library/MPF.Library.csproj

@@ -1,14 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1</TargetFrameworks>
-    <Title>MPF Library</Title>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
     <AssemblyName>MPF.Library</AssemblyName>
-    <Description>Library code for MPF and MPF.Check</Description>
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
     <Copyright>Copyright (c)2019-2021</Copyright>
     <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.0</Version>
+    <Version>2.3</Version>
     <AssemblyVersion>$(Version)</AssemblyVersion>
     <FileVersion>$(Version)</FileVersion>
     <IncludeSource>true</IncludeSource>
@@ -22,72 +21,30 @@
     <NrtShowRevision>false</NrtShowRevision>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(TargetFramework)'!='netcoreapp3.1'">
+  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
     <DefineConstants>NET_FRAMEWORK</DefineConstants>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)'!='netcoreapp3.1'">
-    <COMReference Include="IMAPI2">
-      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
-    <COMReference Include="IMAPI2FS">
-      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
-      <VersionMajor>1</VersionMajor>
-      <VersionMinor>0</VersionMinor>
-      <Lcid>0</Lcid>
-      <WrapperTool>tlbimp</WrapperTool>
-      <Isolated>False</Isolated>
-      <EmbedInteropTypes>True</EmbedInteropTypes>
-    </COMReference>
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+    <ProjectReference Include="..\MPF.Modules\MPF.Modules.csproj" />
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Remove="Aaru\CICMMetadata\CICMMetadataEditor\**" />
-    <Compile Remove="Aaru\CICMMetadata\java\**" />
-    <Compile Remove="Aaru\CICMMetadata\samples\**" />
-    <EmbeddedResource Remove="Aaru\CICMMetadata\CICMMetadataEditor\**" />
-    <EmbeddedResource Remove="Aaru\CICMMetadata\java\**" />
-    <EmbeddedResource Remove="Aaru\CICMMetadata\samples\**" />
-    <None Remove="Aaru\CICMMetadata\CICMMetadataEditor\**" />
-    <None Remove="Aaru\CICMMetadata\java\**" />
-    <None Remove="Aaru\CICMMetadata\samples\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Remove="Aaru\CICMMetadata\.editorconfig" />
-    <None Remove="Aaru\CICMMetadata\.git" />
-    <None Remove="Aaru\CICMMetadata\.gitignore" />
-    <None Remove="Aaru\CICMMetadata\.project" />
-    <None Remove="Aaru\CICMMetadata\build.sh" />
-    <None Remove="Aaru\CICMMetadata\cicm.xml" />
-    <None Remove="Aaru\CICMMetadata\cicm.xsd" />
-    <None Remove="Aaru\CICMMetadata\CICMMetadata.iml" />
-    <None Remove="Aaru\CICMMetadata\dotnet\cicm.vb" />
-    <None Remove="Aaru\CICMMetadata\README.md" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.6.1" GeneratePathProperty="true">
+    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.8.0" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="System.IO.Compression" Version="4.3.0" />
-    <PackageReference Include="System.Management" Version="6.0.0-preview.3.21201.4" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.0" />
+    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
   
   <ItemGroup>
     <Content Include="$(PkgBurnOutSharp)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Reference Include="System.Management" />
-  </ItemGroup>
-
 </Project>

MPF.Library/Protection.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using BurnOutSharp;
+using BurnOutSharp.External.psxt001z;
+using BurnOutSharp.ProtectionType;
+using MPF.Core.Data;
+
+namespace MPF.Library
+{
+    public static class Protection
+    {
+        /// <summary>
+        /// Run protection scan on a given dump environment
+        /// </summary>
+        /// <param name="path">Path to scan for protection</param>
+        /// <param name="options">Options object that determines what to scan</param>
+        /// <param name="progress">Optional progress callback</param>
+        /// <returns>TCopy protection detected in the envirionment, if any</returns>
+        public static async Task<(bool, string)> RunProtectionScanOnPath(string path, Options options, IProgress<ProtectionProgress> progress = null)
+        {
+            try
+            {
+                var found = await Task.Run(() =>
+                {
+                    var scanner = new Scanner(progress)
+                    {
+                        IncludeDebug = options.IncludeDebugProtectionInformation,
+                        ScanAllFiles = options.ForceScanningForProtection,
+                        ScanArchives = options.ScanArchivesForProtection,
+                        ScanPackers = options.ScanPackersForProtection,
+                    };
+                    return scanner.GetProtections(path);
+                });
+
+                if (found == null || found.Count() == 0)
+                    return (true, "None found");
+
+                // Get an ordered list of distinct found protections
+                var orderedDistinctProtections = found
+                    .Where(kvp => kvp.Value != null && kvp.Value.Any())
+                    .SelectMany(kvp => kvp.Value)
+                    .Distinct()
+                    .OrderBy(p => p);
+
+                // Sanitize and join protections for writing
+                string protections = SanitizeFoundProtections(orderedDistinctProtections);
+                return (true, protections);
+            }
+            catch (Exception ex)
+            {
+                return (false, ex.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Get the existence of an anti-modchip string from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="path">Path to scan for anti-modchip strings</param>
+        /// <returns>Anti-modchip existence if possible, false on error</returns>
+        public static async Task<bool> GetPlayStationAntiModchipDetected(string path)
+        {
+            return await Task.Run(() =>
+            {
+                try
+                {
+                    var antiModchip = new PSXAntiModchip();
+                    foreach (string file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories))
+                    {
+                        try
+                        {
+                            byte[] fileContent = File.ReadAllBytes(file);
+                            string protection = antiModchip.CheckContents(file, fileContent, false, null, null);
+                            if (!string.IsNullOrWhiteSpace(protection))
+                                return true;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+
+                return false;
+            });
+        }
+
+        /// <summary>
+        /// Get if LibCrypt data is detected in the subchannel file, if possible
+        /// </summary>
+        /// <param name="sub">.sub file location</param>
+        /// <returns>Status of the LibCrypt data, if possible</returns>
+        public static bool? GetLibCryptDetected(string sub)
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(sub))
+                return null;
+
+            return LibCrypt.CheckSubfile(sub);
+        }
+
+        /// <summary>
+        /// Sanitize unnecessary protection duplication from output
+        /// </summary>
+        /// <param name="foundProtections">Enumerable of found protections</param>
+        public static string SanitizeFoundProtections(IEnumerable<string> foundProtections)
+        {
+            // ActiveMARK
+            if (foundProtections.Any(p => p == "ActiveMARK 5") && foundProtections.Any(p => p == "ActiveMARK"))
+                foundProtections = foundProtections.Where(p => p != "ActiveMARK");
+
+            // Cactus Data Shield
+            if (foundProtections.Any(p => Regex.IsMatch(p, @"Cactus Data Shield [0-9]{3} .+")) && foundProtections.Any(p => p == "Cactus Data Shield 200"))
+                foundProtections = foundProtections.Where(p => p != "Cactus Data Shield 200");
+
+            // CD-Check
+            foundProtections = foundProtections.Where(p => p != "Executable-Based CD Check");
+
+            // CD-Cops
+            if (foundProtections.Any(p => p == "CD-Cops") && foundProtections.Any(p => p.StartsWith("CD-Cops") && p.Length > "CD-Cops".Length))
+                foundProtections = foundProtections.Where(p => p != "CD-Cops");
+
+            // CD-Key / Serial
+            foundProtections = foundProtections.Where(p => p != "CD-Key / Serial");
+
+            // Electronic Arts
+            if (foundProtections.Any(p => p == "EA CdKey Registration Module") && foundProtections.Any(p => p.StartsWith("EA CdKey Registration Module") && p.Length > "EA CdKey Registration Module".Length))
+                foundProtections = foundProtections.Where(p => p != "EA CdKey Registration Module");
+            if (foundProtections.Any(p => p == "EA DRM Protection") && foundProtections.Any(p => p.StartsWith("EA DRM Protection") && p.Length > "EA DRM Protection".Length))
+                foundProtections = foundProtections.Where(p => p != "EA DRM Protection");
+
+            // Games for Windows LIVE
+            if (foundProtections.Any(p => p == "Games for Windows LIVE") && foundProtections.Any(p => p.StartsWith("Games for Windows LIVE") && !p.Contains("Zero Day Piracy Protection") && p.Length > "Games for Windows LIVE".Length))
+                foundProtections = foundProtections.Where(p => p != "Games for Windows LIVE");
+
+            // Impulse Reactor
+            if (foundProtections.Any(p => p.StartsWith("Impulse Reactor Core Module")) && foundProtections.Any(p => p == "Impulse Reactor"))
+                foundProtections = foundProtections.Where(p => p != "Impulse Reactor");
+
+            // JoWood X-Prot
+            if (foundProtections.Any(p => p.StartsWith("JoWood X-Prot")))
+            {
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"JoWood X-Prot [0-9]\.[0-9]\.[0-9]\.[0-9]{2}")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "JoWood X-Prot")
+                        .Where(p => p != "JoWood X-Prot v1.0-v1.3")
+                        .Where(p => p != "JoWood X-Prot v1.4+")
+                        .Where(p => p != "JoWood X-Prot v2");
+                }
+                else if (foundProtections.Any(p => p == "JoWood X-Prot v2"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "JoWood X-Prot")
+                        .Where(p => p != "JoWood X-Prot v1.0-v1.3")
+                        .Where(p => p != "JoWood X-Prot v1.4+");
+                }
+                else if (foundProtections.Any(p => p == "JoWood X-Prot v1.4+"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "JoWood X-Prot")
+                        .Where(p => p != "JoWood X-Prot v1.0-v1.3");
+                }
+                else if (foundProtections.Any(p => p == "JoWood X-Prot v1.0-v1.3"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "JoWood X-Prot");
+                }
+            }
+
+            // LaserLok
+            // TODO: Figure this one out
+
+            // Online Registration
+            foundProtections = foundProtections.Where(p => !p.StartsWith("Executable-Based Online Registration"));
+
+            // ProtectDISC / VOB ProtectCD/DVD
+            // TODO: Figure this one out
+
+            // SafeCast
+            // TODO: Figure this one out
+
+            // SafeDisc
+            if (foundProtections.Any(p => p.StartsWith("SafeDisc")))
+            {
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc 2")
+                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
+                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
+                        .Where(p => !p.StartsWith("SafeDisc (drvmgt.dll)"))
+                        .Where(p => !p.StartsWith("SafeDisc (secdrv.sys)"))
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (drvmgt.dll)")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc 2")
+                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
+                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
+                        .Where(p => !p.StartsWith("SafeDisc (secdrv.sys)"))
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (secdrv.sys)")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc 2")
+                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
+                        .Where(p => !p.StartsWith("SafeDisc (dplayerx.dll)"))
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p.StartsWith("SafeDisc (dplayerx.dll)")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc 2")
+                        .Where(p => p != "SafeDisc 3.20-4.xx (version removed)")
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 3.20-4.xx (version removed)"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc 2")
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 2"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 1/Lite"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1-3")
+                        .Where(p => p != "SafeDisc Lite");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc Lite"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1-3");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 1-3"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "SafeDisc");
+                }
+            }
+
+            // SecuROM
+            // TODO: Figure this one out
+
+            // SolidShield
+            // TODO: Figure this one out
+
+            // StarForce
+            if (foundProtections.Any(p => p.StartsWith("StarForce")))
+            {
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"StarForce [0-9]+\..+")))
+                {
+                    foundProtections = foundProtections.Where(p => p != "StarForce")
+                        .Where(p => p != "StarForce 3-5")
+                        .Where(p => p != "StarForce 5")
+                        .Where(p => p != "StarForce 5 [Protected Module]");
+                }
+                else if (foundProtections.Any(p => p == "StarForce 5 [Protected Module]"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "StarForce")
+                        .Where(p => p != "StarForce 3-5")
+                        .Where(p => p != "StarForce 5");
+                }
+                else if (foundProtections.Any(p => p == "StarForce 5"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "StarForce")
+                        .Where(p => p != "StarForce 3-5");
+                }
+                else if (foundProtections.Any(p => p == "StarForce 3-5"))
+                {
+                    foundProtections = foundProtections.Where(p => p != "StarForce");
+                }
+            }
+
+            // Sysiphus
+            if (foundProtections.Any(p => p == "Sysiphus") && foundProtections.Any(p => p.StartsWith("Sysiphus") && p.Length > "Sysiphus".Length))
+                foundProtections = foundProtections.Where(p => p != "Sysiphus");
+
+            // TAGES
+            // TODO: Figure this one out
+
+            // XCP
+            if (foundProtections.Any(p => p == "XCP") && foundProtections.Any(p => p.StartsWith("XCP") && p.Length > "XCP".Length))
+                foundProtections = foundProtections.Where(p => p != "XCP");
+
+            return string.Join(", ", foundProtections);
+        }
+    }
+}

MPF.Library/Redump/Extras.cs

@@ -1,229 +0,0 @@
-using MPF.Data;
-
-namespace MPF.Redump
-{
-    /// <summary>
-    /// Information pertaining to Redump systems
-    /// </summary>
-    public static class Extras
-    {
-        #region Special lists
-
-        /// <summary>
-        /// List of systems that are not publically accessible
-        /// </summary>
-        public static readonly RedumpSystem?[] BannedSystems = new RedumpSystem?[]
-        {
-            RedumpSystem.AudioCD,
-            RedumpSystem.BDVideo,
-            RedumpSystem.DVDVideo,
-            RedumpSystem.HasbroVideoNow,
-            RedumpSystem.HasbroVideoNowColor,
-            RedumpSystem.HasbroVideoNowJr,
-            RedumpSystem.HasbroVideoNowXP,
-            RedumpSystem.KonamiM2,
-            RedumpSystem.MicrosoftXbox360,
-            RedumpSystem.MicrosoftXboxOne,
-            //RedumpSystem.MicrosoftXboxSeriesXS,
-            RedumpSystem.NavisoftNaviken21,
-            RedumpSystem.NintendoWii,
-            RedumpSystem.NintendoWiiU,
-            RedumpSystem.PanasonicM2,
-            RedumpSystem.SegaPrologue21,
-            RedumpSystem.SegaRingEdge,
-            RedumpSystem.SegaRingEdge2,
-            RedumpSystem.SonyPlayStation3,
-            RedumpSystem.SonyPlayStation4,
-            //RedumpSystem.SonyPlayStation5,
-            RedumpSystem.VideoCD,
-        };
-
-        /// <summary>
-        /// List of systems that have a Cues pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasCues = new RedumpSystem?[]
-        {
-            RedumpSystem.AppleMacintosh,
-            RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem,
-            RedumpSystem.AudioCD,
-            RedumpSystem.BandaiPippin,
-            RedumpSystem.BandaiPlaydiaQuickInteractiveSystem,
-            RedumpSystem.CommodoreAmigaCD,
-            RedumpSystem.CommodoreAmigaCD32,
-            RedumpSystem.CommodoreAmigaCDTV,
-            RedumpSystem.FujitsuFMTownsseries,
-            RedumpSystem.funworldPhotoPlay,
-            RedumpSystem.HasbroVideoNow,
-            RedumpSystem.HasbroVideoNowColor,
-            RedumpSystem.HasbroVideoNowJr,
-            RedumpSystem.HasbroVideoNowXP,
-            RedumpSystem.IBMPCcompatible,
-            RedumpSystem.IncredibleTechnologiesEagle,
-            RedumpSystem.KonamieAmusement,
-            RedumpSystem.KonamiFireBeat,
-            RedumpSystem.KonamiM2,
-            RedumpSystem.KonamiSystemGV,
-            RedumpSystem.MattelFisherPriceiXL,
-            RedumpSystem.MattelHyperScan,
-            RedumpSystem.MemorexVisualInformationSystem,
-            RedumpSystem.MicrosoftXbox,
-            RedumpSystem.MicrosoftXbox360,
-            RedumpSystem.NamcoSegaNintendoTriforce,
-            RedumpSystem.NamcoSystem246,
-            RedumpSystem.NavisoftNaviken21,
-            RedumpSystem.NECPCEngineCDTurboGrafxCD,
-            RedumpSystem.NECPC88series,
-            RedumpSystem.NECPC98series,
-            RedumpSystem.NECPCFXPCFXGA,
-            RedumpSystem.PalmOS,
-            RedumpSystem.Panasonic3DOInteractiveMultiplayer,
-            RedumpSystem.PanasonicM2,
-            RedumpSystem.PhilipsCDi,
-            RedumpSystem.PhotoCD,
-            RedumpSystem.PlayStationGameSharkUpdates,
-            RedumpSystem.SegaChihiro,
-            RedumpSystem.SegaDreamcast,
-            RedumpSystem.SegaMegaCDSegaCD,
-            RedumpSystem.SegaNaomi,
-            RedumpSystem.SegaNaomi2,
-            RedumpSystem.SegaPrologue21,
-            RedumpSystem.SegaSaturn,
-            RedumpSystem.SNKNeoGeoCD,
-            RedumpSystem.SonyPlayStation,
-            RedumpSystem.SonyPlayStation2,
-            RedumpSystem.SonyPlayStation3,
-            RedumpSystem.TABAustriaQuizard,
-            RedumpSystem.TomyKissSite,
-            RedumpSystem.VideoCD,
-            RedumpSystem.VTechVFlashVSmilePro,
-};
-
-        /// <summary>
-        /// List of systems that has a Dat pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasDat = new RedumpSystem?[]
-        {
-            RedumpSystem.MicrosoftXboxBIOS,
-            RedumpSystem.NintendoGameCubeBIOS,
-            RedumpSystem.SonyPlayStationBIOS,
-            RedumpSystem.SonyPlayStation2BIOS,
-
-            RedumpSystem.AppleMacintosh,
-            RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem,
-            RedumpSystem.AudioCD,
-            RedumpSystem.BandaiPippin,
-            RedumpSystem.BandaiPlaydiaQuickInteractiveSystem,
-            RedumpSystem.BDVideo,
-            RedumpSystem.CommodoreAmigaCD,
-            RedumpSystem.CommodoreAmigaCD32,
-            RedumpSystem.CommodoreAmigaCDTV,
-            RedumpSystem.DVDVideo,
-            RedumpSystem.FujitsuFMTownsseries,
-            RedumpSystem.funworldPhotoPlay,
-            RedumpSystem.HasbroVideoNow,
-            RedumpSystem.HasbroVideoNowColor,
-            RedumpSystem.HasbroVideoNowJr,
-            RedumpSystem.HasbroVideoNowXP,
-            RedumpSystem.IBMPCcompatible,
-            RedumpSystem.IncredibleTechnologiesEagle,
-            RedumpSystem.KonamieAmusement,
-            RedumpSystem.KonamiFireBeat,
-            RedumpSystem.KonamiM2,
-            RedumpSystem.KonamiSystemGV,
-            RedumpSystem.MattelFisherPriceiXL,
-            RedumpSystem.MattelHyperScan,
-            RedumpSystem.MemorexVisualInformationSystem,
-            RedumpSystem.MicrosoftXbox,
-            RedumpSystem.MicrosoftXbox360,
-            RedumpSystem.MicrosoftXboxOne,
-            //RedumpSystem.MicrosoftXboxSeriesXS,
-            RedumpSystem.NamcoSegaNintendoTriforce,
-            RedumpSystem.NamcoSystem246,
-            RedumpSystem.NavisoftNaviken21,
-            RedumpSystem.NECPCEngineCDTurboGrafxCD,
-            RedumpSystem.NECPC88series,
-            RedumpSystem.NECPC98series,
-            RedumpSystem.NECPCFXPCFXGA,
-            RedumpSystem.NintendoGameCube,
-            RedumpSystem.NintendoWii,
-            RedumpSystem.NintendoWiiU,
-            RedumpSystem.PalmOS,
-            RedumpSystem.Panasonic3DOInteractiveMultiplayer,
-            RedumpSystem.PanasonicM2,
-            RedumpSystem.PhilipsCDi,
-            RedumpSystem.PhotoCD,
-            RedumpSystem.PlayStationGameSharkUpdates,
-            RedumpSystem.SegaChihiro,
-            RedumpSystem.SegaDreamcast,
-            RedumpSystem.SegaLindbergh,
-            RedumpSystem.SegaMegaCDSegaCD,
-            RedumpSystem.SegaNaomi,
-            RedumpSystem.SegaNaomi2,
-            RedumpSystem.SegaRingEdge,
-            RedumpSystem.SegaRingEdge2,
-            RedumpSystem.SegaSaturn,
-            RedumpSystem.SNKNeoGeoCD,
-            RedumpSystem.SonyPlayStation,
-            RedumpSystem.SonyPlayStation2,
-            RedumpSystem.SonyPlayStation3,
-            RedumpSystem.SonyPlayStation4,
-            //RedumpSystem.SonyPlayStation5,
-            RedumpSystem.SonyPlayStationPortable,
-            RedumpSystem.TABAustriaQuizard,
-            RedumpSystem.TomyKissSite,
-            RedumpSystem.VideoCD,
-            RedumpSystem.VMLabsNUON,
-            RedumpSystem.VTechVFlashVSmilePro,
-            RedumpSystem.ZAPiTGamesGameWaveFamilyEntertainmentSystem,
-        };
-
-        /// <summary>
-        /// List of systems that has a Decrypted Keys pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasDkeys = new RedumpSystem?[]
-        {
-            RedumpSystem.SonyPlayStation3,
-        };
-
-        /// <summary>
-        /// List of systems that has a GDI pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasGdi = new RedumpSystem?[]
-        {
-            RedumpSystem.NamcoSegaNintendoTriforce,
-            RedumpSystem.SegaChihiro,
-            RedumpSystem.SegaDreamcast,
-            RedumpSystem.SegaNaomi,
-            RedumpSystem.SegaNaomi2,
-        };
-
-        /// <summary>
-        /// List of systems that has a Keys pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasKeys = new RedumpSystem?[]
-        {
-            RedumpSystem.NintendoWiiU,
-            RedumpSystem.SonyPlayStation3,
-        };
-
-        /// <summary>
-        /// List of systems that has an LSD pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasLsd = new RedumpSystem?[]
-        {
-            RedumpSystem.IBMPCcompatible,
-            RedumpSystem.SonyPlayStation,
-        };
-
-        /// <summary>
-        /// List of systems that has an SBI pack
-        /// </summary>
-        public static readonly RedumpSystem?[] HasSbi = new RedumpSystem?[]
-        {
-            RedumpSystem.IBMPCcompatible,
-            RedumpSystem.SonyPlayStation,
-        };
-
-        #endregion
-    }
-}

MPF.Library/Utilities/EnumExtensions.cs

@@ -1,119 +0,0 @@
-using MPF.Data;
-
-namespace MPF.Utilities
-{
-    public static class EnumExtensions
-    {
-        /// <summary>
-        /// Determine the category based on the system
-        /// </summary>
-        /// <param name="system">KnownSystem value to check</param>
-        /// <returns>KnownSystemCategory related to the system</returns>
-        public static KnownSystemCategory Category(this KnownSystem? system)
-        {
-            if (system < KnownSystem.MarkerDiscBasedConsoleEnd)
-                return KnownSystemCategory.DiscBasedConsole;
-            /*
-            else if (system < KnownSystem.MarkerOtherConsoleEnd)
-                return KnownSystemCategory.OtherConsole;
-            */
-            else if (system < KnownSystem.MarkerComputerEnd)
-                return KnownSystemCategory.Computer;
-            else if (system < KnownSystem.MarkerArcadeEnd)
-                return KnownSystemCategory.Arcade;
-            else if (system < KnownSystem.MarkerOtherEnd)
-                return KnownSystemCategory.Other;
-            else
-                return KnownSystemCategory.Custom;
-        }
-
-        /// <summary>
-        /// Determine if the media supports drive speeds
-        /// </summary>
-        /// <param name="type">MediaType value to check</param>
-        /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
-        public static bool DoesSupportDriveSpeed(this MediaType? type)
-        {
-            switch (type)
-            {
-                case MediaType.CDROM:
-                case MediaType.DVD:
-                case MediaType.GDROM:
-                case MediaType.HDDVD:
-                case MediaType.BluRay:
-                case MediaType.NintendoGameCubeGameDisc:
-                case MediaType.NintendoWiiOpticalDisc:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-        /// <summary>
-        /// Determine if a system is considered audio-only
-        /// </summary>
-        /// <param name="system">KnownSystem value to check</param>
-        /// <returns>True if the system is audio-only, false otherwise</returns>
-        /// <remarks>
-        /// Philips CD-i should NOT be in this list. It's being included until there's a
-        /// reasonable distinction between CD-i and CD-i ready on the database side.
-        /// </remarks>
-        public static bool IsAudio(this KnownSystem? system)
-        {
-            switch (system)
-            {
-                case KnownSystem.AtariJaguarCD:
-                case KnownSystem.AudioCD:
-                case KnownSystem.DVDAudio:
-                case KnownSystem.HasbroVideoNow:
-                case KnownSystem.HasbroVideoNowColor:
-                case KnownSystem.HasbroVideoNowJr:
-                case KnownSystem.HasbroVideoNowXP:
-                case KnownSystem.PhilipsCDi:
-                case KnownSystem.SuperAudioCD:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-
-        /// <summary>
-        /// Determine if a system is a marker value
-        /// </summary>
-        /// <param name="system">KnownSystem value to check</param>
-        /// <returns>True if the system is a marker value, false otherwise</returns>
-        public static bool IsMarker(this KnownSystem? system)
-        {
-            switch (system)
-            {
-                case KnownSystem.MarkerArcadeEnd:
-                case KnownSystem.MarkerComputerEnd:
-                case KnownSystem.MarkerDiscBasedConsoleEnd:
-                // case KnownSystem.MarkerOtherConsoleEnd:
-                case KnownSystem.MarkerOtherEnd:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-       
-        /// <summary>
-        /// Determine if a system is considered XGD
-        /// </summary>
-        /// <param name="system">KnownSystem value to check</param>
-        /// <returns>True if the system is XGD, false otherwise</returns>
-        public static bool IsXGD(this KnownSystem? system)
-        {
-            switch (system)
-            {
-                case KnownSystem.MicrosoftXBOX:
-                case KnownSystem.MicrosoftXBOX360:
-                case KnownSystem.MicrosoftXBOXOne:
-                case KnownSystem.MicrosoftXboxSeriesXS:
-                    return true;
-                default:
-                    return false;
-            }
-        }
-    }
-}

MPF.Modules/Aaru/Constants.cs

@@ -1,10 +1,17 @@
-namespace MPF.Aaru
+namespace MPF.Modules.Aaru
 {
     /// <summary>
     /// Top-level commands for Aaru
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
+
+        // Archive Family
+        public const string ArchivePrefixShort = "arc";
+        public const string ArchivePrefixLong = "archive";
+        public const string ArchiveInfo = "info";
+
         // Database Family
         public const string DatabasePrefixShort = "db";
         public const string DatabasePrefixLong = "database";
@@ -23,6 +30,7 @@ namespace MPF.Aaru
         public const string FilesystemPrefixShortAlt = "fs";
         public const string FilesystemPrefixLong = "filesystem";
         public const string FilesystemExtract = "extract";
+        public const string FilesystemInfo = "info";
         public const string FilesystemListShort = "ls";
         public const string FilesystemListLong = "list";
         public const string FilesystemOptions = "options";
@@ -30,7 +38,6 @@ namespace MPF.Aaru
         // Image Family
         public const string ImagePrefixShort = "i";
         public const string ImagePrefixLong = "image";
-        public const string ImageAnalyze = "analyze";
         public const string ImageChecksumShort = "chk";
         public const string ImageChecksumLong = "checksum";
         public const string ImageCompareShort = "cmp";
@@ -147,6 +154,7 @@ namespace MPF.Aaru
         public const string MetadataLong = "--metadata";
         public const string PartitionsShort = "-p";
         public const string PartitionsLong = "--partitions";
+        public const string PauseLong = "--pause";
         public const string PersistentLong = "--persistent";
         public const string PrivateLong = "--private";
         public const string ResumeShort = "-r";
@@ -166,9 +174,14 @@ namespace MPF.Aaru
         public const string SpamSumLong = "--spamsum";
         public const string StopOnErrorShort = "-s";
         public const string StopOnErrorLong = "--stop-on-error";
+        public const string StoreEncryptedLong = "--store-encrypted";
         public const string TapeShort = "-t";
         public const string TapeLong = "--tape";
+        public const string TitleKeysLong = "--title-keys";
+        public const string TrapDiscShort = "-t";
+        public const string TrapDiscLong = "--trap-disc";
         public const string TrimLong = "--trim";
+        public const string UseBufferedReadsLong = "--use-buffered-reads";
         public const string VerboseShort = "-v";
         public const string VerboseLong = "--verbose";
         public const string VerifyDiscShort = "-w";
@@ -193,6 +206,7 @@ namespace MPF.Aaru
         public const string BlockSizeLong = "--block-size";
         public const string CountShort = "-c";
         public const string CountLong = "--count";
+        public const string MaxBlocksLong = "--max-blocks";
         public const string MediaLastSequenceLong = "--media-lastsequence";
         public const string MediaSequenceLong = "--media-sequence";
         public const string SkipShort = "-k";
@@ -217,6 +231,8 @@ namespace MPF.Aaru
         public const string FormatConvertLong = "--format";
         public const string FormatDumpShort = "-t";
         public const string FormatDumpLong = "--format";
+        public const string GeometryShort = "-g";
+        public const string GeometryLong = "--geometry";
         public const string ImgBurnLogShort = "-b";
         public const string ImgBurnLogLong = "--ibg-log";
         public const string MediaBarcodeLong = "--media-barcode";

MPF.Modules/Aaru/Converters.cs

@@ -0,0 +1,22 @@
+using RedumpLib.Data;
+
+namespace MPF.Modules.Aaru
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string Extension(MediaType? type)
+        {
+            // Aaru has a single, unified output format by default
+            return ".aaruf";
+        }
+
+        #endregion
+    }
+}

MPF.Modules/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System.Runtime.CompilerServices;
+
+// Anything marked as internal can be used by the test methods
+[assembly: InternalsVisibleTo("MPF.Test")]

MPF.Modules/CleanRIp/Parameters.cs

@@ -2,10 +2,10 @@
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
-using MPF.Data;
-using MPF.Utilities;
+using MPF.Core.Data;
+using RedumpLib.Data;
 
-namespace MPF.CleanRip
+namespace MPF.Modules.CleanRip
 {
     /// <summary>
     /// Represents a generic set of CleanRip parameters
@@ -23,7 +23,7 @@ namespace MPF.CleanRip
         public Parameters(string parameters) : base(parameters) { }
 
         /// <inheritdoc/>
-        public Parameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
+        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
             : base(system, type, driveLetter, filename, driveSpeed, options)
         {
         }
@@ -31,7 +31,7 @@ namespace MPF.CleanRip
         #region BaseParameters Implementations
 
         /// <inheritdoc/>
-        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath)
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
         {
             List<string> missingFiles = new List<string>();
             switch (this.Type)
@@ -39,15 +39,19 @@ namespace MPF.CleanRip
                 case MediaType.DVD: // Only added here to help users; not strictly correct
                 case MediaType.NintendoGameCubeGameDisc:
                 case MediaType.NintendoWiiOpticalDisc:
-                    if (!File.Exists($"{basePath}-dumpinfo.txt"))
-                        missingFiles.Add($"{basePath}-dumpinfo.txt");
-                    if (!File.Exists($"{basePath}.bca"))
-                        missingFiles.Add($"{basePath}.bca");
+                    if (!File.Exists($"{basePath}_logs.zip") || !preCheck)
+                    {
+                        if (!File.Exists($"{basePath}-dumpinfo.txt"))
+                            missingFiles.Add($"{basePath}-dumpinfo.txt");
+                        if (!File.Exists($"{basePath}.bca"))
+                            missingFiles.Add($"{basePath}.bca");
+                    }
 
                     break;
 
                 default:
-                    return (false, missingFiles);
+                    missingFiles.Add("Media and system combination not supported for CleanRip");
+                    break;
             }
 
             return (!missingFiles.Any(), missingFiles);
@@ -80,7 +84,7 @@ namespace MPF.CleanRip
                     if (File.Exists(basePath + ".bca"))
                         info.Extras.BCA = GetBCA(basePath + ".bca");
 
-                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out RedumpRegion? gcRegion, out string gcVersion))
+                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out Region? gcRegion, out string gcVersion))
                     {
                         info.CommonDiscInfo.Region = gcRegion ?? info.CommonDiscInfo.Region;
                         info.VersionAndEditions.Version = gcVersion ?? info.VersionAndEditions.Version;
@@ -201,7 +205,7 @@ namespace MPF.CleanRip
         /// <param name="region">Output region, if possible</param>
         /// <param name="version">Output internal version of the game</param>
         /// <returns></returns>
-        private static bool GetGameCubeWiiInformation(string dumpinfo, out RedumpRegion? region, out string version)
+        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string version)
         {
             region = null; version = null;
 
@@ -236,49 +240,49 @@ namespace MPF.CleanRip
                             switch (serial[3])
                             {
                                 case 'A':
-                                    region = RedumpRegion.World;
+                                    region = Region.World;
                                     break;
                                 case 'D':
-                                    region = RedumpRegion.Germany;
+                                    region = Region.Germany;
                                     break;
                                 case 'E':
-                                    region = RedumpRegion.USA;
+                                    region = Region.UnitedStatesOfAmerica;
                                     break;
                                 case 'F':
-                                    region = RedumpRegion.France;
+                                    region = Region.France;
                                     break;
                                 case 'I':
-                                    region = RedumpRegion.Italy;
+                                    region = Region.Italy;
                                     break;
                                 case 'J':
-                                    region = RedumpRegion.Japan;
+                                    region = Region.Japan;
                                     break;
                                 case 'K':
-                                    region = RedumpRegion.Korea;
+                                    region = Region.SouthKorea;
                                     break;
                                 case 'L':
-                                    region = RedumpRegion.Europe; // Japanese import to Europe
+                                    region = Region.Europe; // Japanese import to Europe
                                     break;
                                 case 'M':
-                                    region = RedumpRegion.Europe; // American import to Europe
+                                    region = Region.Europe; // American import to Europe
                                     break;
                                 case 'N':
-                                    region = RedumpRegion.USA; // Japanese import to USA
+                                    region = Region.UnitedStatesOfAmerica; // Japanese import to USA
                                     break;
                                 case 'P':
-                                    region = RedumpRegion.Europe;
+                                    region = Region.Europe;
                                     break;
                                 case 'R':
-                                    region = RedumpRegion.Russia;
+                                    region = Region.RussianFederation;
                                     break;
                                 case 'S':
-                                    region = RedumpRegion.Spain;
+                                    region = Region.Spain;
                                     break;
                                 case 'Q':
-                                    region = RedumpRegion.Korea; // Korea with Japanese language
+                                    region = Region.SouthKorea; // Korea with Japanese language
                                     break;
                                 case 'T':
-                                    region = RedumpRegion.Korea; // Korea with English language
+                                    region = Region.SouthKorea; // Korea with English language
                                     break;
                                 case 'X':
                                     region = null; // Not a real region code

MPF.Modules/DD/Constants.cs

@@ -1,10 +1,11 @@
-namespace MPF.DD
+namespace MPF.Modules.DD
 {
     /// <summary>
     /// Top-level commands for DD
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
         public const string List = "--list";
     }
 

MPF.Modules/DD/Converters.cs

@@ -0,0 +1,22 @@
+using RedumpLib.Data;
+
+namespace MPF.Modules.DD
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string Extension(MediaType? type)
+        {
+            // DD has a single, unified output format by default
+            return ".bin";
+        }
+
+        #endregion
+    }
+}

MPF.Modules/DD/Parameters.cs

@@ -0,0 +1,404 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using MPF.Core.Data;
+using RedumpLib.Data;
+
+namespace MPF.Modules.DD
+{
+    /// <summary>
+    /// Represents a generic set of DD parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Generic Dumping Information
+
+        /// <inheritdoc/>
+        public override string InputPath => InputFileValue?.TrimStart('\\', '?');
+
+        /// <inheritdoc/>
+        public override string OutputPath => OutputFileValue;
+
+        /// <inheritdoc/>
+        /// <inheritdoc/>
+        public override int? Speed
+        {
+            get { return 1; }
+            set { }
+        }
+
+        #endregion
+
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.DD;
+
+        #endregion
+
+        #region Flag Values
+
+        public long? BlockSizeValue { get; set; }
+
+        public long? CountValue { get; set; }
+
+        // fixed, removable, disk, partition
+        public string FilterValue { get; set; }
+
+        public string InputFileValue { get; set; }
+
+        public string OutputFileValue { get; set; }
+
+        public long? SeekValue { get; set; }
+
+        public long? SkipValue { get; set; }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public Parameters(string parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
+            : base(system, type, driveLetter, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            // TODO: Figure out what sort of output files are expected... just `.bin`?
+            return (true, new List<string>());
+        }
+
+        /// <inheritdoc/>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, Drive drive, bool includeArtifacts)
+        {
+            // TODO: Fill in submission info specifics for DD
+            string outputDirectory = Path.GetDirectoryName(basePath);
+
+            switch (this.Type)
+            {
+                // Determine type-specific differences
+            }
+
+            switch (this.System)
+            {
+                case RedumpSystem.KonamiPython2:
+                    if (GetPlayStationExecutableInfo(drive?.Letter, out string pythonTwoSerial, out Region? pythonTwoRegion, out string pythonTwoDate))
+                    {
+                        // Ensure internal serial is pulled from local data
+                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = pythonTwoSerial ?? string.Empty;
+                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? pythonTwoRegion;
+                        info.CommonDiscInfo.EXEDateBuildDate = pythonTwoDate;
+                    }
+
+                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
+                    break;
+
+                case RedumpSystem.SonyPlayStation:
+                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationSerial, out Region? playstationRegion, out string playstationDate))
+                    {
+                        // Ensure internal serial is pulled from local data
+                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = playstationSerial ?? string.Empty;
+                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationRegion;
+                        info.CommonDiscInfo.EXEDateBuildDate = playstationDate;
+                    }
+
+                    break;
+
+                case RedumpSystem.SonyPlayStation2:
+                    if (GetPlayStationExecutableInfo(drive?.Letter, out string playstationTwoSerial, out Region? playstationTwoRegion, out string playstationTwoDate))
+                    {
+                        // Ensure internal serial is pulled from local data
+                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalSerialName] = playstationTwoSerial ?? string.Empty;
+                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? playstationTwoRegion;
+                        info.CommonDiscInfo.EXEDateBuildDate = playstationTwoDate;
+                    }
+
+                    info.VersionAndEditions.Version = GetPlayStation2Version(drive?.Letter) ?? "";
+                    break;
+
+                case RedumpSystem.SonyPlayStation4:
+                    info.VersionAndEditions.Version = GetPlayStation4Version(drive?.Letter) ?? "";
+                    break;
+
+                case RedumpSystem.SonyPlayStation5:
+                    info.VersionAndEditions.Version = GetPlayStation5Version(drive?.Letter) ?? "";
+                    break;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string GenerateParameters()
+        {
+            List<string> parameters = new List<string>();
+
+            if (BaseCommand == null)
+                BaseCommand = CommandStrings.NONE;
+
+            if (!string.IsNullOrEmpty(BaseCommand))
+                parameters.Add(BaseCommand);
+
+            #region Boolean flags
+
+            // Progress
+            if (IsFlagSupported(FlagStrings.Progress))
+            {
+                if (this[FlagStrings.Progress] == true)
+                    parameters.Add($"{FlagStrings.Progress}");
+            }
+
+            // Size
+            if (IsFlagSupported(FlagStrings.Size))
+            {
+                if (this[FlagStrings.Size] == true)
+                    parameters.Add($"{FlagStrings.Size}");
+            }
+
+            #endregion
+
+            #region Int64 flags
+
+            // Block Size
+            if (IsFlagSupported(FlagStrings.BlockSize))
+            {
+                if (this[FlagStrings.BlockSize] == true && BlockSizeValue != null)
+                    parameters.Add($"{FlagStrings.BlockSize}={BlockSizeValue}");
+            }
+
+            // Count
+            if (IsFlagSupported(FlagStrings.Count))
+            {
+                if (this[FlagStrings.Count] == true && CountValue != null)
+                    parameters.Add($"{FlagStrings.Count}={CountValue}");
+            }
+
+            // Seek
+            if (IsFlagSupported(FlagStrings.Seek))
+            {
+                if (this[FlagStrings.Seek] == true && SeekValue != null)
+                    parameters.Add($"{FlagStrings.Seek}={SeekValue}");
+            }
+
+            // Skip
+            if (IsFlagSupported(FlagStrings.Skip))
+            {
+                if (this[FlagStrings.Skip] == true && SkipValue != null)
+                    parameters.Add($"{FlagStrings.Skip}={SkipValue}");
+            }
+
+            #endregion
+
+            #region String flags
+
+            // Filter
+            if (IsFlagSupported(FlagStrings.Filter))
+            {
+                if (this[FlagStrings.Filter] == true && FilterValue != null)
+                    parameters.Add($"{FlagStrings.Filter}={FilterValue}");
+            }
+
+            // Input File
+            if (IsFlagSupported(FlagStrings.InputFile))
+            {
+                if (this[FlagStrings.InputFile] == true && InputFileValue != null)
+                    parameters.Add($"{FlagStrings.InputFile}=\"{InputFileValue}\"");
+                else
+                    return null;
+            }
+
+            // Output File
+            if (IsFlagSupported(FlagStrings.OutputFile))
+            {
+                if (this[FlagStrings.OutputFile] == true && OutputFileValue != null)
+                    parameters.Add($"{FlagStrings.OutputFile}=\"{OutputFileValue}\"");
+                else
+                    return null;
+            }
+
+            #endregion
+
+            return string.Join(" ", parameters);
+        }
+
+        /// <inheritdoc/>
+        public override Dictionary<string, List<string>> GetCommandSupport()
+        {
+            return new Dictionary<string, List<string>>()
+            {
+                [CommandStrings.NONE] = new List<string>()
+                {
+                    FlagStrings.BlockSize,
+                    FlagStrings.Count,
+                    FlagStrings.Filter,
+                    FlagStrings.InputFile,
+                    FlagStrings.OutputFile,
+                    FlagStrings.Progress,
+                    FlagStrings.Seek,
+                    FlagStrings.Size,
+                    FlagStrings.Skip,
+                },
+
+                [CommandStrings.List] = new List<string>()
+                {
+                },
+            };
+        }
+
+        /// <inheritdoc/>
+        public override string GetDefaultExtension(MediaType? mediaType) => Converters.Extension(mediaType);
+
+        /// <inheritdoc/>
+        public override bool IsDumpingCommand()
+        {
+            switch (this.BaseCommand)
+            {
+                case CommandStrings.List:
+                    return false;
+                default:
+                    return true;
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override void ResetValues()
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            flags = new Dictionary<string, bool?>();
+
+            BlockSizeValue = null;
+            CountValue = null;
+            InputFileValue = null;
+            OutputFileValue = null;
+            SeekValue = null;
+            SkipValue = null;
+        }
+
+        /// <inheritdoc/>
+        protected override void SetDefaultParameters(char driveLetter, string filename, int? driveSpeed, Options options)
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            this[FlagStrings.InputFile] = true;
+            InputFileValue = $"\\\\?\\{driveLetter}:";
+
+            this[FlagStrings.OutputFile] = true;
+            OutputFileValue = filename;
+
+            // TODO: Add more common block sizes
+            this[FlagStrings.BlockSize] = true;
+            switch (this.Type)
+            {
+                case MediaType.FloppyDisk:
+                    BlockSizeValue = 1440 * 1024;
+                    break;
+
+                default:
+                    BlockSizeValue = 1024 * 1024 * 1024;
+                    break;
+            }
+
+            this[FlagStrings.Progress] = true;
+            this[FlagStrings.Size] = true;
+        }
+
+        /// <inheritdoc/>
+        protected override bool ValidateAndSetParameters(string parameters)
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            // The string has to be valid by itself first
+            if (string.IsNullOrWhiteSpace(parameters))
+                return false;
+
+            // Now split the string into parts for easier validation
+            // https://stackoverflow.com/questions/14655023/split-a-string-that-has-white-spaces-unless-they-are-enclosed-within-quotes
+            parameters = parameters.Trim();
+            List<string> parts = Regex.Matches(parameters, @"[\""].+?[\""]|[^ ]+")
+                .Cast<Match>()
+                .Select(m => m.Value)
+                .ToList();
+
+            // Determine what the commandline should look like given the first item
+            int start = 0;
+            if (parts[0] == CommandStrings.List)
+            {
+                BaseCommand = parts[0];
+                start = 1;
+            }
+
+            // Loop through all auxilary flags, if necessary
+            for (int i = start; i < parts.Count; i++)
+            {
+                // Flag read-out values
+                long? longValue = null;
+                string stringValue = null;
+
+                // Keep a count of keys to determine if we should break out to filename handling or not
+                int keyCount = Keys.Count();
+
+                #region Boolean flags
+
+                // Progress
+                ProcessFlagParameter(parts, FlagStrings.Progress, ref i);
+
+                // Size
+                ProcessFlagParameter(parts, FlagStrings.Size, ref i);
+
+                #endregion
+
+                #region Int64 flags
+
+                // Block Size
+                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, ref i);
+                if (longValue != null)
+                    BlockSizeValue = longValue;
+
+                // Count
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, ref i);
+                if (longValue != null)
+                    CountValue = longValue;
+
+                // Seek
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, ref i);
+                if (longValue != null)
+                    SeekValue = longValue;
+
+                // Skip
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, ref i);
+                if (longValue != null)
+                    SkipValue = longValue;
+
+                #endregion
+
+                #region String flags
+
+                // Filter (fixed, removable, disk, partition)
+                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    FilterValue = stringValue;
+
+                // Input File
+                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    InputFileValue = stringValue;
+
+                // Output File
+                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    OutputFileValue = stringValue;
+
+                #endregion
+            }
+
+            return true;
+        }
+
+        #endregion
+    }
+}

MPF.Modules/DiscImageCreator/Constants.cs

@@ -1,10 +1,11 @@
-namespace MPF.DiscImageCreator
+namespace MPF.Modules.DiscImageCreator
 {
     /// <summary>
     /// Top-level commands for DiscImageCreator
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
         public const string Audio = "audio";
         public const string BluRay = "bd";
         public const string Close = "close";

MPF.Modules/DiscImageCreator/Converters.cs

@@ -0,0 +1,124 @@
+using RedumpLib.Data;
+
+namespace MPF.Modules.DiscImageCreator
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the most common known system for a given MediaType
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>RedumpSystem if possible, null on error</returns>
+        public static RedumpSystem? ToRedumpSystem(string baseCommand)
+        {
+            switch (baseCommand)
+            {
+                case CommandStrings.Audio:
+                    return RedumpSystem.AudioCD;
+                case CommandStrings.CompactDisc:
+                case CommandStrings.Data:
+                case CommandStrings.DigitalVideoDisc:
+                case CommandStrings.Disk:
+                case CommandStrings.Floppy:
+                case CommandStrings.Tape:
+                    return RedumpSystem.IBMPCcompatible;
+                case CommandStrings.GDROM:
+                case CommandStrings.Swap:
+                    return RedumpSystem.SegaDreamcast;
+                case CommandStrings.BluRay:
+                    return RedumpSystem.SonyPlayStation3;
+                case CommandStrings.SACD:
+                    return RedumpSystem.SuperAudioCD;
+                case CommandStrings.XBOX:
+                case CommandStrings.XBOXSwap:
+                    return RedumpSystem.MicrosoftXbox;
+                case CommandStrings.XGD2Swap:
+                case CommandStrings.XGD3Swap:
+                    return RedumpSystem.MicrosoftXbox360;
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the MediaType associated with a given base command
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>MediaType if possible, null on error</returns>
+        /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
+        public static MediaType? ToMediaType(string baseCommand)
+        {
+            switch (baseCommand)
+            {
+                case CommandStrings.Audio:
+                case CommandStrings.CompactDisc:
+                case CommandStrings.Data:
+                case CommandStrings.SACD:
+                    return MediaType.CDROM;
+                case CommandStrings.GDROM:
+                case CommandStrings.Swap:
+                    return MediaType.GDROM;
+                case CommandStrings.DigitalVideoDisc:
+                case CommandStrings.XBOX:
+                case CommandStrings.XBOXSwap:
+                case CommandStrings.XGD2Swap:
+                case CommandStrings.XGD3Swap:
+                    return MediaType.DVD;
+                case CommandStrings.BluRay:
+                    return MediaType.BluRay;
+
+                // Non-optical
+                case CommandStrings.Floppy:
+                    return MediaType.FloppyDisk;
+                case CommandStrings.Disk:
+                    return MediaType.HardDisk;
+                case CommandStrings.Tape:
+                    return MediaType.DataCartridge;
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string Extension(MediaType? type)
+        {
+            switch (type)
+            {
+                case MediaType.CDROM:
+                case MediaType.GDROM:
+                case MediaType.Cartridge:
+                case MediaType.HardDisk:
+                case MediaType.CompactFlash:
+                case MediaType.MMC:
+                case MediaType.SDCard:
+                case MediaType.FlashDrive:
+                    return ".bin";
+                case MediaType.DVD:
+                case MediaType.HDDVD:
+                case MediaType.BluRay:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return ".iso";
+                case MediaType.LaserDisc:
+                case MediaType.NintendoGameCubeGameDisc:
+                    return ".raw";
+                case MediaType.NintendoWiiUOpticalDisc:
+                    return ".wud";
+                case MediaType.FloppyDisk:
+                    return ".img";
+                case MediaType.Cassette:
+                    return ".wav";
+                case MediaType.NONE:
+                default:
+                    return null;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Modules/MPF.Modules.csproj

@@ -0,0 +1,46 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2021</Copyright>
+    <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+    <Version>2.3</Version>
+    <AssemblyVersion>$(Version)</AssemblyVersion>
+    <FileVersion>$(Version)</FileVersion>
+    <IncludeSource>true</IncludeSource>
+    <IncludeSymbols>true</IncludeSymbols>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NrtRevisionFormat>$(Version)-{chash:8}</NrtRevisionFormat>
+    <NrtResolveSimpleAttributes>true</NrtResolveSimpleAttributes>
+    <NrtShowRevision>false</NrtShowRevision>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
+    <DefineConstants>NET_FRAMEWORK</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+    <ProjectReference Include="..\MPF.CueSheets\MPF.CueSheets.csproj" />
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
+    <ProjectReference Include="..\CICMMetadata\CICMMetadataEditor\CICMMetadataEditor\CICMMetadataEditor.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Memory" Version="4.5.4" />
+    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+
+</Project>

MPF.Modules/UmdImageCreator/Parameters.cs

@@ -2,10 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using MPF.Data;
-using MPF.Utilities;
+using MPF.Core.Data;
+using RedumpLib.Data;
 
-namespace MPF.UmdImageCreator
+namespace MPF.Modules.UmdImageCreator
 {
     /// <summary>
     /// Represents a generic set of UmdImageCreator parameters
@@ -23,7 +23,7 @@ namespace MPF.UmdImageCreator
         public Parameters(string parameters) : base(parameters) { }
 
         /// <inheritdoc/>
-        public Parameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
+        public Parameters(RedumpSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, Options options)
             : base(system, type, driveLetter, filename, driveSpeed, options)
         {
         }
@@ -31,25 +31,29 @@ namespace MPF.UmdImageCreator
         #region BaseParameters Implementations
 
         /// <inheritdoc/>
-        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath)
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
         {
             List<string> missingFiles = new List<string>();
             switch (this.Type)
             {
                 case MediaType.UMD:
-                    if (!File.Exists($"{basePath}_disc.txt"))
-                        missingFiles.Add($"{basePath}_disc.txt");
-                    if (!File.Exists($"{basePath}_mainError.txt"))
-                        missingFiles.Add($"{basePath}_mainError.txt");
-                    if (!File.Exists($"{basePath}_mainInfo.txt"))
-                        missingFiles.Add($"{basePath}_mainInfo.txt");
-                    if (!File.Exists($"{basePath}_volDesc.txt"))
-                        missingFiles.Add($"{basePath}_volDesc.txt");
+                    if (!File.Exists($"{basePath}_logs.zip") || !preCheck)
+                    {
+                        if (!File.Exists($"{basePath}_disc.txt"))
+                            missingFiles.Add($"{basePath}_disc.txt");
+                        if (!File.Exists($"{basePath}_mainError.txt"))
+                            missingFiles.Add($"{basePath}_mainError.txt");
+                        if (!File.Exists($"{basePath}_mainInfo.txt"))
+                            missingFiles.Add($"{basePath}_mainInfo.txt");
+                        if (!File.Exists($"{basePath}_volDesc.txt"))
+                            missingFiles.Add($"{basePath}_volDesc.txt");
+                    }
 
                     break;
 
                 default:
-                    return (false, missingFiles);
+                    missingFiles.Add("Media and system combination not supported for UmdImageCreator");
+                    break;
             }
 
             return (!missingFiles.Any(), missingFiles);
@@ -72,10 +76,10 @@ namespace MPF.UmdImageCreator
                         info.SizeAndChecksums.SHA1 = sha1;
                     }
 
-                    if (GetUMDAuxInfo(basePath + "_disc.txt", out string title, out RedumpDiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize))
+                    if (GetUMDAuxInfo(basePath + "_disc.txt", out string title, out DiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize))
                     {
                         info.CommonDiscInfo.Title = title ?? "";
-                        info.CommonDiscInfo.Category = umdcat ?? RedumpDiscCategory.Games;
+                        info.CommonDiscInfo.Category = umdcat ?? DiscCategory.Games;
                         info.VersionAndEditions.Version = umdversion ?? "";
                         info.SizeAndChecksums.Size = umdsize;
 
@@ -167,7 +171,7 @@ namespace MPF.UmdImageCreator
         /// </summary>
         /// <param name="disc">_disc.txt file location</param>
         /// <returns>True on successful extraction of info, false otherwise</returns>
-        private static bool GetUMDAuxInfo(string disc, out string title, out RedumpDiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize)
+        private static bool GetUMDAuxInfo(string disc, out string title, out DiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize)
         {
             title = null; umdcat = null; umdversion = null; umdlayer = null; umdsize = -1;
 

MPF.Test/Core/Converters/EnumConverterTests.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+#if NET_FRAMEWORK
+using IMAPI2;
+#endif
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using Xunit;
+
+namespace MPF.Test.Core.Converters
+{
+    public class EnumConverterTests
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// DiscType values that map to InternalDriveType
+        /// </summary>
+        private static readonly DriveType[] _mappableDriveTypes = new DriveType[]
+        {
+            DriveType.CDRom,
+            DriveType.Fixed,
+            DriveType.Removable,
+        };
+
+#if NET_FRAMEWORK
+        /// <summary>
+        /// IMAPI_MEDIA_PHYSICAL_TYPE values that map to MediaType
+        /// </summary>
+        private static readonly IMAPI_MEDIA_PHYSICAL_TYPE[] _mappableImapiTypes = new IMAPI_MEDIA_PHYSICAL_TYPE[]
+        {
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR,
+            IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE,
+        };
+#endif
+
+        /// <summary>
+        /// Check that every supported DriveType maps to an InternalDriveType
+        /// </summary>
+        /// <param name="driveType">DriveType value to check</param>
+        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDriveTypeMappingTestData))]
+        public void ToInternalDriveTypeTest(DriveType driveType, bool expectNull)
+        {
+            var actual = driveType.ToInternalDriveType();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+#if NET_FRAMEWORK
+        /// <summary>
+        /// Check that every supported IMAPI_MEDIA_PHYSICAL_TYPE maps to an MediaType
+        /// </summary>
+        /// <param name="imapiType">IMAPI_MEDIA_PHYSICAL_TYPE value to check</param>
+        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateImapiTypeMappingTestData))]
+        public void IMAPIToMediaTypeTest(IMAPI_MEDIA_PHYSICAL_TYPE imapiType, bool expectNull)
+        {
+            var actual = imapiType.IMAPIToMediaType();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+#endif
+
+        /// <summary>
+        /// Generate a test set of DriveType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DriveType values</returns>
+        public static List<object[]> GenerateDriveTypeMappingTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DriveType driveType in Enum.GetValues(typeof(DriveType)))
+            {
+                if (_mappableDriveTypes.Contains(driveType))
+                    testData.Add(new object[] { driveType, false });
+                else
+                    testData.Add(new object[] { driveType, true });
+            }
+
+            return testData;
+        }
+
+#if NET_FRAMEWORK
+        /// <summary>
+        /// Generate a test set of IMAPI_MEDIA_PHYSICAL_TYPE values
+        /// </summary>
+        /// <returns>MemberData-compatible list of IMAPI_MEDIA_PHYSICAL_TYPE values</returns>
+        public static List<object[]> GenerateImapiTypeMappingTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (IMAPI_MEDIA_PHYSICAL_TYPE imapiType in Enum.GetValues(typeof(IMAPI_MEDIA_PHYSICAL_TYPE)))
+            {
+                if (_mappableImapiTypes.Contains(imapiType))
+                    testData.Add(new object[] { imapiType, false });
+                else
+                    testData.Add(new object[] { imapiType, true });
+            }
+
+            return testData;
+        }
+#endif
+
+        #endregion
+
+        #region Convert to Long Name
+
+        // TODO: Maybe add a test for the generic "GetLongName" method
+
+        /// <summary>
+        /// Check that every InternalProgram has a long name provided
+        /// </summary>
+        /// <param name="internalProgram">InternalProgram value to check</param>
+        [Theory]
+        [MemberData(nameof(GenerateInternalProgramTestData))]
+        public void InternalProgramLongNameTest(InternalProgram? internalProgram)
+        {
+            string actual = internalProgram.LongName();
+            Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of InternalProgram values
+        /// </summary>
+        /// <returns>MemberData-compatible list of InternalProgram values</returns>
+        public static List<object[]> GenerateInternalProgramTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null } };
+            foreach (InternalProgram? internalProgram in Enum.GetValues(typeof(InternalProgram)))
+            {
+                testData.Add(new object[] { internalProgram });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        // TODO: Add from-string tests
+    }
+}

MPF.Test/Core/Data/ResultTests.cs

@@ -0,0 +1,42 @@
+using MPF.Core.Data;
+using Xunit;
+
+namespace MPF.Test.Core.Data
+{
+    public class ResultTests
+    {
+        [Fact]
+        public void EmptySuccessTest()
+        {
+            var actual = Result.Success();
+            Assert.True(actual);
+            Assert.Empty(actual.Message);
+        }
+
+        [Fact]
+        public void CustomMessageSuccessTest()
+        {
+            string message = "Success!";
+            var actual = Result.Success(message);
+            Assert.True(actual);
+            Assert.Equal(message, actual.Message);
+        }
+
+        [Fact]
+        public void EmptyFailureTest()
+        {
+            var actual = Result.Failure();
+            Assert.False(actual);
+            Assert.Empty(actual.Message);
+        }
+
+        [Fact]
+        public void CustomMessageFailureTest()
+        {
+            string message = "Failure!";
+            var actual = Result.Failure(message);
+            Assert.False(actual);
+            Assert.Equal(message, actual.Message);
+        }
+    }
+}

MPF.Test/Core/Data/XgdInfoTests.cs

@@ -0,0 +1,115 @@
+using MPF.Core.Data;
+using Xunit;
+
+namespace MPF.Test.Core.Data
+{
+    public class XgdInfoTests
+    {
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("1234567")]
+        [InlineData("1234567\0")]
+        [InlineData("123456789")]
+        public void UnmatchedStringTests(string invalidString)
+        {
+            XgdInfo xgdInfo = new XgdInfo(invalidString);
+            Assert.False(xgdInfo.Initialized);
+        }
+
+        [Theory]
+        [InlineData("AV00100W", "AV", "001", "00", 'W')]
+        [InlineData("AV00100W\0", "AV", "001", "00", 'W')]
+        public void XGD1ValidTests(string validString, string publisher, string gameId, string version, char regionIdentifier)
+        {
+            XgdInfo xgdInfo = new XgdInfo(validString, validate: true);
+
+            Assert.True(xgdInfo.Initialized);
+            Assert.Equal(publisher, xgdInfo.PublisherIdentifier);
+            Assert.Equal(gameId, xgdInfo.GameID);
+            Assert.Equal(version, xgdInfo.SKU);
+            Assert.Equal(regionIdentifier, xgdInfo.RegionIdentifier);
+        }
+
+        [Theory]
+        // Invalid publisher identifier
+        [InlineData("ZZ000000")]
+        [InlineData("ZZ000000\0")]
+        // Invalid region identifier
+        [InlineData("AV00000Z")]
+        [InlineData("AV00000Z\0")]
+        public void XGD1InvalidTests(string invalidString)
+        {
+            XgdInfo xgdInfo = new XgdInfo(invalidString, validate: true);
+            Assert.False(xgdInfo.Initialized);
+        }
+
+        [Theory]
+        [InlineData("AV200100W0F11", "AV", "001", "00", 'W', "0", 'F', "11", null)]
+        [InlineData("AV200100W0F11\0", "AV", "001", "00", 'W', "0", 'F', "11", null)]
+        [InlineData("AV200100W01F11", "AV", "001", "00", 'W', "01", 'F', "11", null)]
+        [InlineData("AV200100W01F11\0", "AV", "001", "00", 'W', "01", 'F', "11", null)]
+        [InlineData("AV200100W0F11DEADBEEF", "AV", "001", "00", 'W', "0", 'F', "11", "DEADBEEF")]
+        [InlineData("AV200100W0F11DEADBEEF\0", "AV", "001", "00", 'W', "0", 'F', "11", "DEADBEEF")]
+        [InlineData("AV200100W01F11DEADBEEF", "AV", "001", "00", 'W', "01", 'F', "11", "DEADBEEF")]
+        [InlineData("AV200100W01F11DEADBEEF\0", "AV", "001", "00", 'W', "01", 'F', "11", "DEADBEEF")]
+        public void XGD23ValidTests(string validString, string publisher, string gameId, string sku, char regionIdentifier, string baseVersion, char mediaSubtype, string discNumber, string cert)
+        {
+            XgdInfo xgdInfo = new XgdInfo(validString, validate: true);
+
+            Assert.True(xgdInfo.Initialized);
+            Assert.Equal(publisher, xgdInfo.PublisherIdentifier);
+            Assert.Equal('2', xgdInfo.PlatformIdentifier);
+            Assert.Equal(gameId, xgdInfo.GameID);
+            Assert.Equal(sku, xgdInfo.SKU);
+            Assert.Equal(regionIdentifier, xgdInfo.RegionIdentifier);
+            Assert.Equal(baseVersion, xgdInfo.BaseVersion);
+            Assert.Equal(mediaSubtype, xgdInfo.MediaSubtypeIdentifier);
+            Assert.Equal(discNumber, xgdInfo.DiscNumberIdentifier);
+            Assert.Equal(cert, xgdInfo.CertificationSubmissionIdentifier);
+        }
+
+        [Theory]
+        // Invalid publisher identifier
+        [InlineData("ZZ00000000000")]
+        [InlineData("ZZ00000000000\0")]
+        [InlineData("ZZ000000000000")]
+        [InlineData("ZZ000000000000\0")]
+        [InlineData("ZZ0000000000000000000")]
+        [InlineData("ZZ0000000000000000000\0")]
+        [InlineData("ZZ00000000000000000000")]
+        [InlineData("ZZ00000000000000000000\0")]
+        // Invalid platform identifier
+        [InlineData("AV90000000000")]
+        [InlineData("AV90000000000\0")]
+        [InlineData("AV900000000000")]
+        [InlineData("AV900000000000\0")]
+        [InlineData("AV9000000000000000000")]
+        [InlineData("AV9000000000000000000\0")]
+        [InlineData("AV90000000000000000000")]
+        [InlineData("AV90000000000000000000\0")]
+        // Invalid region identifier
+        [InlineData("AV200000Z0000")]
+        [InlineData("AV200000Z0000\0")]
+        [InlineData("AV200000Z00000")]
+        [InlineData("AV200000Z00000\0")]
+        [InlineData("AV200000Z000000000000")]
+        [InlineData("AV200000Z000000000000\0")]
+        [InlineData("AV200000Z0000000000000")]
+        [InlineData("AV200000Z0000000000000\0")]
+        // Invalid media subtype identifier
+        [InlineData("AV200000W0A00")]
+        [InlineData("AV200000W0A00\0")]
+        [InlineData("AV200000W00A00")]
+        [InlineData("AV200000W00A00\0")]
+        [InlineData("AV200000W00A000000000")]
+        [InlineData("AV200000W00A000000000\0")]
+        [InlineData("AV200000W00A0000000000")]
+        [InlineData("AV200000W00A0000000000\0")]
+        public void XGD23InvalidTests(string invalidString)
+        {
+            XgdInfo xgdInfo = new XgdInfo(invalidString, validate: true);
+            Assert.False(xgdInfo.Initialized);
+        }
+    }
+}

MPF.Test/Core/Utilities/EnumExtensionsTests.cs

@@ -0,0 +1,229 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core.Utilities;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.Core.Utilities
+{
+    public class EnumExtensionsTests
+    {
+        /// <summary>
+        /// MediaType values that support drive speeds
+        /// </summary>
+        private static readonly MediaType?[] _supportDriveSpeeds = new MediaType?[]
+        {
+            MediaType.CDROM,
+            MediaType.DVD,
+            MediaType.GDROM,
+            MediaType.HDDVD,
+            MediaType.BluRay,
+            MediaType.NintendoGameCubeGameDisc,
+            MediaType.NintendoWiiOpticalDisc,
+        };
+
+        /// <summary>
+        /// RedumpSystem values that are considered Audio
+        /// </summary>
+        private static readonly RedumpSystem?[] _audioSystems = new RedumpSystem?[]
+        {
+            RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem,
+            RedumpSystem.AudioCD,
+            RedumpSystem.DVDAudio,
+            RedumpSystem.HasbroVideoNow,
+            RedumpSystem.HasbroVideoNowColor,
+            RedumpSystem.HasbroVideoNowJr,
+            RedumpSystem.HasbroVideoNowXP,
+            RedumpSystem.PhilipsCDi,
+            RedumpSystem.SuperAudioCD,
+        };
+
+        /// <summary>
+        /// RedumpSystem values that are considered markers
+        /// </summary>
+        private static readonly RedumpSystem?[] _markerSystems = new RedumpSystem?[]
+        {
+            RedumpSystem.MarkerArcadeEnd,
+            RedumpSystem.MarkerComputerEnd,
+            RedumpSystem.MarkerDiscBasedConsoleEnd,
+            RedumpSystem.MarkerOtherEnd,
+        };
+
+        /// <summary>
+        /// RedumpSystem values that are have reversed ringcodes
+        /// </summary>
+        private static readonly RedumpSystem?[] _reverseRingcodeSystems = new RedumpSystem?[]
+        {
+            RedumpSystem.SonyPlayStation2,
+            RedumpSystem.SonyPlayStation3,
+            RedumpSystem.SonyPlayStation4,
+        };
+
+        /// <summary>
+        /// RedumpSystem values that are considered XGD
+        /// </summary>
+        private static readonly RedumpSystem?[] _xgdSystems = new RedumpSystem?[]
+        {
+            RedumpSystem.MicrosoftXbox,
+            RedumpSystem.MicrosoftXbox360,
+            RedumpSystem.MicrosoftXboxOne,
+            RedumpSystem.MicrosoftXboxSeriesXS,
+        };
+
+        /// <summary>
+        /// Check that all optical media support drive speeds
+        /// </summary>
+        /// <param name="mediaType">DriveType value to check</param>
+        /// <param name="expected">The expected value to come from the check</param>
+        [Theory]
+        [MemberData(nameof(GenerateSupportDriveSpeedsTestData))]
+        public void DoesSupportDriveSpeedTest(MediaType? mediaType, bool expected)
+        {
+            bool actual = mediaType.DoesSupportDriveSpeed();
+            Assert.Equal(expected, actual);
+        }
+
+        /// <summary>
+        /// Check that all systems with reversed ringcodes are marked properly
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expected">The expected value to come from the check</param>
+        [Theory]
+        [MemberData(nameof(GenerateReversedRingcodeSystemsTestData))]
+        public void HasReversedRingcodesTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.HasReversedRingcodes();
+            Assert.Equal(expected, actual);
+        }
+
+        /// <summary>
+        /// Check that all audio systems are marked properly
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expected">The expected value to come from the check</param>
+        [Theory]
+        [MemberData(nameof(GenerateAudioSystemsTestData))]
+        public void IsAudioTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.IsAudio();
+            Assert.Equal(expected, actual);
+        }
+
+        /// <summary>
+        /// Check that all marker systems are marked properly
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expected">The expected value to come from the check</param>
+        [Theory]
+        [MemberData(nameof(GenerateMarkerSystemsTestData))]
+        public void IsMarkerTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.IsMarker();
+            Assert.Equal(expected, actual);
+        }
+
+        /// <summary>
+        /// Check that all XGD systems are marked properly
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expected">The expected value to come from the check</param>
+        [Theory]
+        [MemberData(nameof(GenerateXGDSystemsTestData))]
+        public void IsXGDTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.IsXGD();
+            Assert.Equal(expected, actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of MediaType values that support drive speeds
+        /// </summary>
+        /// <returns>MemberData-compatible list of MediaType values</returns>
+        public static List<object[]> GenerateSupportDriveSpeedsTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (MediaType mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                if (_supportDriveSpeeds.Contains(mediaType))
+                    testData.Add(new object[] { mediaType, true });
+                else
+                    testData.Add(new object[] { mediaType, false });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered Audio
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateAudioSystemsTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_audioSystems.Contains(redumpSystem))
+                    testData.Add(new object[] { redumpSystem, true });
+                else
+                    testData.Add(new object[] { redumpSystem, false });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered markers
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateMarkerSystemsTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_markerSystems.Contains(redumpSystem))
+                    testData.Add(new object[] { redumpSystem, true });
+                else
+                    testData.Add(new object[] { redumpSystem, false });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered markers
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateReversedRingcodeSystemsTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_reverseRingcodeSystems.Contains(redumpSystem))
+                    testData.Add(new object[] { redumpSystem, true });
+                else
+                    testData.Add(new object[] { redumpSystem, false });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered XGD
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateXGDSystemsTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_xgdSystems.Contains(redumpSystem))
+                    testData.Add(new object[] { redumpSystem, true });
+                else
+                    testData.Add(new object[] { redumpSystem, false });
+            }
+
+            return testData;
+        }
+    }
+}

MPF.Test/Library/DumpEnvironmentTests.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using MPF.Core.Data;
+using MPF.Library;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.Library
+{
+    public class DumpEnvironmentTests
+    {
+        [Theory]
+        [InlineData(null, 'D', false, MediaType.NONE, false)]
+        [InlineData("", 'D', false, MediaType.NONE, false)]
+        [InlineData("cd F test.bin 8 /c2 20", 'F', false, MediaType.CDROM, true)]
+        [InlineData("fd A test.img", 'A', true, MediaType.FloppyDisk, true)]
+        [InlineData("dvd X test.iso 8 /raw", 'X', false, MediaType.FloppyDisk, false)]
+        [InlineData("stop D", 'D', false, MediaType.DVD, true)]
+        public void ParametersValidTest(string parameters, char letter, bool isFloppy, MediaType? mediaType, bool expected)
+        {
+            var options = new Options() { InternalProgram = InternalProgram.DiscImageCreator };
+            var drive = isFloppy
+                ? new Drive(InternalDriveType.Floppy, new DriveInfo(letter.ToString()))
+                : new Drive(InternalDriveType.Optical, new DriveInfo(letter.ToString()));
+
+            var env = new DumpEnvironment(options, string.Empty, string.Empty, drive, RedumpSystem.IBMPCcompatible, mediaType, parameters);
+
+            bool actual = env.ParametersValid();
+            Assert.Equal(expected, actual);
+        }
+    }
+}

MPF.Test/Library/InfoToolTests.cs

@@ -0,0 +1,196 @@
+using System.Collections.Generic;
+using MPF.Library;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.Library
+{
+    public class InfoToolTests
+    {
+        [Theory]
+        [InlineData(null, 0, 0, 0, 0, null)]
+        [InlineData(null, 12345, 0, 0, 0, null)]
+        [InlineData(null, 12345, 1, 0, 0, null)]
+        [InlineData(null, 12345, 1, 2, 0, null)]
+        [InlineData(null, 12345, 1, 2, 3, null)]
+        [InlineData(MediaType.CDROM, 0, 0, 0, 0, "CD-ROM")]
+        [InlineData(MediaType.CDROM, 12345, 0, 0, 0, "CD-ROM")]
+        [InlineData(MediaType.CDROM, 12345, 1, 0, 0, "CD-ROM")]
+        [InlineData(MediaType.CDROM, 12345, 1, 2, 0, "CD-ROM")]
+        [InlineData(MediaType.CDROM, 12345, 1, 2, 3, "CD-ROM")]
+        [InlineData(MediaType.DVD, 0, 0, 0, 0, "DVD-ROM-5")]
+        [InlineData(MediaType.DVD, 12345, 0, 0, 0, "DVD-ROM-5")]
+        [InlineData(MediaType.DVD, 12345, 1, 0, 0, "DVD-ROM-9")]
+        [InlineData(MediaType.DVD, 12345, 1, 2, 0, "DVD-ROM-9")]
+        [InlineData(MediaType.DVD, 12345, 1, 2, 3, "DVD-ROM-9")]
+        [InlineData(MediaType.BluRay, 0, 0, 0, 0, "BD-ROM-25")]
+        [InlineData(MediaType.BluRay, 12345, 0, 0, 0, "BD-ROM-25")]
+        [InlineData(MediaType.BluRay, 26_843_531_857, 0, 0, 0, "BD-ROM-33")]
+        [InlineData(MediaType.BluRay, 12345, 1, 0, 0, "BD-ROM-50")]
+        [InlineData(MediaType.BluRay, 53_687_063_713, 1, 0, 0, "BD-ROM-66")]
+        [InlineData(MediaType.BluRay, 12345, 1, 2, 0, "BD-ROM-100")]
+        [InlineData(MediaType.BluRay, 12345, 1, 2, 3, "BD-ROM-128")]
+        [InlineData(MediaType.UMD, 0, 0, 0, 0, "UMD-SL")]
+        [InlineData(MediaType.UMD, 12345, 0, 0, 0, "UMD-SL")]
+        [InlineData(MediaType.UMD, 12345, 1, 0, 0, "UMD-DL")]
+        [InlineData(MediaType.UMD, 12345, 1, 2, 0, "UMD-DL")]
+        [InlineData(MediaType.UMD, 12345, 1, 2, 3, "UMD-DL")]
+        public void GetFixedMediaTypeTest(
+            MediaType? mediaType,
+            long size,
+            long layerbreak,
+            long layerbreak2,
+            long layerbreak3,
+            string expected)
+        {
+            string actual = InfoTool.GetFixedMediaType(mediaType, size, layerbreak, layerbreak2, layerbreak3);
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(null, null, null, null)]
+        [InlineData(" ", "", " ", "")]
+        [InlineData("super", "blah.bin", "super", "blah.bin")]
+        [InlineData("super\\hero", "blah.bin", "super\\hero", "blah.bin")]
+        [InlineData("super.hero", "blah.bin", "super.hero", "blah.bin")]
+        [InlineData("superhero", "blah.rev.bin", "superhero", "blah.rev.bin")]
+        [InlineData("super&hero", "blah.bin", "super&hero", "blah.bin")]
+        [InlineData("superhero", "blah&foo.bin", "superhero", "blah&foo.bin")]
+        public void NormalizeOutputPathsTest(string outputDirectory, string outputFilename, string expectedOutputDirectory, string expectedOutputFilename)
+        {
+            (string actualOutputDirectory, string actualOutputFilename) = InfoTool.NormalizeOutputPaths(outputDirectory, outputFilename);
+            Assert.Equal(expectedOutputDirectory, actualOutputDirectory);
+            Assert.Equal(expectedOutputFilename, actualOutputFilename);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsCompleteTest()
+        {
+            // Create a new SubmissionInfo object
+            SubmissionInfo info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = "This is a comments line\n[T:ISBN] ISBN Value",
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = "This is a contents line\n[T:GF] Game Footage",
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.Patches] = "1.04 patch",
+                    },
+                }
+            };
+
+            // Process the special fields
+            InfoTool.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Equal(3, splitComments.Length);
+            Assert.Equal(5, splitContents.Length);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullObjectTest()
+        {
+            // Create a new SubmissionInfo object
+            SubmissionInfo info = new SubmissionInfo()
+            {
+                CommonDiscInfo = null,
+            };
+
+            // Process the special fields
+            InfoTool.ProcessSpecialFields(info);
+
+            // Validate
+            Assert.Null(info.CommonDiscInfo);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullCommentsContentsTest()
+        {
+            // Create a new SubmissionInfo object
+            SubmissionInfo info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = null,
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = null,
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.Patches] = "1.04 patch",
+                    },
+                }
+            };
+
+            // Process the special fields
+            InfoTool.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Single(splitComments);
+            Assert.Equal(2, splitContents.Length);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullDictionariesTest()
+        {
+            // Create a new SubmissionInfo object
+            SubmissionInfo info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = "This is a comments line\n[T:ISBN] ISBN Value",
+                    CommentsSpecialFields = null,
+
+                    Contents = "This is a contents line\n[T:GF] Game Footage",
+                    ContentsSpecialFields = null,
+                }
+            };
+
+            // Process the special fields
+            InfoTool.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Equal(2, splitComments.Length);
+            Assert.Equal(2, splitContents.Length);
+        }
+    }
+}

MPF.Test/Library/ProtectionTests.cs

@@ -0,0 +1,271 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Library;
+using Xunit;
+
+namespace MPF.Test.Library
+{
+    public class ProtectionTests
+    {
+        [Fact]
+        public void SanitizeFoundProtectionsActiveMARKTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "ActiveMARK",
+                "ActiveMARK 5",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("ActiveMARK 5", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsCactusDataShieldTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Cactus Data Shield 200",
+                "Cactus Data Shield 200 (Build 3.0.100a)",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Cactus Data Shield 200 (Build 3.0.100a)", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsCDCheckTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Anything Else Protection",
+                "Executable-Based CD Check",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsCDCopsTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "CD-Cops",
+                "CD-Cops v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("CD-Cops v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsCDKeyTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Anything Else Protection",
+                "CD-Key / Serial",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsEACdKeyTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "EA CdKey Registration Module",
+                "EA CdKey Registration Module v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("EA CdKey Registration Module v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsEADRMTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "EA DRM Protection",
+                "EA DRM Protection v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("EA DRM Protection v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsGFWLTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Games for Windows LIVE",
+                "Games for Windows LIVE v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Games for Windows LIVE v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsGFWLZDPPTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Games for Windows LIVE",
+                "Games for Windows LIVE Zero Day Piracy Protection",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Games for Windows LIVE, Games for Windows LIVE Zero Day Piracy Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsImpulseReactorTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Impulse Reactor",
+                "Impulse Reactor Core Module v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Impulse Reactor Core Module v1.2.0", sanitized);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        public void SanitizeFoundProtectionsJoWoodXProtTest(int skip)
+        {
+            List<string> protections = new List<string>()
+            {
+                "JoWood X-Prot 1.2.0.00",
+                "JoWood X-Prot v2",
+                "JoWood X-Prot v1.4+",
+                "JoWood X-Prot v1.0-v1.3",
+                "JoWood X-Prot",
+            };
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsOnlineRegistrationTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Anything Else Protection",
+                "Executable-Based Online Registration",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        [InlineData(7)]
+        [InlineData(8)]
+        public void SanitizeFoundProtectionsSafeDiscTest(int skip)
+        {
+            List<string> protections = new List<string>()
+            {
+                "SafeDisc 1.20.000",
+                "SafeDisc (drvmgt.dll) 1.2.0",
+                "SafeDisc (secdrv.sys) 1.2.0",
+                "SafeDisc (dplayerx.dll) 1.2.0",
+                "SafeDisc 3.20-4.xx (version removed)",
+                "SafeDisc 2",
+                "SafeDisc 1/Lite",
+                "SafeDisc Lite",
+                "SafeDisc 1-3",
+                "SafeDisc",
+            };
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        public void SanitizeFoundProtectionStarForceTest(int skip)
+        {
+            List<string> protections = new List<string>()
+            {
+                "StarForce 1.20.000.000",
+                "StarForce 5 [Protected Module]",
+                "StarForce 5",
+                "StarForce 3-5",
+                "StarForce",
+            };
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsSysiphusTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "Sysiphus",
+                "Sysiphus v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("Sysiphus v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectionsXCPTest()
+        {
+            List<string> protections = new List<string>()
+            {
+                "XCP",
+                "XCP v1.2.0",
+            };
+
+            string sanitized = Protection.SanitizeFoundProtections(protections);
+            Assert.Equal("XCP v1.2.0", sanitized);
+        }
+    }
+}

MPF.Test/MPF.Test.csproj

@@ -1,24 +1,47 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0-windows</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\MPF.Library\MPF.Library.csproj">
-      <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
-      <Name>MPF.Library</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\MPF\MPF.csproj">
-      <Project>{7b1b75eb-8940-466f-bd51-76471a57f9be}</Project>
-      <Name>MPF</Name>
-    </ProjectReference>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net48'">
+    <DefineConstants>NET_FRAMEWORK</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
+    <COMReference Include="IMAPI2">
+      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+    <COMReference Include="IMAPI2FS">
+      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeCoverage" Version="16.9.0-preview-20210106-01" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.0-preview-20210106-01" />
+    <ProjectReference Include="..\MPF\MPF.csproj" />
+    <ProjectReference Include="..\MPF.Library\MPF.Library.csproj" />
+    <ProjectReference Include="..\MPF.Modules\MPF.Modules.csproj" />
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeCoverage" Version="16.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.abstractions" Version="2.0.3" />
     <PackageReference Include="xunit.analyzers" Version="0.10.0" />

MPF.Test/Modules/DiscImageCreatorTests.cs

@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using MPF.Core.Data;
+using MPF.Modules.DiscImageCreator;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.Modules
+{
+    public class DiscImageCreatorTests
+    {
+        #region Old Tests
+
+        [Theory]
+        [InlineData(RedumpSystem.MicrosoftXbox, MediaType.CDROM, CommandStrings.CompactDisc)]
+        [InlineData(RedumpSystem.MicrosoftXbox, MediaType.DVD, CommandStrings.XBOX)]
+        [InlineData(RedumpSystem.MicrosoftXbox, MediaType.LaserDisc, null)]
+        [InlineData(RedumpSystem.SonyPlayStation3, MediaType.BluRay, CommandStrings.BluRay)]
+        [InlineData(RedumpSystem.AppleMacintosh, MediaType.FloppyDisk, CommandStrings.Floppy)]
+        [InlineData(RedumpSystem.RawThrillsVarious, MediaType.GDROM, null)]
+        public void ParametersFromSystemAndTypeTest(RedumpSystem? knownSystem, MediaType? mediaType, string expected)
+        {
+            var options = new Options { };
+            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
+            Assert.Equal(expected, actual.BaseCommand);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.AppleMacintosh, MediaType.LaserDisc, true, 20, null, null)]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, false, 20, null, new string[] { FlagStrings.Raw })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, 20, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
+        /* paranoid mode tests */
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, 1000, 2, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(RedumpSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
+        /* reread c2 */
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, false, 1000, null, new string[] { FlagStrings.C2Opcode })]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new string[] { FlagStrings.C2Opcode })]
+        public void ParametersFromOptionsTest(RedumpSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, string[] expected)
+        {
+            var options = new Options { DICParanoidMode = paranoid, DICRereadCount = rereadC2 };
+            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
+
+            HashSet<string> expectedSet = new HashSet<string>(expected ?? new string[0]);
+            HashSet<string> actualSet = new HashSet<string>(actual.Keys ?? new string[0]);
+            Assert.Equal(expectedSet, actualSet);
+            if (rereadC2 == -1 || !knownSystem.MediaTypes().Contains(mediaType))
+                Assert.Null(actual.C2OpcodeValue[0]);
+            else
+                Assert.Equal(rereadC2, actual.C2OpcodeValue[0]);
+            Assert.Equal(subchannelLevel, actual.SubchannelReadLevelValue);
+        }
+
+        [Theory]
+        [InlineData(null, false)]
+        [InlineData("", false)]
+        [InlineData("cd F test.bin 8 /c2 20", true)]
+        [InlineData("fd A test.img", true)]
+        [InlineData("dvd X super\\test.iso 8 /raw", true)]
+        [InlineData("bd D longer\\path_test.iso 16", true)]
+        [InlineData("stop D", true)]
+        [InlineData("ls", false)]
+        public void ValidateParametersTest(string parameters, bool expected)
+        {
+            var actual = new Parameters(parameters);
+            Assert.Equal(expected, actual.IsValid());
+        }
+
+        [Theory]
+        [InlineData(MediaType.CDROM, ".bin")]
+        [InlineData(MediaType.DVD, ".iso")]
+        [InlineData(MediaType.LaserDisc, ".raw")]
+        [InlineData(MediaType.NintendoWiiUOpticalDisc, ".wud")]
+        [InlineData(MediaType.FloppyDisk, ".img")]
+        [InlineData(MediaType.Cassette, ".wav")]
+        [InlineData(MediaType.NONE, null)]
+        public void MediaTypeToExtensionTest(MediaType? mediaType, string expected)
+        {
+            string actual = MPF.Modules.DiscImageCreator.Converters.Extension(mediaType);
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(CommandStrings.Audio, MediaType.CDROM)]
+        [InlineData(CommandStrings.BluRay, MediaType.BluRay)]
+        [InlineData(CommandStrings.Close, null)]
+        [InlineData(CommandStrings.CompactDisc, MediaType.CDROM)]
+        [InlineData(CommandStrings.Data, MediaType.CDROM)]
+        [InlineData(CommandStrings.DigitalVideoDisc, MediaType.DVD)]
+        [InlineData(CommandStrings.Eject, null)]
+        [InlineData(CommandStrings.Floppy, MediaType.FloppyDisk)]
+        [InlineData(CommandStrings.GDROM, MediaType.GDROM)]
+        [InlineData(CommandStrings.MDS, null)]
+        [InlineData(CommandStrings.Reset, null)]
+        [InlineData(CommandStrings.SACD, MediaType.CDROM)]
+        [InlineData(CommandStrings.Start, null)]
+        [InlineData(CommandStrings.Stop, null)]
+        [InlineData(CommandStrings.Sub, null)]
+        [InlineData(CommandStrings.Swap, MediaType.GDROM)]
+        [InlineData(CommandStrings.XBOX, MediaType.DVD)]
+        public void BaseCommandToMediaTypeTest(string command, MediaType? expected)
+        {
+            MediaType? actual = MPF.Modules.DiscImageCreator.Converters.ToMediaType(command);
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(CommandStrings.Audio, RedumpSystem.AudioCD)]
+        [InlineData(CommandStrings.BluRay, RedumpSystem.SonyPlayStation3)]
+        [InlineData(CommandStrings.Close, null)]
+        [InlineData(CommandStrings.CompactDisc, RedumpSystem.IBMPCcompatible)]
+        [InlineData(CommandStrings.Data, RedumpSystem.IBMPCcompatible)]
+        [InlineData(CommandStrings.DigitalVideoDisc, RedumpSystem.IBMPCcompatible)]
+        [InlineData(CommandStrings.Eject, null)]
+        [InlineData(CommandStrings.Floppy, RedumpSystem.IBMPCcompatible)]
+        [InlineData(CommandStrings.GDROM, RedumpSystem.SegaDreamcast)]
+        [InlineData(CommandStrings.MDS, null)]
+        [InlineData(CommandStrings.Reset, null)]
+        [InlineData(CommandStrings.SACD, RedumpSystem.SuperAudioCD)]
+        [InlineData(CommandStrings.Start, null)]
+        [InlineData(CommandStrings.Stop, null)]
+        [InlineData(CommandStrings.Sub, null)]
+        [InlineData(CommandStrings.Swap, RedumpSystem.SegaDreamcast)]
+        [InlineData(CommandStrings.XBOX, RedumpSystem.MicrosoftXbox)]
+        public void BaseCommandToRedumpSystemTest(string command, RedumpSystem? expected)
+        {
+            RedumpSystem? actual = MPF.Modules.DiscImageCreator.Converters.ToRedumpSystem(command);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        [Fact]
+        public void DiscImageCreatorAudioParametersTest()
+        {
+            string originalParameters = "audio F \"ISO\\Audio CD\\Audio CD.bin\" 72 -5 0";
+
+            // Validate that a common audio commandline is parsed
+            var parametersObject = new Parameters(originalParameters);
+            Assert.NotNull(parametersObject);
+
+            // Validate that the same set of parameters are generated on the output
+            string newParameters = parametersObject.GenerateParameters();
+            Assert.NotNull(newParameters);
+            Assert.Equal(originalParameters, newParameters);
+        }
+
+        [Fact]
+        public void DiscImageCreatorDataParametersTest()
+        {
+            string originalParameters = "data F \"ISO\\Data CD\\Data CD.bin\" 72 -5 0";
+
+            // Validate that a common audio commandline is parsed
+            var parametersObject = new Parameters(originalParameters);
+            Assert.NotNull(parametersObject);
+
+            // Validate that the same set of parameters are generated on the output
+            string newParameters = parametersObject.GenerateParameters();
+            Assert.NotNull(newParameters);
+            Assert.Equal(originalParameters, newParameters);
+        }
+    }
+}

MPF.Test/RedumpLib/ExtensionsTests.cs

@@ -0,0 +1,723 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.RedumpLib
+{
+    // TODO: Add tests for string-to-enum conversion
+    public class ExtensionsTests
+    {
+        #region Cross-Enumeration
+
+        /// <summary>
+        /// DiscType values that map to MediaType
+        /// </summary>
+        private static readonly DiscType?[] _mappableDiscTypes = new DiscType?[]
+        {
+            DiscType.BD25,
+            DiscType.BD50,
+            DiscType.CD,
+            DiscType.DVD5,
+            DiscType.DVD9,
+            DiscType.GDROM,
+            DiscType.HDDVDSL,
+            DiscType.NintendoGameCubeGameDisc,
+            DiscType.NintendoWiiOpticalDiscSL,
+            DiscType.NintendoWiiOpticalDiscDL,
+            DiscType.NintendoWiiUOpticalDiscSL,
+            DiscType.UMDSL,
+            DiscType.UMDDL,
+        };
+
+        /// <summary>
+        /// MediaType values that map to DiscType
+        /// </summary>
+        private static readonly MediaType?[] _mappableMediaTypes = new MediaType?[]
+        {
+            MediaType.BluRay,
+            MediaType.CDROM,
+            MediaType.DVD,
+            MediaType.GDROM,
+            MediaType.HDDVD,
+            MediaType.NintendoGameCubeGameDisc,
+            MediaType.NintendoWiiOpticalDisc,
+            MediaType.NintendoWiiUOpticalDisc,
+            MediaType.UMD,
+        };
+
+        /// <summary>
+        /// Check that every supported system has some set of MediaTypes supported
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        [Theory]
+        [MemberData(nameof(GenerateRedumpSystemMappingTestData))]
+        public void MediaTypesTest(RedumpSystem? redumpSystem)
+        {
+            var actual = redumpSystem.MediaTypes();
+            Assert.NotEmpty(actual);
+        }
+
+        /// <summary>
+        /// Check that both mappable and unmappable media types output correctly
+        /// </summary>
+        /// <param name="mediaType">MediaType value to check</param>
+        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateMediaTypeMappingTestData))]
+        public void ToDiscTypeTest(MediaType? mediaType, bool expectNull)
+        {
+            DiscType? actual = mediaType.ToDiscType();
+            Assert.Equal(expectNull, actual == null);
+        }
+
+        /// <summary>
+        /// Check that DiscType values all map to something appropriate
+        /// </summary>
+        /// <param name="discType">DiscType value to check</param>
+        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDiscTypeMappingTestData))]
+        public void ToMediaTypeTest(DiscType? discType, bool expectNull)
+        {
+            MediaType? actual = discType.ToMediaType();
+            Assert.Equal(expectNull, actual == null);
+        }
+
+        /// <summary>
+        /// Generate a test set of DiscType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DiscType values</returns>
+        public static List<object[]> GenerateDiscTypeMappingTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
+            {
+                if (_mappableDiscTypes.Contains(discType))
+                    testData.Add(new object[] { discType, false });
+                else
+                    testData.Add(new object[] { discType, true });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateRedumpSystemMappingTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null } };
+            foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                testData.Add(new object[] { redumpSystem });
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of mappable media types
+        /// </summary>
+        /// <returns>MemberData-compatible list of MediaTypes</returns>
+        public static List<object[]> GenerateMediaTypeMappingTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+
+            foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                if (_mappableMediaTypes.Contains(mediaType))
+                    testData.Add(new object[] { mediaType, false });
+                else
+                    testData.Add(new object[] { mediaType, true });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Disc Category
+
+        /// <summary>
+        /// Check that every DiscCategory has a long name provided
+        /// </summary>
+        /// <param name="discCategory">DiscCategory value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDiscCategoryTestData))]
+        public void DiscCategoryLongNameTest(DiscCategory? discCategory, bool expectNull)
+        {
+            string actual = discCategory.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of DiscCategory values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DiscCategory values</returns>
+        public static List<object[]> GenerateDiscCategoryTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DiscCategory? discCategory in Enum.GetValues(typeof(DiscCategory)))
+            {
+                testData.Add(new object[] { discCategory, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Disc Type
+
+        /// <summary>
+        /// Check that every DiscType has a long name provided
+        /// </summary>
+        /// <param name="discType">DiscType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDiscTypeTestData))]
+        public void DiscTypeLongNameTest(DiscType? discType, bool expectNull)
+        {
+            string actual = discType.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of DiscType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DiscType values</returns>
+        public static List<object[]> GenerateDiscTypeTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
+            {
+                if (discType == DiscType.NONE)
+                    testData.Add(new object[] { discType, true });
+                else
+                    testData.Add(new object[] { discType, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Language
+
+        /// <summary>
+        /// Check that every Language has a long name provided
+        /// </summary>
+        /// <param name="language">Language value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageTestData))]
+        public void LanguageLongNameTest(Language? language, bool expectNull)
+        {
+            string actual = language.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every Language has a short name provided
+        /// </summary>
+        /// <param name="language">Language value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageTestData))]
+        public void LanguageShortNameTest(Language? language, bool expectNull)
+        {
+            string actual = language.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Ensure that every Language that has an ISO 639-1 code is unique
+        /// </summary>
+        [Fact]
+        public void LanguageNoDuplicateTwoLetterCodeTest()
+        {
+            var fullLanguages = Enum.GetValues(typeof(Language)).Cast<Language?>().ToList();
+            var filteredLanguages = new Dictionary<string, Language?>();
+
+            int totalCount = 0;
+            foreach (Language? language in fullLanguages)
+            {
+                string code = language.TwoLetterCode();
+                if (string.IsNullOrWhiteSpace(code))
+                    continue;
+
+                // Throw if the code already exists
+                if (filteredLanguages.ContainsKey(code))
+                    throw new DuplicateNameException($"Code {code} already in dictionary");
+
+                filteredLanguages[code] = language;
+                totalCount++;
+            }
+
+            Assert.Equal(totalCount, filteredLanguages.Count);
+        }
+
+        /// <summary>
+        /// Ensure that every Language that has a standard/bibliographic ISO 639-2 code is unique
+        /// </summary>
+        [Fact]
+        public void LanguageNoDuplicateThreeLetterCodeTest()
+        {
+            var fullLanguages = Enum.GetValues(typeof(Language)).Cast<Language?>().ToList();
+            var filteredLanguages = new Dictionary<string, Language?>();
+
+            int totalCount = 0;
+            foreach (Language? language in fullLanguages)
+            {
+                string code = language.ThreeLetterCode();
+                if (string.IsNullOrWhiteSpace(code))
+                    continue;
+
+                // Throw if the code already exists
+                if (filteredLanguages.ContainsKey(code))
+                    throw new DuplicateNameException($"Code {code} already in dictionary");
+
+                filteredLanguages[code] = language;
+                totalCount++;
+            }
+
+            Assert.Equal(totalCount, filteredLanguages.Count);
+        }
+
+        /// <summary>
+        /// Ensure that every Language that has a terminology ISO 639-2 code is unique
+        /// </summary>
+        [Fact]
+        public void LanguageNoDuplicateThreeLetterCodeAltTest()
+        {
+            var fullLanguages = Enum.GetValues(typeof(Language)).Cast<Language?>().ToList();
+            var filteredLanguages = new Dictionary<string, Language?>();
+
+            int totalCount = 0;
+            foreach (Language? language in fullLanguages)
+            {
+                string code = language.ThreeLetterCodeAlt();
+                if (string.IsNullOrWhiteSpace(code))
+                    continue;
+
+                // Throw if the code already exists
+                if (filteredLanguages.ContainsKey(code))
+                    throw new DuplicateNameException($"Code {code} already in dictionary");
+
+                filteredLanguages[code] = language;
+                totalCount++;
+            }
+
+            Assert.Equal(totalCount, filteredLanguages.Count);
+        }
+
+        /// <summary>
+        /// Generate a test set of Language values
+        /// </summary>
+        /// <returns>MemberData-compatible list of Language values</returns>
+        public static List<object[]> GenerateLanguageTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (Language? language in Enum.GetValues(typeof(Language)))
+            {
+                testData.Add(new object[] { language, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Language Selection
+
+        /// <summary>
+        /// Check that every LanguageSelection has a long name provided
+        /// </summary>
+        /// <param name="languageSelection">LanguageSelection value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateLanguageSelectionTestData))]
+        public void LanguageSelectionLongNameTest(LanguageSelection? languageSelection, bool expectNull)
+        {
+            string actual = languageSelection.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of LanguageSelection values
+        /// </summary>
+        /// <returns>MemberData-compatible list of LanguageSelection values</returns>
+        public static List<object[]> GenerateLanguageSelectionTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (LanguageSelection? languageSelection in Enum.GetValues(typeof(LanguageSelection)))
+            {
+                testData.Add(new object[] { languageSelection, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Media Type
+
+        /// <summary>
+        /// Check that every MediaType has a long name provided
+        /// </summary>
+        /// <param name="mediaType">MediaType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateMediaTypeTestData))]
+        public void MediaTypeLongNameTest(MediaType? mediaType, bool expectNull)
+        {
+            string actual = mediaType.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every MediaType has a short name provided
+        /// </summary>
+        /// <param name="mediaType">MediaType value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateMediaTypeTestData))]
+        public void MediaTypeShortNameTest(MediaType? mediaType, bool expectNull)
+        {
+            string actual = mediaType.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of MediaType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of MediaType values</returns>
+        public static List<object[]> GenerateMediaTypeTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                testData.Add(new object[] { mediaType, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Region
+
+        /// <summary>
+        /// Check that every Region has a long name provided
+        /// </summary>
+        /// <param name="region">Region value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateRegionTestData))]
+        public void RegionLongNameTest(Region? region, bool expectNull)
+        {
+            string actual = region.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every Region has a short name provided
+        /// </summary>
+        /// <param name="region">Region value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateRegionTestData))]
+        public void RegionShortNameTest(Region? region, bool expectNull)
+        {
+            string actual = region.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Ensure that every Language that has an ISO 639-1 code is unique
+        /// </summary>
+        [Fact]
+        public void RegionNoDuplicateShortNameTest()
+        {
+            var fullRegions = Enum.GetValues(typeof(Region)).Cast<Region?>().ToList();
+            var filteredRegions = new Dictionary<string, Region?>();
+
+            int totalCount = 0;
+            foreach (Region? region in fullRegions)
+            {
+                string code = region.ShortName();
+                if (string.IsNullOrWhiteSpace(code))
+                    continue;
+
+                // Throw if the code already exists
+                if (filteredRegions.ContainsKey(code))
+                    throw new DuplicateNameException($"Code {code} already in dictionary");
+
+                filteredRegions[code] = region;
+                totalCount++;
+            }
+
+            Assert.Equal(totalCount, filteredRegions.Count);
+        }
+
+        /// <summary>
+        /// Generate a test set of Region values
+        /// </summary>
+        /// <returns>MemberData-compatible list of Region values</returns>
+        public static List<object[]> GenerateRegionTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (Region? region in Enum.GetValues(typeof(Region)))
+            {
+                testData.Add(new object[] { region, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Site Code
+
+        /// <summary>
+        /// Check that every SiteCode has a long name provided
+        /// </summary>
+        /// <param name="siteCode">SiteCode value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateSiteCodeTestData))]
+        public void SiteCodeLongNameTest(SiteCode? siteCode, bool expectNull)
+        {
+            string actual = siteCode.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Check that every SiteCode has a short name provided
+        /// </summary>
+        /// <param name="siteCode">SiteCode value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateSiteCodeTestData))]
+        public void SiteCodeShortNameTest(SiteCode? siteCode, bool expectNull)
+        {
+            string actual = siteCode.ShortName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of SiteCode values
+        /// </summary>
+        /// <returns>MemberData-compatible list of SiteCode values</returns>
+        public static List<object[]> GenerateSiteCodeTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (SiteCode? siteCode in Enum.GetValues(typeof(SiteCode)))
+            {
+                testData.Add(new object[] { siteCode, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region System
+
+        /// <summary>
+        /// RedumpSystem values that are considered markers and not real systems
+        /// </summary>
+        private static readonly RedumpSystem?[] _markerSystemTypes = new RedumpSystem?[]
+        {
+            RedumpSystem.MarkerArcadeEnd,
+            RedumpSystem.MarkerComputerEnd,
+            RedumpSystem.MarkerDiscBasedConsoleEnd,
+            RedumpSystem.MarkerOtherEnd,
+        };
+
+        /// <summary>
+        /// Check that every RedumpSystem has a long name provided
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateRedumpSystemTestData))]
+        public void RedumpSystemLongNameTest(RedumpSystem? redumpSystem, bool expectNull)
+        {
+            string actual = redumpSystem.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        // TODO: Re-enable the following test once non-Redump systems are accounted for
+
+        /// <summary>
+        /// Check that every RedumpSystem has a short name provided
+        /// </summary>
+        /// <param name="redumpSystem">RedumpSystem value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        //[Theory]
+        //[MemberData(nameof(GenerateRedumpSystemTestData))]
+        //public void RedumpSystemShortNameTest(RedumpSystem? redumpSystem, bool expectNull)
+        //{
+        //    string actual = redumpSystem.ShortName();
+
+        //    if (expectNull)
+        //        Assert.Null(actual);
+        //    else
+        //        Assert.NotNull(actual);
+        //}
+
+        // TODO: Test the other attributes as well
+        // Most are bool checks so they're not as interesting to have unit tests around
+        // SystemCategory always returns something as well, so is it worth testing?
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+        public static List<object[]> GenerateRedumpSystemTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                // We want to skip all markers for this
+                if (_markerSystemTypes.Contains(redumpSystem))
+                    continue;
+
+                testData.Add(new object[] { redumpSystem, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region System Category
+
+        /// <summary>
+        /// Check that every SystemCategory has a long name provided
+        /// </summary>
+        /// <param name="systemCategory">SystemCategory value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateSystemCategoryTestData))]
+        public void SystemCategoryLongNameTest(SystemCategory? systemCategory, bool expectNull)
+        {
+            string actual = systemCategory.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of SystemCategory values
+        /// </summary>
+        /// <returns>MemberData-compatible list of SystemCategory values</returns>
+        public static List<object[]> GenerateSystemCategoryTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, true } };
+            foreach (SystemCategory? systemCategory in Enum.GetValues(typeof(SystemCategory)))
+            {
+                if (systemCategory == SystemCategory.NONE)
+                    testData.Add(new object[] { systemCategory, true });
+                else
+                    testData.Add(new object[] { systemCategory, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region Yes/No
+
+        /// <summary>
+        /// Check that every YesNo has a long name provided
+        /// </summary>
+        /// <param name="yesNo">YesNo value to check</param>
+        /// <param name="expectNull">True to expect a null value, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateYesNoTestData))]
+        public void YesNoLongNameTest(YesNo? yesNo, bool expectNull)
+        {
+            string actual = yesNo.LongName();
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of YesNo values
+        /// </summary>
+        /// <returns>MemberData-compatible list of YesNo values</returns>
+        public static List<object[]> GenerateYesNoTestData()
+        {
+            var testData = new List<object[]>() { new object[] { null, false } };
+            foreach (YesNo? yesNo in Enum.GetValues(typeof(YesNo)))
+            {
+                testData.Add(new object[] { yesNo, false });
+            }
+
+            return testData;
+        }
+
+        #endregion
+    }
+}

MPF.Test/RedumpLib/SubmissionInfoTests.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.RedumpLib
+{
+    public class SubmissionInfoTests
+    {
+        [Fact]
+        public void EmptySerializationTest()
+        {
+            var submissionInfo = new SubmissionInfo();
+            string json = JsonConvert.SerializeObject(submissionInfo, Formatting.Indented);
+            Assert.NotNull(json);
+        }
+
+        [Fact]
+        public void PartialSerializationTest()
+        {
+            var submissionInfo = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection(),
+                VersionAndEditions = new VersionAndEditionsSection(),
+                EDC = new EDCSection(),
+                ParentCloneRelationship = new ParentCloneRelationshipSection(),
+                Extras = new ExtrasSection(),
+                CopyProtection = new CopyProtectionSection(),
+                DumpersAndStatus = new DumpersAndStatusSection(),
+                TracksAndWriteOffsets = new TracksAndWriteOffsetsSection(),
+                SizeAndChecksums = new SizeAndChecksumsSection(),
+            };
+
+            string json = JsonConvert.SerializeObject(submissionInfo, Formatting.Indented);
+            Assert.NotNull(json);
+        }
+
+        [Fact]
+        public void FullSerializationTest()
+        {
+            var submissionInfo = new SubmissionInfo()
+            {
+                SchemaVersion = 1,
+                MatchedIDs = new List<int> { 0, 1, 2, 3 },
+                Added = DateTime.UtcNow,
+                LastModified = DateTime.UtcNow,
+
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    System = RedumpSystem.IBMPCcompatible,
+                    Media = DiscType.CD,
+                    Title = "Game Title",
+                    ForeignTitleNonLatin = "Foreign Game Title",
+                    DiscNumberLetter = "1",
+                    DiscTitle = "Install Disc",
+                    Category = DiscCategory.Games,
+                    Region = Region.World,
+                    Languages = new Language?[] { Language.English, Language.Spanish, Language.French },
+                    LanguageSelection = new LanguageSelection?[] { LanguageSelection.BiosSettings },
+                    Serial = "Disc Serial",
+                    Layer0MasteringRing = "L0 Mastering Ring",
+                    Layer0MasteringSID = "L0 Mastering SID",
+                    Layer0ToolstampMasteringCode = "L0 Toolstamp",
+                    Layer0MouldSID = "L0 Mould SID",
+                    Layer0AdditionalMould = "L0 Additional Mould",
+                    Layer1MasteringRing = "L1 Mastering Ring",
+                    Layer1MasteringSID = "L1 Mastering SID",
+                    Layer1ToolstampMasteringCode = "L1 Toolstamp",
+                    Layer1MouldSID = "L1 Mould SID",
+                    Layer1AdditionalMould = "L1 Additional Mould",
+                    Layer2MasteringRing = "L2 Mastering Ring",
+                    Layer2MasteringSID = "L2 Mastering SID",
+                    Layer2ToolstampMasteringCode = "L2 Toolstamp",
+                    Layer3MasteringRing = "L3 Mastering Ring",
+                    Layer3MasteringSID = "L3 Mastering SID",
+                    Layer3ToolstampMasteringCode = "L3 Toolstamp",
+                    RingWriteOffset = "+12",
+                    Barcode = "UPC Barcode",
+                    EXEDateBuildDate = "19xx-xx-xx",
+                    ErrorsCount = "0",
+                    Comments = "Comment data line 1\r\nComment data line 2",
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.ISBN] = "ISBN",
+                    },
+                    Contents = "Special contents 1\r\nSpecial contents 2",
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+                    {
+                        [SiteCode.PlayableDemos] = "Game Demo 1",
+                    },
+                },
+
+                VersionAndEditions = new VersionAndEditionsSection()
+                {
+                    Version = "Original",
+                    VersionDatfile = "Alt",
+                    CommonEditions = new string[] { "Taikenban" },
+                    OtherEditions = "Rerelease",
+                },
+
+                EDC = new EDCSection()
+                {
+                    EDC = YesNo.Yes,
+                },
+
+                ParentCloneRelationship = new ParentCloneRelationshipSection()
+                {
+                    ParentID = "12345",
+                    RegionalParent = false,
+                },
+
+                Extras = new ExtrasSection()
+                {
+                    PVD = "PVD",
+                    DiscKey = "Disc key",
+                    DiscID = "Disc ID",
+                    PIC = "PIC",
+                    Header = "Header",
+                    BCA = "BCA",
+                    SecuritySectorRanges = "SSv1 Ranges",
+                },
+
+                CopyProtection = new CopyProtectionSection()
+                {
+                    AntiModchip = YesNo.Yes,
+                    LibCrypt = YesNo.No,
+                    LibCryptData = "LibCrypt data",
+                    Protection = "List of protections",
+                    SecuROMData = "SecuROM data",
+                },
+
+                DumpersAndStatus = new DumpersAndStatusSection()
+                {
+                    Status = DumpStatus.TwoOrMoHumanReadablesGreen,
+                    Dumpers = new string[] { "Dumper1", "Dumper2" },
+                    OtherDumpers = "Dumper3",
+                },
+
+                TracksAndWriteOffsets = new TracksAndWriteOffsetsSection()
+                {
+                    ClrMameProData = "Datfile",
+                    Cuesheet = "Cuesheet",
+                    CommonWriteOffsets = new int[] { 0, 12, -12 },
+                    OtherWriteOffsets = "-2",
+                },
+
+                SizeAndChecksums = new SizeAndChecksumsSection()
+                {
+                    Layerbreak = 0,
+                    Layerbreak2 = 1,
+                    Layerbreak3 = 2,
+                    Size = 12345,
+                    CRC32 = "CRC32",
+                    MD5 = "MD5",
+                    SHA1 = "SHA1",
+                },
+
+                Artifacts = new Dictionary<string, string>()
+                {
+                    ["Sample Artifact"] = "Sample Data",
+                },
+            };
+
+            string json = JsonConvert.SerializeObject(submissionInfo, Formatting.Indented);
+            Assert.NotNull(json);
+        }
+    }
+}

MPF.Test/ResultTest.cs

@@ -1,30 +0,0 @@
-using MPF.Data;
-using Xunit;
-
-namespace MPF.Test
-{
-    public class ResultTest
-    {
-        [Fact]
-        public void ResultSuccessTest()
-        {
-            Result actual = Result.Success();
-            Assert.Empty(actual.Message);
-
-            string message = "Success!";
-            actual = Result.Success(message);
-            Assert.Equal(message, actual.Message);
-        }
-
-        [Fact]
-        public void ResultFailureTest()
-        {
-            Result actual = Result.Failure();
-            Assert.Empty(actual.Message);
-
-            string message = "Failure!";
-            actual = Result.Failure(message);
-            Assert.Equal(message, actual.Message);
-        }
-    }
-}

MPF.Test/UI/AllowedSpeedsTest.cs

@@ -1,5 +1,6 @@
 using System.Linq;
-using MPF.Data;
+using MPF.Core.Data;
+using RedumpLib.Data;
 using Xunit;
 
 namespace MPF.Test.Data

MPF.Test/Utilities/ConvertersTest.cs

@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using MPF.Data;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test.Utilities
-{
-    public class ConvertersTest
-    {
-        /// <summary>
-        /// Set of all known systems for testing
-        /// </summary>
-        public static IEnumerable<object[]> KnownSystems = KnownSystemComboBoxItem.GenerateElements().Select(e => new object[] { e });
-
-        [Theory]
-        [InlineData(DiscImageCreator.Command.Audio, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.BluRay, MediaType.BluRay)]
-        [InlineData(DiscImageCreator.Command.Close, null)]
-        [InlineData(DiscImageCreator.Command.CompactDisc, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.Data, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.DigitalVideoDisc, MediaType.DVD)]
-        [InlineData(DiscImageCreator.Command.Eject, null)]
-        [InlineData(DiscImageCreator.Command.Floppy, MediaType.FloppyDisk)]
-        [InlineData(DiscImageCreator.Command.GDROM, MediaType.GDROM)]
-        [InlineData(DiscImageCreator.Command.MDS, null)]
-        [InlineData(DiscImageCreator.Command.Reset, null)]
-        [InlineData(DiscImageCreator.Command.SACD, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.Start, null)]
-        [InlineData(DiscImageCreator.Command.Stop, null)]
-        [InlineData(DiscImageCreator.Command.Sub, null)]
-        [InlineData(DiscImageCreator.Command.Swap, MediaType.GDROM)]
-        [InlineData(DiscImageCreator.Command.XBOX, MediaType.DVD)]
-        public void BaseCommandToMediaTypeTest(DiscImageCreator.Command command, MediaType? expected)
-        {
-            MediaType? actual = DiscImageCreator.Converters.ToMediaType(command);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(DiscImageCreator.Command.Audio, KnownSystem.AudioCD)]
-        [InlineData(DiscImageCreator.Command.BluRay, KnownSystem.SonyPlayStation3)]
-        [InlineData(DiscImageCreator.Command.Close, null)]
-        [InlineData(DiscImageCreator.Command.CompactDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.Data, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.DigitalVideoDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.Eject, null)]
-        [InlineData(DiscImageCreator.Command.Floppy, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.GDROM, KnownSystem.SegaDreamcast)]
-        [InlineData(DiscImageCreator.Command.MDS, null)]
-        [InlineData(DiscImageCreator.Command.Reset, null)]
-        [InlineData(DiscImageCreator.Command.SACD, KnownSystem.SuperAudioCD)]
-        [InlineData(DiscImageCreator.Command.Start, null)]
-        [InlineData(DiscImageCreator.Command.Stop, null)]
-        [InlineData(DiscImageCreator.Command.Sub, null)]
-        [InlineData(DiscImageCreator.Command.Swap, KnownSystem.SegaDreamcast)]
-        [InlineData(DiscImageCreator.Command.XBOX, KnownSystem.MicrosoftXBOX)]
-        public void BaseCommandToKnownSystemTest(DiscImageCreator.Command command, KnownSystem? expected)
-        {
-            KnownSystem? actual = DiscImageCreator.Converters.ToKnownSystem(command);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(MediaType.CDROM, ".bin")]
-        [InlineData(MediaType.DVD, ".iso")]
-        [InlineData(MediaType.LaserDisc, ".raw")]
-        [InlineData(MediaType.NintendoWiiUOpticalDisc, ".wud")]
-        [InlineData(MediaType.FloppyDisk, ".img")]
-        [InlineData(MediaType.Cassette, ".wav")]
-        [InlineData(MediaType.NONE, null)]
-        public void MediaTypeToExtensionTest(MediaType? mediaType, string expected)
-        {
-            string actual = DiscImageCreator.Converters.Extension(mediaType);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(MediaType.CDROM, "CD-ROM")]
-        [InlineData(MediaType.LaserDisc, "LD-ROM / LV-ROM")]
-        [InlineData(MediaType.NONE, "Unknown")]
-        public void MediaTypeToStringTest(MediaType? mediaType, string expected)
-        {
-            string actual = Converters.LongName(mediaType);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(KnownSystem.MicrosoftXBOX, "Microsoft XBOX")]
-        [InlineData(KnownSystem.NECPC88, "NEC PC-88")]
-        [InlineData(KnownSystem.KonamiPython, "Konami Python")]
-        [InlineData(KnownSystem.HDDVDVideo, "HD-DVD-Video")]
-        [InlineData(KnownSystem.NONE, "Unknown")]
-        public void KnownSystemToStringTest(KnownSystem? knownSystem, string expected)
-        {
-            string actual = Converters.LongName(knownSystem);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [MemberData(nameof(KnownSystems))]
-        public void KnownSystemHasValidCategory(KnownSystemComboBoxItem system)
-        {
-            KnownSystem[] markers = { KnownSystem.MarkerArcadeEnd, KnownSystem.MarkerDiscBasedConsoleEnd, /* KnownSystem.MarkerOtherConsoleEnd, */ KnownSystem.MarkerComputerEnd, KnownSystem.MarkerOtherEnd };
-
-            // Non-system items won't map
-            if (system.IsHeader)
-                return;
-
-            // NONE will never map
-            if (system == KnownSystem.NONE)
-                return;
-
-            // we check that the category is the first category value higher than the system
-            KnownSystemCategory category = ((KnownSystem?)system).Category();
-            KnownSystem marker = KnownSystem.NONE;
-
-            switch (category)
-            {
-                case KnownSystemCategory.Arcade: marker = KnownSystem.MarkerArcadeEnd; break;
-                case KnownSystemCategory.DiscBasedConsole: marker = KnownSystem.MarkerDiscBasedConsoleEnd; break;
-                /* case KnownSystemCategory.OtherConsole: marker = KnownSystem.MarkerOtherConsoleEnd; break; */
-                case KnownSystemCategory.Computer: marker = KnownSystem.MarkerComputerEnd; break;
-                case KnownSystemCategory.Other: marker = KnownSystem.MarkerOtherEnd; break;
-            }
-
-            Assert.NotEqual(KnownSystem.NONE, marker);
-            Assert.True(marker > system);
-
-            Array.ForEach(markers, mmarker =>
-            {
-                // a marker can be the same of the found one, or one of a category before or a category after but never in the middle between
-                // the system and the mapped category
-                Assert.True(mmarker == marker || mmarker < system || mmarker > marker);
-            });
-        }
-    }
-}

MPF.Test/Utilities/DumpEnvironmentTest.cs

@@ -1,88 +0,0 @@
-using System.IO;
-using MPF.Data;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test
-{
-    public class DumpEnvironmentTest
-    {
-        [Theory]
-        [InlineData(null, 'D', false, MediaType.NONE, false)]
-        [InlineData("", 'D', false, MediaType.NONE, false)]
-        [InlineData("cd F test.bin 8 /c2 20", 'F', false, MediaType.CDROM, true)]
-        [InlineData("fd A test.img", 'A', true, MediaType.FloppyDisk, true)]
-        [InlineData("dvd X test.iso 8 /raw", 'X', false, MediaType.FloppyDisk, false)]
-        [InlineData("stop D", 'D', false, MediaType.DVD, true)]
-        public void ParametersValidTest(string parameters, char letter, bool isFloppy, MediaType? mediaType, bool expected)
-        {
-            var options = new Options() { InternalProgram = InternalProgram.DiscImageCreator };
-            var drive = isFloppy
-                ? new Drive(InternalDriveType.Floppy, new DriveInfo(letter.ToString()))
-                : new Drive(InternalDriveType.Optical, new DriveInfo(letter.ToString()));
-
-            var env = new DumpEnvironment(options, string.Empty, string.Empty, drive, KnownSystem.IBMPCCompatible, mediaType, parameters);
-
-            bool actual = env.ParametersValid();
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(null, null, null, null)]
-        [InlineData(" ", "", " ", "")]
-        [InlineData("super", "blah.bin", "super", "blah.bin")]
-        [InlineData("super\\hero", "blah.bin", "super\\hero", "blah.bin")]
-        [InlineData("super.hero", "blah.bin", "super.hero", "blah.bin")]
-        [InlineData("superhero", "blah.rev.bin", "superhero", "blah.rev.bin")]
-        [InlineData("super&hero", "blah.bin", "super&hero", "blah.bin")]
-        [InlineData("superhero", "blah&foo.bin", "superhero", "blah&foo.bin")]
-        public void FixOutputPathsTest(string outputDirectory, string outputFilename, string expectedOutputDirectory, string expectedOutputFilename)
-        {
-            (string actualOutputDirectory, string actualOutputFilename) = DumpEnvironment.NormalizeOutputPaths(outputDirectory, outputFilename, false);
-            Assert.Equal(expectedOutputDirectory, actualOutputDirectory);
-            Assert.Equal(expectedOutputFilename, actualOutputFilename);
-        }
-
-        [Fact]
-        public void GetFirstTrackTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void FormatOutputDataTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void WriteOutputDataTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void EjectDiscTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void CancelDumpingTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void StartDumpingTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-    }
-}

MPF.Test/Utilities/KnownSystemExtensionsTest.cs

@@ -1,37 +0,0 @@
-using System;
-using MPF.Data;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test.Utilities
-{
-    public class KnownSystemExtensionsTest
-    {
-        [Fact]
-        public void IsMarkerTest()
-        {
-            var values = (KnownSystem[])Enum.GetValues(typeof(KnownSystem));
-            foreach(var system in values)
-            {
-                bool expected = system == KnownSystem.MarkerArcadeEnd || system == KnownSystem.MarkerComputerEnd ||
-                                system == KnownSystem.MarkerOtherEnd || system == KnownSystem.MarkerDiscBasedConsoleEnd;
-                                // || system == KnownSystem.MarkerOtherConsoleEnd;
-
-                bool actual = ((KnownSystem?)system).IsMarker();
-
-                Assert.Equal(expected, actual);
-            }
-        }
-
-        [Fact]
-        public void CategoryNameNotEmptyTest()
-        {
-            var values = (KnownSystemCategory[])Enum.GetValues(typeof(KnownSystemCategory));
-            foreach (var system in values)
-            {
-                string actual = ((KnownSystem?)system).LongName();
-                Assert.NotEqual("", actual);
-            }
-        }
-    }
-}

MPF.Test/Utilities/MediaTypeExtensionsTest.cs

@@ -1,46 +0,0 @@
-using MPF.Data;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test.Utilities
-{
-    public class MediaTypeExtensionsTest
-    {
-        [Theory]
-        [InlineData(MediaType.CDROM, "CD-ROM")]
-        [InlineData(MediaType.LaserDisc, "LD-ROM / LV-ROM")]
-        [InlineData(MediaType.NONE, "Unknown")]
-        public void NameTest(MediaType? mediaType, string expected)
-        {
-            string actual = mediaType.LongName();
-
-            Assert.NotNull(actual);
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(MediaType.CDROM, ".bin")]
-        [InlineData(MediaType.DVD, ".iso")]
-        [InlineData(MediaType.LaserDisc, ".raw")]
-        [InlineData(MediaType.FloppyDisk, ".img")]
-        [InlineData(MediaType.NONE, null)]
-        public void ExtensionTest(MediaType? mediaType, string expected)
-        {
-            string actual = DiscImageCreator.Converters.Extension(mediaType);
-
-            Assert.Equal(expected, actual);
-        }
-
-        [Theory]
-        [InlineData(MediaType.CDROM, true)]
-        [InlineData(MediaType.DVD, true)]
-        [InlineData(MediaType.FloppyDisk, false)]
-        [InlineData(MediaType.BluRay, true)]
-        [InlineData(MediaType.LaserDisc, false)]
-        public void DriveSpeedSupportedTest(MediaType? mediaType, bool expected)
-        {
-            bool actual = mediaType.DoesSupportDriveSpeed();
-            Assert.Equal(expected, actual);
-        }
-    }
-}

MPF.Test/Utilities/ParametersTest.cs

@@ -1,71 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using MPF.Data;
-using MPF.DiscImageCreator;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test.Utilities
-{
-    public class ParametersTest
-    {
-        [Theory]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.CDROM, Command.CompactDisc)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.DVD, Command.XBOX)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.LaserDisc, Command.NONE)]
-        [InlineData(KnownSystem.SegaNu, MediaType.BluRay, Command.BluRay)]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.FloppyDisk, Command.Floppy)]
-        [InlineData(KnownSystem.RawThrillsVarious, MediaType.GDROM, Command.NONE)]
-        public void ParametersFromSystemAndTypeTest(KnownSystem? knownSystem, MediaType? mediaType, Command expected)
-        {
-            var options = new Options { };
-            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
-            Assert.Equal(expected, actual.BaseCommand);
-        }
-
-        [Theory]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.LaserDisc, true, 20, null, null)]
-        [InlineData(KnownSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, false, 20, null, new Flag[] { Flag.Raw })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 20, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
-        /* paranoid mode tests */
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.CDROM, true, 1000, 2, new Flag[] { Flag.C2Opcode, Flag.NoFixSubQSecuROM, Flag.ScanFileProtect, Flag.ScanSectorProtect, Flag.SubchannelReadLevel })]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new Flag[] { Flag.C2Opcode, Flag.NoFixSubQSecuROM, Flag.ScanFileProtect, Flag.ScanSectorProtect, Flag.SubchannelReadLevel })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, true, 500, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new Flag[] { Flag.CopyrightManagementInformation })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 500, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new Flag[] { Flag.CopyrightManagementInformation })]
-        /* reread c2 */
-        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, 1000, null, new Flag[] { Flag.C2Opcode })]
-        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new Flag[] { Flag.C2Opcode })]
-
-        public void ParametersFromOptionsTest(KnownSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, Flag[] expected)
-        {
-            var options = new Options { DICParanoidMode = paranoid, DICRereadCount = rereadC2 };
-            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
-
-            HashSet<Flag> expectedSet = new HashSet<Flag>(expected ?? new Flag[0]);
-            HashSet<Flag> actualSet = new HashSet<Flag>(actual.Keys.Cast<Flag>() ?? new Flag[0]);
-            Assert.Equal(expectedSet, actualSet);
-            if (rereadC2 == -1 || !Validators.GetValidMediaTypes(knownSystem).Contains(mediaType))
-                Assert.Null(actual.C2OpcodeValue[0]);
-            else
-                Assert.Equal(rereadC2, actual.C2OpcodeValue[0]);
-            Assert.Equal(subchannelLevel, actual.SubchannelReadLevelValue);
-        }
-
-        [Theory]
-        [InlineData(null, false)]
-        [InlineData("", false)]
-        [InlineData("cd F test.bin 8 /c2 20", true)]
-        [InlineData("fd A test.img", true)]
-        [InlineData("dvd X super\\test.iso 8 /raw", true)]
-        [InlineData("bd D longer\\path_test.iso 16", true)]
-        [InlineData("stop D", true)]
-        [InlineData("ls", false)]
-        public void ValidateParametersTest(string parameters, bool expected)
-        {
-            var actual = new Parameters(parameters);
-            Assert.Equal(expected, actual.IsValid());
-        }
-    }
-}

MPF.Test/Utilities/ValidatorsTest.cs

@@ -1,46 +0,0 @@
-using System;
-using System.Linq;
-using MPF.Data;
-using MPF.Utilities;
-using Xunit;
-
-namespace MPF.Test.Utilities
-{
-    public class ValidatorsTest
-    {
-        [Theory]
-        [InlineData(KnownSystem.BandaiApplePippin, MediaType.CDROM)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.DVD)]
-        [InlineData(KnownSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc)]
-        [InlineData(KnownSystem.NintendoWii, MediaType.NintendoWiiOpticalDisc)]
-        [InlineData(KnownSystem.NintendoWiiU, MediaType.NintendoWiiUOpticalDisc)]
-        [InlineData(KnownSystem.SonyPlayStationPortable, MediaType.UMD)]
-        public void GetValidMediaTypesTest(KnownSystem? knownSystem, MediaType? expected)
-        {
-            var actual = Validators.GetValidMediaTypes(knownSystem);
-            Assert.Contains(expected, actual);
-        }
-
-        [Fact]
-        public void CreateListOfSystemsTest()
-        {
-            int expected = Enum.GetValues(typeof(KnownSystem)).Length;
-            var actual = KnownSystemComboBoxItem.GenerateElements().ToList();
-            Assert.Equal(expected, actual.Count);
-        }
-
-        [Fact]
-        public void CreateListOfDrivesTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-
-        [Fact]
-        public void GetDiscTypeTest()
-        {
-            // TODO: Implement
-            Assert.True(true);
-        }
-    }
-}

MPF.sln

@@ -18,6 +18,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		README.md = README.md
 	EndProjectSection
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RedumpLib", "RedumpLib\RedumpLib.csproj", "{13574913-A426-4644-9955-F49AD0876E5F}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.CueSheets", "MPF.CueSheets\MPF.CueSheets.csproj", "{F2C12798-DF53-4D4C-A55B-F5A77F29D6B1}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CICMMetadataEditor", "CICMMetadata\CICMMetadataEditor\CICMMetadataEditor\CICMMetadataEditor.csproj", "{E4271454-6217-4500-BC36-F8856AC7AD6B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.Core", "MPF.Core\MPF.Core.csproj", "{70B1265D-FE49-472A-A83D-0B462152D37A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.Modules", "MPF.Modules\MPF.Modules.csproj", "{8A4254BD-552F-4238-B8EB-D59AACD768B9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -40,6 +50,26 @@ Global
 		{8CFDE289-E171-4D49-A40D-5293265C1253}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8CFDE289-E171-4D49-A40D-5293265C1253}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8CFDE289-E171-4D49-A40D-5293265C1253}.Release|Any CPU.Build.0 = Release|Any CPU
+		{13574913-A426-4644-9955-F49AD0876E5F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{13574913-A426-4644-9955-F49AD0876E5F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{13574913-A426-4644-9955-F49AD0876E5F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{13574913-A426-4644-9955-F49AD0876E5F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2C12798-DF53-4D4C-A55B-F5A77F29D6B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2C12798-DF53-4D4C-A55B-F5A77F29D6B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2C12798-DF53-4D4C-A55B-F5A77F29D6B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2C12798-DF53-4D4C-A55B-F5A77F29D6B1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E4271454-6217-4500-BC36-F8856AC7AD6B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E4271454-6217-4500-BC36-F8856AC7AD6B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E4271454-6217-4500-BC36-F8856AC7AD6B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E4271454-6217-4500-BC36-F8856AC7AD6B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{70B1265D-FE49-472A-A83D-0B462152D37A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{70B1265D-FE49-472A-A83D-0B462152D37A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{70B1265D-FE49-472A-A83D-0B462152D37A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{70B1265D-FE49-472A-A83D-0B462152D37A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8A4254BD-552F-4238-B8EB-D59AACD768B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8A4254BD-552F-4238-B8EB-D59AACD768B9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8A4254BD-552F-4238-B8EB-D59AACD768B9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8A4254BD-552F-4238-B8EB-D59AACD768B9}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

MPF/App.xaml

@@ -1,9 +1,776 @@
-<Application x:Class="MPF.App"
+<Application
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:MPF"
-             StartupUri="Windows\MainWindow.xaml">
+             xmlns:Themes="clr-namespace:Microsoft.Windows.Themes;assembly=PresentationFramework.Aero"
+             xmlns:windows="clr-namespace:MPF.Windows"
+             x:Class="MPF.App">
+    <Application.MainWindow>
+        <windows:MainWindow Visibility="Visible"/>
+    </Application.MainWindow>
+    
     <Application.Resources>
-         
+
+        <!-- Button -->
+        <SolidColorBrush x:Key="Button.Static.Background" Color="#FFDDDDDD"/>
+        <SolidColorBrush x:Key="Button.Static.Border" Color="#FF707070"/>
+        <SolidColorBrush x:Key="Button.MouseOver.Background" Color="#FFBEE6FD"/>
+        <SolidColorBrush x:Key="Button.MouseOver.Border" Color="#FF3C7FB1"/>
+        <SolidColorBrush x:Key="Button.Pressed.Background" Color="#FFC4E5F6"/>
+        <SolidColorBrush x:Key="Button.Pressed.Border" Color="#FF2C628B"/>
+        <SolidColorBrush x:Key="Button.Disabled.Background" Color="#FFF4F4F4"/>
+        <SolidColorBrush x:Key="Button.Disabled.Border" Color="#FFADB2B5"/>
+        <SolidColorBrush x:Key="Button.Disabled.Foreground" Color="#FF838383"/>
+        <Style x:Key="CustomButtonStyle" TargetType="{x:Type Button}">
+            <Setter Property="FocusVisualStyle" Value="{DynamicResource FocusVisual}"/>
+            <Setter Property="Background" Value="{DynamicResource Button.Static.Background}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource Button.Static.Border}"/>
+            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="HorizontalContentAlignment" Value="Center"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"/>
+            <Setter Property="Padding" Value="1"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type Button}">
+                        <Border x:Name="border" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" SnapsToDevicePixels="true">
+                            <ContentPresenter x:Name="contentPresenter" Focusable="False" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}"/>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsDefaulted" Value="true">
+                                <Setter Property="BorderBrush" TargetName="border" Value="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}"/>
+                            </Trigger>
+                            <Trigger Property="IsMouseOver" Value="true">
+                                <Setter Property="Background" TargetName="border" Value="{DynamicResource Button.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="border" Value="{DynamicResource Button.MouseOver.Border}"/>
+                            </Trigger>
+                            <Trigger Property="IsPressed" Value="true">
+                                <Setter Property="Background" TargetName="border" Value="{DynamicResource Button.Pressed.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="border" Value="{DynamicResource Button.Pressed.Border}"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="false">
+                                <Setter Property="Background" TargetName="border" Value="{DynamicResource Button.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="border" Value="{DynamicResource Button.Disabled.Border}"/>
+                                <Setter Property="TextElement.Foreground" TargetName="contentPresenter" Value="{DynamicResource Button.Disabled.Foreground}"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- ComboBox -->
+        <Style x:Key="FocusVisual">
+            <Setter Property="Control.Template">
+                <Setter.Value>
+                    <ControlTemplate>
+                        <Rectangle Margin="2" SnapsToDevicePixels="true" Stroke="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" StrokeThickness="1" StrokeDashArray="1 2"/>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+        <LinearGradientBrush x:Key="ComboBox.Static.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#FFF0F0F0" Offset="0.0"/>
+            <GradientStop Color="#FFE5E5E5" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="ComboBox.Static.Border" Color="#FFACACAC"/>
+        <SolidColorBrush x:Key="ComboBox.Static.Editable.Background" Color="#FFFFFFFF"/>
+        <SolidColorBrush x:Key="ComboBox.Static.Editable.Border" Color="#FFABADB3"/>
+        <SolidColorBrush x:Key="ComboBox.Static.Editable.Button.Background" Color="Transparent"/>
+        <SolidColorBrush x:Key="ComboBox.Static.Editable.Button.Border" Color="Transparent"/>
+        <SolidColorBrush x:Key="ComboBox.MouseOver.Glyph" Color="#FF000000"/>
+        <LinearGradientBrush x:Key="ComboBox.MouseOver.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#FFECF4FC" Offset="0.0"/>
+            <GradientStop Color="#FFDCECFC" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="ComboBox.MouseOver.Border" Color="#FF7EB4EA"/>
+        <SolidColorBrush x:Key="ComboBox.MouseOver.Editable.Background" Color="#FFFFFFFF"/>
+        <SolidColorBrush x:Key="ComboBox.MouseOver.Editable.Border" Color="#FF7EB4EA"/>
+        <LinearGradientBrush x:Key="ComboBox.MouseOver.Editable.Button.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#FFEBF4FC" Offset="0.0"/>
+            <GradientStop Color="#FFDCECFC" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="ComboBox.MouseOver.Editable.Button.Border" Color="#FF7EB4EA"/>
+        <SolidColorBrush x:Key="ComboBox.Pressed.Glyph" Color="#FF000000"/>
+        <LinearGradientBrush x:Key="ComboBox.Pressed.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#FFDAECFC" Offset="0.0"/>
+            <GradientStop Color="#FFC4E0FC" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="ComboBox.Pressed.Border" Color="#FF569DE5"/>
+        <SolidColorBrush x:Key="ComboBox.Pressed.Editable.Background" Color="#FFFFFFFF"/>
+        <SolidColorBrush x:Key="ComboBox.Pressed.Editable.Border" Color="#FF569DE5"/>
+        <LinearGradientBrush x:Key="ComboBox.Pressed.Editable.Button.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#FFDAEBFC" Offset="0.0"/>
+            <GradientStop Color="#FFC4E0FC" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="ComboBox.Pressed.Editable.Button.Border" Color="#FF569DE5"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Glyph" Color="#FFBFBFBF"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Background" Color="#FFF0F0F0"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Border" Color="#FFD9D9D9"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Editable.Background" Color="#FFFFFFFF"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Editable.Border" Color="#FFBFBFBF"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Editable.Button.Background" Color="Transparent"/>
+        <SolidColorBrush x:Key="ComboBox.Disabled.Editable.Button.Border" Color="Transparent"/>
+        <SolidColorBrush x:Key="ComboBox.Static.Glyph" Color="#FF606060"/>
+        <Style x:Key="ComboBoxToggleButton" TargetType="{x:Type ToggleButton}">
+            <Setter Property="OverridesDefaultStyle" Value="true"/>
+            <Setter Property="IsTabStop" Value="false"/>
+            <Setter Property="Focusable" Value="false"/>
+            <Setter Property="ClickMode" Value="Press"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type ToggleButton}">
+                        <Border x:Name="templateRoot" BorderBrush="{DynamicResource ComboBox.Static.Border}" BorderThickness="{TemplateBinding BorderThickness}" Background="{DynamicResource ComboBox.Static.Background}" SnapsToDevicePixels="true">
+                            <Border x:Name="splitBorder" BorderBrush="Transparent" BorderThickness="1" HorizontalAlignment="Right" Margin="0" SnapsToDevicePixels="true" Width="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}">
+                                <Path x:Name="arrow" Data="F1 M 0,0 L 2.667,2.66665 L 5.3334,0 L 5.3334,-1.78168 L 2.6667,0.88501 L0,-1.78168 L0,0 Z" Fill="{DynamicResource ComboBox.Static.Glyph}" HorizontalAlignment="Center" Margin="0" VerticalAlignment="Center"/>
+                            </Border>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="true"/>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding IsPressed, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.Static.Editable.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.Static.Editable.Border}"/>
+                                <Setter Property="Background" TargetName="splitBorder" Value="{DynamicResource ComboBox.Static.Editable.Button.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="splitBorder" Value="{DynamicResource ComboBox.Static.Editable.Button.Border}"/>
+                            </MultiDataTrigger>
+                            <Trigger Property="IsMouseOver" Value="true">
+                                <Setter Property="Fill" TargetName="arrow" Value="{DynamicResource ComboBox.MouseOver.Glyph}"/>
+                            </Trigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="false"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.MouseOver.Border}"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="true"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.MouseOver.Editable.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.MouseOver.Editable.Border}"/>
+                                <Setter Property="Background" TargetName="splitBorder" Value="{DynamicResource ComboBox.MouseOver.Editable.Button.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="splitBorder" Value="{DynamicResource ComboBox.MouseOver.Editable.Button.Border}"/>
+                            </MultiDataTrigger>
+                            <Trigger Property="IsPressed" Value="true">
+                                <Setter Property="Fill" TargetName="arrow" Value="{DynamicResource ComboBox.Pressed.Glyph}"/>
+                            </Trigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsPressed, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="false"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.Pressed.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.Pressed.Border}"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsPressed, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="true"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.Pressed.Editable.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.Pressed.Editable.Border}"/>
+                                <Setter Property="Background" TargetName="splitBorder" Value="{DynamicResource ComboBox.Pressed.Editable.Button.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="splitBorder" Value="{DynamicResource ComboBox.Pressed.Editable.Button.Border}"/>
+                            </MultiDataTrigger>
+                            <Trigger Property="IsEnabled" Value="false">
+                                <Setter Property="Fill" TargetName="arrow" Value="{DynamicResource ComboBox.Disabled.Glyph}"/>
+                            </Trigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="false"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.Disabled.Border}"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding IsEditable, RelativeSource={RelativeSource AncestorType={x:Type ComboBox}}}" Value="true"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="templateRoot" Value="{DynamicResource ComboBox.Disabled.Editable.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="templateRoot" Value="{DynamicResource ComboBox.Disabled.Editable.Border}"/>
+                                <Setter Property="Background" TargetName="splitBorder" Value="{DynamicResource ComboBox.Disabled.Editable.Button.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="splitBorder" Value="{DynamicResource ComboBox.Disabled.Editable.Button.Border}"/>
+                            </MultiDataTrigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+        <ControlTemplate x:Key="ComboBoxTemplate" TargetType="{x:Type ComboBox}">
+            <Grid x:Name="templateRoot" SnapsToDevicePixels="true">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition MinWidth="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}" Width="0"/>
+                </Grid.ColumnDefinitions>
+                <Popup x:Name="PART_Popup" AllowsTransparency="true" Grid.ColumnSpan="2" IsOpen="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" Margin="1" PopupAnimation="{DynamicResource {x:Static SystemParameters.ComboBoxPopupAnimationKey}}" Placement="Bottom">
+                    <Themes:SystemDropShadowChrome x:Name="shadow" Color="Transparent" MaxHeight="{TemplateBinding MaxDropDownHeight}" MinWidth="{Binding ActualWidth, ElementName=templateRoot}">
+                        <Border x:Name="dropDownBorder" BorderBrush="{DynamicResource {x:Static SystemColors.WindowFrameBrushKey}}" BorderThickness="1" Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}">
+                            <ScrollViewer x:Name="DropDownScrollViewer">
+                                <Grid x:Name="grid" RenderOptions.ClearTypeHint="Enabled">
+                                    <Canvas x:Name="canvas" HorizontalAlignment="Left" Height="0" VerticalAlignment="Top" Width="0">
+                                        <Rectangle x:Name="opaqueRect" Fill="{Binding Background, ElementName=dropDownBorder}" Height="{Binding ActualHeight, ElementName=dropDownBorder}" Width="{Binding ActualWidth, ElementName=dropDownBorder}"/>
+                                    </Canvas>
+                                    <ItemsPresenter x:Name="ItemsPresenter" KeyboardNavigation.DirectionalNavigation="Contained" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                                </Grid>
+                            </ScrollViewer>
+                        </Border>
+                    </Themes:SystemDropShadowChrome>
+                </Popup>
+                <ToggleButton x:Name="toggleButton" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" Grid.ColumnSpan="2" IsChecked="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" Style="{DynamicResource ComboBoxToggleButton}"/>
+                <ContentPresenter x:Name="contentPresenter" ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}" ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}" Content="{TemplateBinding SelectionBoxItem}" ContentStringFormat="{TemplateBinding SelectionBoxItemStringFormat}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" IsHitTestVisible="false" Margin="{TemplateBinding Padding}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}"/>
+            </Grid>
+            <ControlTemplate.Triggers>
+                <Trigger Property="HasDropShadow" SourceName="PART_Popup" Value="true">
+                    <Setter Property="Margin" TargetName="shadow" Value="0,0,5,5"/>
+                    <Setter Property="Color" TargetName="shadow" Value="#71000000"/>
+                </Trigger>
+                <Trigger Property="HasItems" Value="false">
+                    <Setter Property="Height" TargetName="dropDownBorder" Value="95"/>
+                </Trigger>
+                <MultiTrigger>
+                    <MultiTrigger.Conditions>
+                        <Condition Property="IsGrouping" Value="true"/>
+                        <Condition Property="VirtualizingPanel.IsVirtualizingWhenGrouping" Value="false"/>
+                    </MultiTrigger.Conditions>
+                    <Setter Property="ScrollViewer.CanContentScroll" Value="false"/>
+                </MultiTrigger>
+                <Trigger Property="ScrollViewer.CanContentScroll" SourceName="DropDownScrollViewer" Value="false">
+                    <Setter Property="Canvas.Top" TargetName="opaqueRect" Value="{Binding VerticalOffset, ElementName=DropDownScrollViewer}"/>
+                    <Setter Property="Canvas.Left" TargetName="opaqueRect" Value="{Binding HorizontalOffset, ElementName=DropDownScrollViewer}"/>
+                </Trigger>
+            </ControlTemplate.Triggers>
+        </ControlTemplate>
+        <SolidColorBrush x:Key="TextBox.Static.Background" Color="#FFFFFFFF"/>
+        <Style x:Key="ComboBoxEditableTextBox" TargetType="{x:Type TextBox}">
+            <Setter Property="OverridesDefaultStyle" Value="true"/>
+            <Setter Property="AllowDrop" Value="true"/>
+            <Setter Property="MinWidth" Value="0"/>
+            <Setter Property="MinHeight" Value="0"/>
+            <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+            <Setter Property="ScrollViewer.PanningMode" Value="VerticalFirst"/>
+            <Setter Property="Stylus.IsFlicksEnabled" Value="False"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type TextBox}">
+                        <ScrollViewer x:Name="PART_ContentHost" Background="Transparent" Focusable="false" HorizontalScrollBarVisibility="Hidden" VerticalScrollBarVisibility="Hidden"/>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+        <ControlTemplate x:Key="ComboBoxEditableTemplate" TargetType="{x:Type ComboBox}">
+            <Grid x:Name="templateRoot" SnapsToDevicePixels="true">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition MinWidth="{DynamicResource {x:Static SystemParameters.VerticalScrollBarWidthKey}}" Width="0"/>
+                </Grid.ColumnDefinitions>
+                <Popup x:Name="PART_Popup" AllowsTransparency="true" Grid.ColumnSpan="2" IsOpen="{Binding IsDropDownOpen, RelativeSource={RelativeSource TemplatedParent}}" PopupAnimation="{DynamicResource {x:Static SystemParameters.ComboBoxPopupAnimationKey}}" Placement="Bottom">
+                    <Themes:SystemDropShadowChrome x:Name="shadow" Color="Transparent" MaxHeight="{TemplateBinding MaxDropDownHeight}" MinWidth="{Binding ActualWidth, ElementName=templateRoot}">
+                        <Border x:Name="dropDownBorder" BorderBrush="{DynamicResource {x:Static SystemColors.WindowFrameBrushKey}}" BorderThickness="1" Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}">
+                            <ScrollViewer x:Name="DropDownScrollViewer">
+                                <Grid x:Name="grid" RenderOptions.ClearTypeHint="Enabled">
+                                    <Canvas x:Name="canvas" HorizontalAlignment="Left" Height="0" VerticalAlignment="Top" Width="0">
+                                        <Rectangle x:Name="opaqueRect" Fill="{Binding Background, ElementName=dropDownBorder}" Height="{Binding ActualHeight, ElementName=dropDownBorder}" Width="{Binding ActualWidth, ElementName=dropDownBorder}"/>
+                                    </Canvas>
+                                    <ItemsPresenter x:Name="ItemsPresenter" KeyboardNavigation.DirectionalNavigation="Contained" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                                </Grid>
+                            </ScrollViewer>
+                        </Border>
+                    </Themes:SystemDropShadowChrome>
+                </Popup>
+                <ToggleButton x:Name="toggleButton" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" Grid.ColumnSpan="2" IsChecked="{Binding IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" Style="{DynamicResource ComboBoxToggleButton}"/>
+                <Border x:Name="border" Background="{DynamicResource TextBox.Static.Background}" Margin="{TemplateBinding BorderThickness}">
+                    <TextBox x:Name="PART_EditableTextBox" HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" IsReadOnly="{Binding IsReadOnly, RelativeSource={RelativeSource TemplatedParent}}" Margin="{TemplateBinding Padding}" Style="{DynamicResource ComboBoxEditableTextBox}" VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"/>
+                </Border>
+            </Grid>
+            <ControlTemplate.Triggers>
+                <Trigger Property="IsEnabled" Value="false">
+                    <Setter Property="Opacity" TargetName="border" Value="0.56"/>
+                </Trigger>
+                <Trigger Property="IsKeyboardFocusWithin" Value="true">
+                    <Setter Property="Foreground" Value="Black"/>
+                </Trigger>
+                <Trigger Property="HasDropShadow" SourceName="PART_Popup" Value="true">
+                    <Setter Property="Margin" TargetName="shadow" Value="0,0,5,5"/>
+                    <Setter Property="Color" TargetName="shadow" Value="#71000000"/>
+                </Trigger>
+                <Trigger Property="HasItems" Value="false">
+                    <Setter Property="Height" TargetName="dropDownBorder" Value="95"/>
+                </Trigger>
+                <MultiTrigger>
+                    <MultiTrigger.Conditions>
+                        <Condition Property="IsGrouping" Value="true"/>
+                        <Condition Property="VirtualizingPanel.IsVirtualizingWhenGrouping" Value="false"/>
+                    </MultiTrigger.Conditions>
+                    <Setter Property="ScrollViewer.CanContentScroll" Value="false"/>
+                </MultiTrigger>
+                <Trigger Property="ScrollViewer.CanContentScroll" SourceName="DropDownScrollViewer" Value="false">
+                    <Setter Property="Canvas.Top" TargetName="opaqueRect" Value="{Binding VerticalOffset, ElementName=DropDownScrollViewer}"/>
+                    <Setter Property="Canvas.Left" TargetName="opaqueRect" Value="{Binding HorizontalOffset, ElementName=DropDownScrollViewer}"/>
+                </Trigger>
+            </ControlTemplate.Triggers>
+        </ControlTemplate>
+        <Style x:Key="CustomComboBoxStyle" TargetType="{x:Type ComboBox}">
+            <Setter Property="FocusVisualStyle" Value="{DynamicResource FocusVisual}"/>
+            <Setter Property="Background" Value="{DynamicResource ComboBox.Static.Background}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource ComboBox.Static.Border}"/>
+            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Auto"/>
+            <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto"/>
+            <Setter Property="Padding" Value="6,3,5,3"/>
+            <Setter Property="ScrollViewer.CanContentScroll" Value="true"/>
+            <Setter Property="ScrollViewer.PanningMode" Value="Both"/>
+            <Setter Property="Stylus.IsFlicksEnabled" Value="False"/>
+            <Setter Property="Template" Value="{DynamicResource ComboBoxTemplate}"/>
+            <Style.Triggers>
+                <Trigger Property="IsEditable" Value="true">
+                    <Setter Property="IsTabStop" Value="false"/>
+                    <Setter Property="Padding" Value="2"/>
+                    <Setter Property="Template" Value="{DynamicResource ComboBoxEditableTemplate}"/>
+                </Trigger>
+            </Style.Triggers>
+        </Style>
+
+        <!-- ContextMenu -->
+        <SolidColorBrush x:Key="ContextMenu.Static.Border" Color="#FF888888"/>
+        <Style x:Key="CustomContextMenuStyle" TargetType="{x:Type ContextMenu}">
+            <Setter Property="SnapsToDevicePixels" Value="True" />
+            <Setter Property="OverridesDefaultStyle" Value="True" />
+            <Setter Property="Grid.IsSharedSizeScope" Value="true" />
+            <Setter Property="HasDropShadow" Value="True" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type ContextMenu}">
+                        <Border x:Name="Border" Background="{Binding Background}" BorderBrush="{DynamicResource ContextMenu.Static.Border}" BorderThickness="1">
+                            <StackPanel IsItemsHost="True" KeyboardNavigation.DirectionalNavigation="Cycle" />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="HasDropShadow" Value="true">
+                                <Setter TargetName="Border" Property="Padding" Value="0,3,0,3" />
+                                <Setter TargetName="Border" Property="CornerRadius" Value="4" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- CustomMessageBox -->
+        <SolidColorBrush x:Key="CustomMessageBox.Static.Background" Color="#FFE5E5E5"/>
+
+        <!-- MenuItem -->
+        <SolidColorBrush x:Key="MenuItem.SubMenu.Background" Color="#FFF0F0F0"/>
+        <SolidColorBrush x:Key="MenuItem.SubMenu.Border" Color="#FF999999"/>
+        <SolidColorBrush x:Key="MenuItem.SubMenu.HoverRectangle" Color="Transparent"/>
+        <ControlTemplate x:Key="CustomMenuItemTemplate" TargetType="{x:Type MenuItem}">
+            <Border x:Name="templateRoot" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" SnapsToDevicePixels="True">
+                <Grid VerticalAlignment="Center">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    <ContentPresenter x:Name="Icon" Content="{TemplateBinding Icon}" ContentSource="Icon" HorizontalAlignment="Center" Height="16" Margin="3" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="Center" Width="16"/>
+                    <Path x:Name="GlyphPanel" Data="F1M10,1.2L4.7,9.1 4.5,9.1 0,5.2 1.3,3.5 4.3,6.1 8.3,0 10,1.2z" Fill="{TemplateBinding Foreground}" FlowDirection="LeftToRight" Margin="3" Visibility="Collapsed" VerticalAlignment="Center"/>
+                    <ContentPresenter ContentTemplate="{TemplateBinding HeaderTemplate}" Content="{TemplateBinding Header}" Grid.Column="1" ContentStringFormat="{TemplateBinding HeaderStringFormat}" ContentSource="Header" Margin="{TemplateBinding Padding}" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                    <Popup x:Name="PART_Popup" AllowsTransparency="True" Focusable="False" IsOpen="{Binding IsSubmenuOpen, RelativeSource={RelativeSource TemplatedParent}}" PopupAnimation="{DynamicResource {x:Static SystemParameters.MenuPopupAnimationKey}}" Placement="Bottom">
+                        <Border x:Name="SubMenuBorder" BorderBrush="{DynamicResource MenuItem.SubMenu.Border}" BorderThickness="1" Background="{DynamicResource MenuItem.SubMenu.Background}" Padding="2">
+                            <ScrollViewer x:Name="SubMenuScrollViewer" Style="{DynamicResource {ComponentResourceKey ResourceId=MenuScrollViewer, TypeInTargetAssembly={x:Type FrameworkElement}}}">
+                                <Grid RenderOptions.ClearTypeHint="Enabled">
+                                    <Canvas HorizontalAlignment="Left" Height="0" VerticalAlignment="Top" Width="0">
+                                        <Rectangle x:Name="OpaqueRect" Fill="{Binding Background, ElementName=SubMenuBorder}" Height="{Binding ActualHeight, ElementName=SubMenuBorder}" Width="{Binding ActualWidth, ElementName=SubMenuBorder}"/>
+                                    </Canvas>
+                                    <Rectangle Fill="{DynamicResource MenuItem.SubMenu.HoverRectangle}" HorizontalAlignment="Left" Margin="29,2,0,2" Width="1"/>
+                                    <ItemsPresenter x:Name="ItemsPresenter" KeyboardNavigation.DirectionalNavigation="Cycle" Grid.IsSharedSizeScope="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" KeyboardNavigation.TabNavigation="Cycle"/>
+                                </Grid>
+                            </ScrollViewer>
+                        </Border>
+                    </Popup>
+                </Grid>
+            </Border>
+            <ControlTemplate.Triggers>
+                <Trigger Property="IsSuspendingPopupAnimation" Value="True">
+                    <Setter Property="PopupAnimation" TargetName="PART_Popup" Value="None"/>
+                </Trigger>
+                <Trigger Property="Icon" Value="{x:Null}">
+                    <Setter Property="Visibility" TargetName="Icon" Value="Collapsed"/>
+                </Trigger>
+                <Trigger Property="IsChecked" Value="True">
+                    <Setter Property="Visibility" TargetName="GlyphPanel" Value="Visible"/>
+                    <Setter Property="Visibility" TargetName="Icon" Value="Collapsed"/>
+                </Trigger>
+                <Trigger Property="IsHighlighted" Value="True">
+                    <Setter Property="Background" TargetName="templateRoot" Value="#3D26A0DA"/>
+                    <Setter Property="BorderBrush" TargetName="templateRoot" Value="#FF26A0DA"/>
+                </Trigger>
+                <Trigger Property="IsEnabled" Value="False">
+                    <Setter Property="TextElement.Foreground" TargetName="templateRoot" Value="#FF707070"/>
+                    <Setter Property="Fill" TargetName="GlyphPanel" Value="#FF707070"/>
+                </Trigger>
+                <Trigger Property="CanContentScroll" SourceName="SubMenuScrollViewer" Value="False">
+                    <Setter Property="Canvas.Top" TargetName="OpaqueRect" Value="{Binding VerticalOffset, ElementName=SubMenuScrollViewer}"/>
+                    <Setter Property="Canvas.Left" TargetName="OpaqueRect" Value="{Binding HorizontalOffset, ElementName=SubMenuScrollViewer}"/>
+                </Trigger>
+            </ControlTemplate.Triggers>
+        </ControlTemplate>
+
+        <!-- ProgressBar -->
+        <SolidColorBrush x:Key="ProgressBar.Progress" Color="#FF06B025"/>
+        <SolidColorBrush x:Key="ProgressBar.Background" Color="#FFE6E6E6"/>
+        <SolidColorBrush x:Key="ProgressBar.Border" Color="#FFBCBCBC"/>
+        <Style x:Key="CustomProgressBarStyle" TargetType="{x:Type ProgressBar}">
+            <Setter Property="Foreground" Value="{DynamicResource ProgressBar.Progress}"/>
+            <Setter Property="Background" Value="{DynamicResource ProgressBar.Background}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource ProgressBar.Border}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type ProgressBar}">
+                        <Grid x:Name="TemplateRoot">
+                            <VisualStateManager.VisualStateGroups>
+                                <VisualStateGroup x:Name="CommonStates">
+                                    <VisualState x:Name="Determinate"/>
+                                    <VisualState x:Name="Indeterminate">
+                                        <Storyboard RepeatBehavior="Forever">
+                                            <DoubleAnimationUsingKeyFrames Storyboard.TargetProperty="(UIElement.RenderTransform).(TransformGroup.Children)[0].(ScaleTransform.ScaleX)" Storyboard.TargetName="Animation">
+                                                <EasingDoubleKeyFrame KeyTime="0" Value="0.25"/>
+                                                <EasingDoubleKeyFrame KeyTime="0:0:1" Value="0.25"/>
+                                                <EasingDoubleKeyFrame KeyTime="0:0:2" Value="0.25"/>
+                                            </DoubleAnimationUsingKeyFrames>
+                                            <PointAnimationUsingKeyFrames Storyboard.TargetProperty="(UIElement.RenderTransformOrigin)" Storyboard.TargetName="Animation">
+                                                <EasingPointKeyFrame KeyTime="0" Value="-0.5,0.5"/>
+                                                <EasingPointKeyFrame KeyTime="0:0:1" Value="0.5,0.5"/>
+                                                <EasingPointKeyFrame KeyTime="0:0:2" Value="1.5,0.5"/>
+                                            </PointAnimationUsingKeyFrames>
+                                        </Storyboard>
+                                    </VisualState>
+                                </VisualStateGroup>
+                            </VisualStateManager.VisualStateGroups>
+                            <Border BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}"/>
+                            <Rectangle x:Name="PART_Track"/>
+                            <Grid x:Name="PART_Indicator" ClipToBounds="true" HorizontalAlignment="Left">
+                                <Rectangle x:Name="Indicator" Fill="{TemplateBinding Foreground}"/>
+                                <Rectangle x:Name="Animation" Fill="{TemplateBinding Foreground}" RenderTransformOrigin="0.5,0.5">
+                                    <Rectangle.RenderTransform>
+                                        <TransformGroup>
+                                            <ScaleTransform/>
+                                            <SkewTransform/>
+                                            <RotateTransform/>
+                                            <TranslateTransform/>
+                                        </TransformGroup>
+                                    </Rectangle.RenderTransform>
+                                </Rectangle>
+                            </Grid>
+                        </Grid>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="Orientation" Value="Vertical">
+                                <Setter Property="LayoutTransform" TargetName="TemplateRoot">
+                                    <Setter.Value>
+                                        <RotateTransform Angle="-90"/>
+                                    </Setter.Value>
+                                </Setter>
+                            </Trigger>
+                            <Trigger Property="IsIndeterminate" Value="true">
+                                <Setter Property="Visibility" TargetName="Indicator" Value="Collapsed"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- ScrollViewer -->
+        <SolidColorBrush x:Key="ScrollViewer.ScrollBar.Background" Color="LightGray"/>
+        <SolidColorBrush x:Key="ScrollViewer.ScrollBar.Foreground" Color="DarkGray"/>
+        <ControlTemplate x:Key="CustomScrollViewerControlStyle" TargetType="{x:Type ScrollViewer}">
+            <Grid x:Name="Grid" Background="{TemplateBinding Background}">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="*"/>
+                    <RowDefinition Height="Auto"/>
+                </Grid.RowDefinitions>
+                <Rectangle x:Name="Corner" Grid.Column="1" Fill="{DynamicResource {x:Static SystemColors.ControlBrushKey}}" Grid.Row="1"/>
+                <ScrollContentPresenter x:Name="PART_ScrollContentPresenter" CanContentScroll="{TemplateBinding CanContentScroll}" CanHorizontallyScroll="False" CanVerticallyScroll="False" ContentTemplate="{TemplateBinding ContentTemplate}" Content="{TemplateBinding Content}" Grid.Column="0" Margin="{TemplateBinding Padding}" Grid.Row="0"/>
+                <ScrollBar x:Name="PART_VerticalScrollBar" AutomationProperties.AutomationId="VerticalScrollBar" Cursor="Arrow" Grid.Column="1" Maximum="{TemplateBinding ScrollableHeight}" Minimum="0" Grid.Row="0" Visibility="{TemplateBinding ComputedVerticalScrollBarVisibility}" Value="{Binding VerticalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}" ViewportSize="{TemplateBinding ViewportHeight}" Background="{DynamicResource ScrollViewer.ScrollBar.Background}" Foreground="{DynamicResource ScrollViewer.ScrollBar.Foreground}"/>
+                <ScrollBar x:Name="PART_HorizontalScrollBar" AutomationProperties.AutomationId="HorizontalScrollBar" Cursor="Arrow" Grid.Column="0" Maximum="{TemplateBinding ScrollableWidth}" Minimum="0" Orientation="Horizontal" Grid.Row="1" Visibility="{TemplateBinding ComputedHorizontalScrollBarVisibility}" Value="{Binding HorizontalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}" ViewportSize="{TemplateBinding ViewportWidth}" Background="{DynamicResource ScrollViewer.ScrollBar.Background}" Foreground="{DynamicResource ScrollViewer.ScrollBar.Foreground}"/>
+            </Grid>
+        </ControlTemplate>
+
+        <!-- TabControl -->
+        <SolidColorBrush x:Key="TabItem.Selected.Background" Color="#FFFFFF"/>
+        <SolidColorBrush x:Key="TabItem.Selected.Border" Color="#ACACAC"/>
+        <Style x:Key="CustomTabControlStyle" TargetType="{x:Type TabControl}">
+            <Setter Property="Padding" Value="2"/>
+            <Setter Property="HorizontalContentAlignment" Value="Center"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"/>
+            <Setter Property="Background" Value="{DynamicResource TabItem.Selected.Background}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource TabItem.Selected.Border}"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type TabControl}">
+                        <Grid x:Name="templateRoot" ClipToBounds="true" SnapsToDevicePixels="true" KeyboardNavigation.TabNavigation="Local">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition x:Name="ColumnDefinition0"/>
+                                <ColumnDefinition x:Name="ColumnDefinition1" Width="0"/>
+                            </Grid.ColumnDefinitions>
+                            <Grid.RowDefinitions>
+                                <RowDefinition x:Name="RowDefinition0" Height="Auto"/>
+                                <RowDefinition x:Name="RowDefinition1" Height="*"/>
+                            </Grid.RowDefinitions>
+                            <TabPanel x:Name="headerPanel" Background="Transparent" Grid.Column="0" IsItemsHost="true" Margin="2,2,2,0" Grid.Row="0" KeyboardNavigation.TabIndex="1" Panel.ZIndex="1"/>
+                            <Border x:Name="contentPanel" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" Grid.Column="0" KeyboardNavigation.DirectionalNavigation="Contained" Grid.Row="1" KeyboardNavigation.TabIndex="2" KeyboardNavigation.TabNavigation="Local">
+                                <ContentPresenter x:Name="PART_SelectedContentHost" ContentSource="SelectedContent" Margin="{TemplateBinding Padding}" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"/>
+                            </Border>
+                        </Grid>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="TabStripPlacement" Value="Bottom">
+                                <Setter Property="Grid.Row" TargetName="headerPanel" Value="1"/>
+                                <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
+                                <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                                <Setter Property="Height" TargetName="RowDefinition1" Value="Auto"/>
+                                <Setter Property="Margin" TargetName="headerPanel" Value="2,0,2,2"/>
+                            </Trigger>
+                            <Trigger Property="TabStripPlacement" Value="Left">
+                                <Setter Property="Grid.Row" TargetName="headerPanel" Value="0"/>
+                                <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
+                                <Setter Property="Grid.Column" TargetName="headerPanel" Value="0"/>
+                                <Setter Property="Grid.Column" TargetName="contentPanel" Value="1"/>
+                                <Setter Property="Width" TargetName="ColumnDefinition0" Value="Auto"/>
+                                <Setter Property="Width" TargetName="ColumnDefinition1" Value="*"/>
+                                <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                                <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                                <Setter Property="Margin" TargetName="headerPanel" Value="2,2,0,2"/>
+                            </Trigger>
+                            <Trigger Property="TabStripPlacement" Value="Right">
+                                <Setter Property="Grid.Row" TargetName="headerPanel" Value="0"/>
+                                <Setter Property="Grid.Row" TargetName="contentPanel" Value="0"/>
+                                <Setter Property="Grid.Column" TargetName="headerPanel" Value="1"/>
+                                <Setter Property="Grid.Column" TargetName="contentPanel" Value="0"/>
+                                <Setter Property="Width" TargetName="ColumnDefinition0" Value="*"/>
+                                <Setter Property="Width" TargetName="ColumnDefinition1" Value="Auto"/>
+                                <Setter Property="Height" TargetName="RowDefinition0" Value="*"/>
+                                <Setter Property="Height" TargetName="RowDefinition1" Value="0"/>
+                                <Setter Property="Margin" TargetName="headerPanel" Value="0,2,2,2"/>
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="false">
+                                <Setter Property="TextElement.Foreground" TargetName="templateRoot" Value="{DynamicResource {x:Static SystemColors.GrayTextBrushKey}}"/>
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <!-- TabItem -->
+        <LinearGradientBrush x:Key="TabItem.Static.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#F0F0F0" Offset="0.0"/>
+            <GradientStop Color="#E5E5E5" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="TabItem.Static.Border" Color="#ACACAC"/>
+        <LinearGradientBrush x:Key="TabItem.MouseOver.Background" EndPoint="0,1" StartPoint="0,0">
+            <GradientStop Color="#ECF4FC" Offset="0.0"/>
+            <GradientStop Color="#DCECFC" Offset="1.0"/>
+        </LinearGradientBrush>
+        <SolidColorBrush x:Key="TabItem.MouseOver.Border" Color="#7EB4EA"/>
+        <SolidColorBrush x:Key="TabItem.Disabled.Background" Color="#F0F0F0"/>
+        <SolidColorBrush x:Key="TabItem.Disabled.Border" Color="#D9D9D9"/>
+        <Style x:Key="CustomTabItemStyle" TargetType="{x:Type TabItem}">
+            <Setter Property="FocusVisualStyle" Value="{DynamicResource FocusVisual}"/>
+            <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"/>
+            <Setter Property="Background" Value="{DynamicResource TabItem.Static.Background}"/>
+            <Setter Property="BorderBrush" Value="{DynamicResource TabItem.Static.Border}"/>
+            <Setter Property="Margin" Value="0"/>
+            <Setter Property="Padding" Value="6,2,6,2"/>
+            <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
+            <Setter Property="VerticalContentAlignment" Value="Stretch"/>
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="{x:Type TabItem}">
+                        <Grid x:Name="templateRoot" SnapsToDevicePixels="true">
+                            <Border x:Name="mainBorder" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="1,1,1,0" Background="{TemplateBinding Background}" Margin="0">
+                                <Border x:Name="innerBorder" BorderBrush="{DynamicResource TabItem.Selected.Border}" BorderThickness="1,1,1,0" Background="{DynamicResource TabItem.Selected.Background}" Margin="-1" Opacity="0"/>
+                            </Border>
+                            <ContentPresenter x:Name="contentPresenter" ContentSource="Header" Focusable="False" HorizontalAlignment="{Binding HorizontalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}" Margin="{TemplateBinding Padding}" RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" VerticalAlignment="{Binding VerticalContentAlignment, RelativeSource={RelativeSource AncestorType={x:Type ItemsControl}}}"/>
+                        </Grid>
+                        <ControlTemplate.Triggers>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.MouseOver.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Opacity" TargetName="contentPresenter" Value="0.56"/>
+                                <Setter Property="Background" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Background}"/>
+                                <Setter Property="BorderBrush" TargetName="mainBorder" Value="{DynamicResource TabItem.Disabled.Border}"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Left"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Panel.ZIndex" Value="1"/>
+                                <Setter Property="Margin" Value="-2,-2,0,-2"/>
+                                <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,0,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,0,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Bottom"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Panel.ZIndex" Value="1"/>
+                                <Setter Property="Margin" Value="-2,0,-2,-2"/>
+                                <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,0,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,0,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Right"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Panel.ZIndex" Value="1"/>
+                                <Setter Property="Margin" Value="0,-2,-2,-2"/>
+                                <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="0,1,1,1"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="0,1,1,1"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="false"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
+                            </MultiDataTrigger>
+                            <MultiDataTrigger>
+                                <MultiDataTrigger.Conditions>
+                                    <Condition Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="true"/>
+                                    <Condition Binding="{Binding TabStripPlacement, RelativeSource={RelativeSource AncestorType={x:Type TabControl}}}" Value="Top"/>
+                                </MultiDataTrigger.Conditions>
+                                <Setter Property="Panel.ZIndex" Value="1"/>
+                                <Setter Property="Margin" Value="-2,-2,-2,0"/>
+                                <Setter Property="Opacity" TargetName="innerBorder" Value="1"/>
+                                <Setter Property="BorderThickness" TargetName="innerBorder" Value="1,1,1,0"/>
+                                <Setter Property="BorderThickness" TargetName="mainBorder" Value="1,1,1,0"/>
+                            </MultiDataTrigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
     </Application.Resources>
 </Application>

MPF/App.xaml.cs

@@ -1,11 +1,60 @@
 using System.Windows;
+using MPF.Core.Data;
+using MPF.GUI.ViewModels;
+using MPF.Windows;
 
 namespace MPF
 {
     /// <summary>
     /// Interaction logic for App.xaml
     /// </summary>
+    /// <remarks>
+    /// This application is not fully MVVM. The following steps are needed to get there:
+    /// - Use commands instead of event handlers, where at all possible
+    /// - Reduce the amount of manual UI adjustments needed, instead binding to the view models
+    /// </remarks>
     public partial class App : Application
     {
+        /// <summary>
+        /// Static application instance for reference
+        /// </summary>
+        private static App _appInstance;
+
+        /// <summary>
+        /// Read-only access to the current main window
+        /// </summary>
+        public static MainWindow Instance => _appInstance.MainWindow as MainWindow;
+
+        /// <summary>
+        /// Read-only access to the current log window
+        /// </summary>
+        public static LogViewModel Logger => Instance.LogOutput.LogViewModel;
+
+        /// <summary>
+        /// Access to the current options
+        /// </summary>
+        public static Options Options
+        {
+            get => _options;
+            set
+            {
+                _options = value;
+                OptionsLoader.SaveToConfig(_options);
+            }
+        }
+
+        /// <summary>
+        /// Internal reference to Options
+        /// </summary>
+        private static Options _options;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public App()
+        {
+            _appInstance = this;
+            _options = OptionsLoader.LoadFromConfig();
+        }
     }
 }

MPF/ComboBoxItems/Element.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Utilities;
+using MPF.Core.Converters;
 
 namespace MPF
 {
@@ -22,7 +22,7 @@ namespace MPF
         public static implicit operator T? (Element<T> item) => item?.Data;
 
         /// <inheritdoc/>
-        public string Name => Converters.GetLongName(Data);
+        public string Name => EnumConverter.GetLongName(Data);
 
         public override string ToString() => Name;
 

MPF/ComboBoxItems/KnownSystemComboBoxItem.cs

@@ -1,22 +1,23 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using MPF.Data;
-using MPF.Utilities;
+using MPF.Core.Converters;
+using MPF.Core.Utilities;
+using RedumpLib.Data;
 
 namespace MPF
 {
     /// <summary>
     /// Represents a single item in the System combo box
     /// </summary>
-    public class KnownSystemComboBoxItem : IElement
+    public class RedumpSystemComboBoxItem : IElement
     {
         private readonly object Data;
 
-        public KnownSystemComboBoxItem(KnownSystem? system) => Data = system;
-        public KnownSystemComboBoxItem(KnownSystemCategory? category) => Data = category;
+        public RedumpSystemComboBoxItem(RedumpSystem? system) => Data = system;
+        public RedumpSystemComboBoxItem(SystemCategory? category) => Data = category;
 
-        public static implicit operator KnownSystem?(KnownSystemComboBoxItem item) => item.Data as KnownSystem?;
+        public static implicit operator RedumpSystem?(RedumpSystemComboBoxItem item) => item.Data as RedumpSystem?;
 
         /// <inheritdoc/>
         public string Name
@@ -24,9 +25,9 @@ namespace MPF
             get
             {
                 if (IsHeader)
-                    return "---------- " + Converters.GetLongName(Data as KnownSystemCategory?) + " ----------";
+                    return "---------- " + (Data as SystemCategory?).LongName() + " ----------";
                 else
-                    return Converters.GetLongName(Data as KnownSystem?);
+                    return (Data as RedumpSystem?).LongName() ?? "No system selected";
             }
         }
 
@@ -35,31 +36,31 @@ namespace MPF
         /// <summary>
         /// Internal enum value
         /// </summary>
-        public KnownSystem? Value => Data as KnownSystem?;
+        public RedumpSystem? Value => Data as RedumpSystem?;
 
         /// <summary>
         /// Determines if the item is a header value
         /// </summary>
-        public bool IsHeader => Data is KnownSystemCategory?;
+        public bool IsHeader => Data is SystemCategory?;
 
         /// <summary>
         /// Determines if the item is a standard system value
         /// </summary>
-        public bool IsSystem => Data is KnownSystem?;
+        public bool IsSystem => Data is RedumpSystem?;
 
         /// <summary>
         /// Generate all elements for the known system combo box
         /// </summary>
         /// <returns></returns>
-        public static IEnumerable<KnownSystemComboBoxItem> GenerateElements()
+        public static IEnumerable<RedumpSystemComboBoxItem> GenerateElements()
         {
-            var knownSystems = Enum.GetValues(typeof(KnownSystem))
-                .OfType<KnownSystem?>()
-                .Where(s => !s.IsMarker() && s != KnownSystem.NONE)
+            var knownSystems = Enum.GetValues(typeof(RedumpSystem))
+                .OfType<RedumpSystem?>()
+                .Where(s => !s.IsMarker() && s.GetCategory() != SystemCategory.NONE)
                 .ToList();
 
-            Dictionary<KnownSystemCategory, List<KnownSystem?>> mapping = knownSystems
-                .GroupBy(s => s.Category())
+            Dictionary<SystemCategory, List<RedumpSystem?>> mapping = knownSystems
+                .GroupBy(s => s.GetCategory())
                 .ToDictionary(
                     k => k.Key,
                     v => v
@@ -67,15 +68,15 @@ namespace MPF
                         .ToList()
                 );
 
-            var systemsValues = new List<KnownSystemComboBoxItem>
+            var systemsValues = new List<RedumpSystemComboBoxItem>
             {
-                new KnownSystemComboBoxItem(KnownSystem.NONE),
+                new RedumpSystemComboBoxItem((RedumpSystem?)null),
             };
 
             foreach (var group in mapping)
             {
-                systemsValues.Add(new KnownSystemComboBoxItem(group.Key));
-                group.Value.ForEach(system => systemsValues.Add(new KnownSystemComboBoxItem(system)));
+                systemsValues.Add(new RedumpSystemComboBoxItem(group.Key));
+                group.Value.ForEach(system => systemsValues.Add(new RedumpSystemComboBoxItem(system)));
             }
 
             return systemsValues;

MPF/Constants.cs

@@ -11,14 +11,14 @@ namespace MPF
     public static class Constants
     {
         // Private lists of known drive speed ranges
-        private static IReadOnlyList<int> cd { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
-        private static IReadOnlyList<int> dvd { get; } = cd.Where(s => s <= 24).ToList();
-        private static IReadOnlyList<int> bd { get; } = cd.Where(s => s <= 16).ToList();
+        private static IReadOnlyList<int> CD { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
+        private static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
+        private static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
 
         // Create collections for UI based on known drive speeds
-        public static DoubleCollection SpeedsForCDAsCollection { get; } = GetDoubleCollectionFromIntList(cd);
-        public static DoubleCollection SpeedsForDVDAsCollection { get; } = GetDoubleCollectionFromIntList(dvd);
-        public static DoubleCollection SpeedsForBDAsCollection { get; } = GetDoubleCollectionFromIntList(bd);
+        public static DoubleCollection SpeedsForCDAsCollection { get; } = GetDoubleCollectionFromIntList(CD);
+        public static DoubleCollection SpeedsForDVDAsCollection { get; } = GetDoubleCollectionFromIntList(DVD);
+        public static DoubleCollection SpeedsForBDAsCollection { get; } = GetDoubleCollectionFromIntList(BD);
         private static DoubleCollection GetDoubleCollectionFromIntList(IReadOnlyList<int> list)
             => new DoubleCollection(list.Select(i => Convert.ToDouble(i)).ToList());
     }

MPF/External/WPFCustomMessageBox/CustomMessageBox.cs

@@ -0,0 +1,596 @@
+// -----------------------------------------------------------------------
+// <copyright file="MessageBox.cs">
+// TODO: Update copyright text.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace WPFCustomMessageBox
+{
+    using System;
+    using System.Windows;
+
+    /// <summary>
+    /// Displays a message box.
+    /// </summary>
+    public static class CustomMessageBox
+    {
+        /// <summary>
+        /// Global parameter to enable (true) or disable (false) the removal of the title bar icon.
+        /// If you are using a custom window style, the icon removal may cause issues like displaying two title bar (the default windows one and the custom one). 
+        /// </summary>
+        public static bool RemoveTitleBarIcon = true;
+
+        /// <summary>
+        /// Displays a message box that has a message and returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(string messageBoxText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, string.Empty, null, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message and a title bar caption; and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(string messageBoxText, string caption, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, caption, null, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box in front of the specified window. The message box displays a message and returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(Window owner, string messageBoxText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, string.Empty, null, null, null, timeout, timeoutResult);
+
+        }
+
+        /// <summary>
+        /// Displays a message box in front of the specified window. The message box displays a message and title bar caption; and it returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(Window owner, string messageBoxText, string caption, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, caption, null, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, and button; and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="button">A System.Windows.MessageBoxButton value that specifies which button or buttons to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.YesNo:
+                case MessageBoxButton.YesNoCancel:
+                    return ShowYesNoMessage(null, messageBoxText, caption, null, null, null, null, timeout, timeoutResult);
+                default:
+                    return ShowOKMessage(null, messageBoxText, caption, null, null, null, timeout, timeoutResult);
+            }
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, and button; and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="button">A System.Windows.MessageBoxButton value that specifies which button or buttons to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(Window owner, string messageBoxText, string caption, MessageBoxButton button, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.YesNo:
+                case MessageBoxButton.YesNoCancel:
+                    return ShowYesNoMessage(owner, messageBoxText, caption, null, null, null, null, timeout, timeoutResult);
+                default:
+                    return ShowOKMessage(owner, messageBoxText, caption, null, null, null, timeout, timeoutResult);
+            }
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, button, and icon; and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="button">A System.Windows.MessageBoxButton value that specifies which button or buttons to display.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.YesNo:
+                case MessageBoxButton.YesNoCancel:
+                    return ShowYesNoMessage(null, messageBoxText, caption, null, null, null, icon, timeout, timeoutResult);
+                default:
+                    return ShowOKMessage(null, messageBoxText, caption, null, null, icon, timeout, timeoutResult);
+            }
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, button, and icon; and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="button">A System.Windows.MessageBoxButton value that specifies which button or buttons to display.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult Show(Window owner, string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.YesNo:
+                case MessageBoxButton.YesNoCancel:
+                    return ShowYesNoMessage(owner, messageBoxText, caption, null, null, null, icon, timeout, timeoutResult);
+                default:
+                    return ShowOKMessage(owner, messageBoxText, caption, null, null, icon, timeout, timeoutResult);
+            }
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, and OK button with a custom System.String value for the button's text; and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOK(string messageBoxText, string caption, string okButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, caption, okButtonText, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, and OK button with a custom System.String value for the button's text; and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOK(Window owner, string messageBoxText, string caption, string okButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, caption, okButtonText, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, OK button with a custom System.String value for the button's text, and icon; and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOK(string messageBoxText, string caption, string okButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, caption, okButtonText, null, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, title bar caption, OK button with a custom System.String value for the button's text, and icon; and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOK(Window owner, string messageBoxText, string caption, string okButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, caption, okButtonText, null, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and OK/Cancel buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOKCancel(string messageBoxText, string caption, string okButtonText, string cancelButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, caption, okButtonText, cancelButtonText, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and OK/Cancel buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOKCancel(Window owner, string messageBoxText, string caption, string okButtonText, string cancelButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, caption, okButtonText, cancelButtonText, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, OK/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOKCancel(string messageBoxText, string caption, string okButtonText, string cancelButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(null, messageBoxText, caption, okButtonText, cancelButtonText, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, OK/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowOKCancel(Window owner, string messageBoxText, string caption, string okButtonText, string cancelButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowOKMessage(owner, messageBoxText, caption, okButtonText, cancelButtonText, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and Yes/No buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNo(string messageBoxText, string caption, string yesButtonText, string noButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(null, messageBoxText, caption, yesButtonText, noButtonText, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and Yes/No buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNo(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(owner, messageBoxText, caption, yesButtonText, noButtonText, null, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, Yes/No buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNo(string messageBoxText, string caption, string yesButtonText, string noButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(null, messageBoxText, caption, yesButtonText, noButtonText, null, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, Yes/No buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNo(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(owner, messageBoxText, caption, yesButtonText, noButtonText, null, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and Yes/No/Cancel buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNoCancel(string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(null, messageBoxText, caption, yesButtonText, noButtonText, cancelButtonText, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, and Yes/No/Cancel buttons with custom System.String values for the buttons' text;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNoCancel(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(owner, messageBoxText, caption, yesButtonText, noButtonText, cancelButtonText, null, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, Yes/No/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNoCancel(string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(null, messageBoxText, caption, yesButtonText, noButtonText, cancelButtonText, icon, timeout, timeoutResult);
+        }
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, Yes/No/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">
+        /// The message box will close automatically after <paramref name="timeout"/> milliseconds.
+        /// If null, the message box will act like default message box and not close automatically.
+        /// </param>
+        /// <param name="timeoutResult">If the message box closes automatically due to the <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        public static MessageBoxResult ShowYesNoCancel(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            return ShowYesNoMessage(owner, messageBoxText, caption, yesButtonText, noButtonText, cancelButtonText, icon, timeout, timeoutResult);
+        }
+
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, OK/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="okButtonText">A System.String that specifies the text to display within the OK button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">The message box will close automatically after given milliseconds</param>
+        /// <param name="timeoutResult">If the message box closes automatically due to <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        private static MessageBoxResult ShowOKMessage(Window owner, string messageBoxText, string caption, string okButtonText, string cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.OK : MessageBoxButton.OKCancel;
+
+            CustomMessageBoxWindow msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
+            if (!string.IsNullOrEmpty(okButtonText))
+                msg.OkButtonText = okButtonText;
+            if (!string.IsNullOrEmpty(cancelButtonText))
+                msg.CancelButtonText = cancelButtonText;
+
+            ShowDialog(msg, timeout, timeoutResult);
+
+            return msg.Result;
+        }
+
+
+        /// <summary>
+        /// Displays a message box that has a message, caption, Yes/No/Cancel buttons with custom System.String values for the buttons' text, and icon;
+        /// and that returns a result.
+        /// </summary>
+        /// <param name="owner">A System.Windows.Window that represents the owner window of the message box.</param>
+        /// <param name="messageBoxText">A System.String that specifies the text to display.</param>
+        /// <param name="caption">A System.String that specifies the title bar caption to display.</param>
+        /// <param name="yesButtonText">A System.String that specifies the text to display within the Yes button.</param>
+        /// <param name="noButtonText">A System.String that specifies the text to display within the No button.</param>
+        /// <param name="cancelButtonText">A System.String that specifies the text to display within the Cancel button.</param>
+        /// <param name="icon">A System.Windows.MessageBoxImage value that specifies the icon to display.</param>
+        /// <param name="timeout">The message box will close automatically after given milliseconds</param>
+        /// <param name="timeoutResult">If the message box closes automatically due to <paramref name="timeout"/> being exceeded, this result is returned.</param>
+        /// <returns>A System.Windows.MessageBoxResult value that specifies which message box button is clicked by the user.</returns>
+        private static MessageBoxResult ShowYesNoMessage(Window owner, string messageBoxText, string caption, string yesButtonText, string noButtonText, string cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+        {
+            MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.YesNo : MessageBoxButton.YesNoCancel;
+
+            CustomMessageBoxWindow msg = new CustomMessageBoxWindow(owner, messageBoxText, caption, buttonLayout, icon, RemoveTitleBarIcon);
+            if (!string.IsNullOrEmpty(yesButtonText))
+                msg.YesButtonText = yesButtonText;
+            if (!string.IsNullOrEmpty(noButtonText))
+                msg.NoButtonText = noButtonText;
+            if (!string.IsNullOrEmpty(cancelButtonText))
+                msg.CancelButtonText = cancelButtonText;
+
+            ShowDialog(msg, timeout, timeoutResult);
+
+            return msg.Result;
+        }
+
+        private static void ShowDialog(CustomMessageBoxWindow dialog, int? timeout, MessageBoxResult timeoutResult)
+        {
+            if (timeout.HasValue && timeout.Value <= 0)
+            {
+                throw new ArgumentOutOfRangeException("timeout", string.Format("Timeout must be greater than 0."));
+            }
+
+            if (timeout.HasValue)
+            {
+                //System.Threading.Timer timer = null;
+                //timer = new System.Threading.Timer(s => { msg.Close(); timer.Dispose(); }, null, timeout.Value, System.Threading.Timeout.Infinite);
+                System.Timers.Timer timer = new System.Timers.Timer(timeout.Value) { AutoReset = false };
+                timer.Elapsed += delegate {
+                    Application.Current.Dispatcher.Invoke(new Action(() =>
+                    {
+                        dialog.Result = timeoutResult;
+                        dialog.Close();
+                        //timer.Stop();
+                        //timer.Dispose();
+                        //timer = null;
+                    }));
+                };
+                timer.Start();
+                dialog.ShowDialog();
+                timer.Stop();
+                timer.Dispose();
+            }
+            else
+                dialog.ShowDialog();
+        }
+    }
+}

MPF/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml

@@ -0,0 +1,84 @@
+<Window x:Class="WPFCustomMessageBox.CustomMessageBoxWindow"
+        x:ClassModifier="internal"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        WindowStartupLocation="CenterScreen"
+        WindowStyle="None"
+        ShowInTaskbar="False"
+        ResizeMode="NoResize" SizeToContent="WidthAndHeight"
+        TextOptions.TextFormattingMode="Display" TextOptions.TextRenderingMode="ClearType" UseLayoutRounding="True"
+        Title="" MinHeight="155" MaxWidth="470" MinWidth="154"
+        BorderBrush="DarkGray" BorderThickness="2">
+
+    <WindowChrome.WindowChrome>
+        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
+    </WindowChrome.WindowChrome>
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <Grid Grid.Row="0" Margin="0,10,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="25"/>
+                <ColumnDefinition Width="115"/>
+                <ColumnDefinition/>
+                <ColumnDefinition/>
+                <ColumnDefinition/>
+                <ColumnDefinition Width="50"/>
+            </Grid.ColumnDefinitions>
+
+            <Image Grid.Column="0" Source="/Images/Icon.ico" Height="20" Width="20" Margin="1" />
+            <Label Grid.Column="1" Grid.ColumnSpan="4" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" MouseDown="TitleMouseDown" Content="{Binding Path=Title,RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"/>
+        </Grid>
+
+        <!-- Make the window width fit the title by embedding the title invisibly  -->
+        <TextBlock Text="{Binding Path=Title,RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
+                   Visibility="Hidden" Height="0" Margin="50 0 0 0" />
+
+        <Grid Grid.Row="1" Background="{DynamicResource CustomMessageBox.Static.Background}" MinHeight="69">
+            <DockPanel>
+                <Image Name="Image_MessageBox" Width="32" Height="32" HorizontalAlignment="Left" DockPanel.Dock="Left" Margin="30,0,0,0" Visibility="Collapsed"/>
+                <TextBlock Name="TextBlock_Message" TextWrapping="Wrap" MaxWidth="500" Width="Auto"
+                       VerticalAlignment="Center" Margin="12,20,41,15" />
+            </DockPanel>
+        </Grid>
+        
+        <Grid Grid.Row="2" Background="{DynamicResource CustomMessageBox.Static.Background}" MinHeight="49">
+            <DockPanel Margin="5,0">
+                
+                <!-- Cancel Button -->
+                <Button Name="Button_Cancel" MinWidth="88" MaxWidth="160" Height="26" Margin="5,0" HorizontalAlignment="Right" Visibility="Collapsed" IsCancel="True"
+                        DockPanel.Dock="Right" Click="Button_Cancel_Click" Style="{DynamicResource CustomButtonStyle}">
+                    <Label Name="Label_Cancel" Padding="0" Margin="10,0">_Cancel</Label>
+                </Button>
+                <!-- End Cancel Button -->
+                
+                <!-- No Button -->
+                <Button Name="Button_No" MinWidth="88" MaxWidth="160" Height="26" Margin="5,0" HorizontalAlignment="Right" Visibility="Collapsed"
+                        DockPanel.Dock="Right" Click="Button_No_Click" Style="{DynamicResource CustomButtonStyle}">
+                    <Label Name="Label_No" Padding="0" Margin="10,0">_No</Label>
+                </Button>
+                <!-- End No Button -->
+                
+                <!-- Yes Button -->
+                <Button Name="Button_Yes" MinWidth="88" MaxWidth="160" Height="26" Margin="35,0,5,0" HorizontalAlignment="Right" Visibility="Collapsed"
+                        DockPanel.Dock="Right" Click="Button_Yes_Click" Style="{DynamicResource CustomButtonStyle}">
+                    <Label Name="Label_Yes" Padding="0" Margin="10,0">_Yes</Label>
+                </Button>
+                <!-- End Yes Button -->
+                
+                <!-- OK Button -->
+                <Button Name="Button_OK" MinWidth="88" MaxWidth="160" Margin="35,0,5,0" HorizontalAlignment="Right" Height="26"
+                        Click="Button_OK_Click" Style="{DynamicResource CustomButtonStyle}">
+                    <Label Name="Label_Ok" Padding="0" Margin="10,0">_OK</Label>
+                </Button>
+                <!-- End OK Button -->
+                
+            </DockPanel>
+        </Grid>
+    </Grid>
+</Window>

MPF/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Drawing;
+using System.Windows;
+using System.Windows.Input;
+
+namespace WPFCustomMessageBox
+{
+    /// <summary>
+    /// Interaction logic for ModalDialog.xaml
+    /// </summary>
+    internal partial class CustomMessageBoxWindow : Window
+    {
+        private bool _removeTitleBarIcon = true;
+
+        public string Caption
+        {
+            get
+            {
+                return Title;
+            }
+            set
+            {
+                Title = value;
+            }
+        }
+
+        public string Message
+        {
+            get
+            {
+                return TextBlock_Message.Text;
+            }
+            set
+            {
+                TextBlock_Message.Text = value;
+            }
+        }
+
+        public string OkButtonText
+        {
+            get
+            {
+                return Label_Ok.Content.ToString();
+            }
+            set
+            {
+                Label_Ok.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+        public string CancelButtonText
+        {
+            get
+            {
+                return Label_Cancel.Content.ToString();
+            }
+            set
+            {
+                Label_Cancel.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+        public string YesButtonText
+        {
+            get
+            {
+                return Label_Yes.Content.ToString();
+            }
+            set
+            {
+                Label_Yes.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+        public string NoButtonText
+        {
+            get
+            {
+                return Label_No.Content.ToString();
+            }
+            set
+            {
+                Label_No.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+        public MessageBoxResult Result { get; set; }
+
+        internal CustomMessageBoxWindow(Window owner, string message, string caption = null, MessageBoxButton? button = null, MessageBoxImage? image = null, bool removeTitleBarIcon = true)
+        {
+            InitializeComponent();
+
+            _removeTitleBarIcon = removeTitleBarIcon;
+
+            if (owner != null)
+            {
+                Owner = owner;
+                WindowStartupLocation = WindowStartupLocation.CenterOwner;
+            }
+
+            Message = message;
+            Caption = caption;
+
+            DisplayButtons(button ?? MessageBoxButton.OK);
+
+            if (image.HasValue)
+                DisplayImage(image.Value);
+            else
+                Image_MessageBox.Visibility = System.Windows.Visibility.Collapsed;
+        }
+
+        protected override void OnSourceInitialized(EventArgs e)
+        {
+            if (_removeTitleBarIcon)
+                Util.RemoveIcon(this);
+
+            base.OnSourceInitialized(e);
+        }
+
+        private void DisplayButtons(MessageBoxButton button)
+        {
+            switch (button)
+            {
+                case MessageBoxButton.OKCancel:
+                    // Hide all but OK, Cancel
+                    Button_OK.Visibility = System.Windows.Visibility.Visible;
+                    Button_OK.Focus();
+                    Button_Cancel.Visibility = System.Windows.Visibility.Visible;
+
+                    Button_Yes.Visibility = System.Windows.Visibility.Collapsed;
+                    Button_No.Visibility = System.Windows.Visibility.Collapsed;
+                    break;
+                case MessageBoxButton.YesNo:
+                    // Hide all but Yes, No
+                    Button_Yes.Visibility = System.Windows.Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = System.Windows.Visibility.Visible;
+
+                    Button_OK.Visibility = System.Windows.Visibility.Collapsed;
+                    Button_Cancel.Visibility = System.Windows.Visibility.Collapsed;
+                    break;
+                case MessageBoxButton.YesNoCancel:
+                    // Hide only OK
+                    Button_Yes.Visibility = System.Windows.Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = System.Windows.Visibility.Visible;
+                    Button_Cancel.Visibility = System.Windows.Visibility.Visible;
+
+                    Button_OK.Visibility = System.Windows.Visibility.Collapsed;
+                    break;
+                default:
+                    // Hide all but OK
+                    Button_OK.Visibility = System.Windows.Visibility.Visible;
+                    Button_OK.Focus();
+
+                    Button_Yes.Visibility = System.Windows.Visibility.Collapsed;
+                    Button_No.Visibility = System.Windows.Visibility.Collapsed;
+                    Button_Cancel.Visibility = System.Windows.Visibility.Collapsed;
+                    break;
+            }
+        }
+
+        private void DisplayImage(MessageBoxImage image)
+        {
+            Icon icon;
+
+            switch (image)
+            {
+                case MessageBoxImage.Exclamation:       // Enumeration value 48 - also covers "Warning"
+                    icon = SystemIcons.Exclamation;
+                    break;
+                case MessageBoxImage.Error:             // Enumeration value 16, also covers "Hand" and "Stop"
+                    icon = SystemIcons.Hand;
+                    break;
+                case MessageBoxImage.Information:       // Enumeration value 64 - also covers "Asterisk"
+                    icon = SystemIcons.Information;
+                    break;
+                case MessageBoxImage.Question:
+                    icon = SystemIcons.Question;
+                    break;
+                default:
+                    icon = SystemIcons.Information;
+                    break;
+            }
+
+            Image_MessageBox.Source = icon.ToImageSource();
+            Image_MessageBox.Visibility = System.Windows.Visibility.Visible;
+        }
+
+        private void Button_OK_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.OK;
+            Close();
+        }
+
+        private void Button_Cancel_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.Cancel;
+            Close();
+        }
+
+        private void Button_Yes_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.Yes;
+            Close();
+        }
+
+        private void Button_No_Click(object sender, RoutedEventArgs e)
+        {
+            Result = MessageBoxResult.No;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for Title MouseDown event
+        /// </summary>
+        private void TitleMouseDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+                this.DragMove();
+        }
+    }
+}

MPF/External/WPFCustomMessageBox/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2021 Thomas Absenger
+
+Copyright (c) 2013 Evan Wondrasek / Apricity Software LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MPF/External/WPFCustomMessageBox/Util.cs

@@ -0,0 +1,92 @@
+// -----------------------------------------------------------------------
+// <copyright file="Util.cs">
+// TODO: Update copyright text.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace WPFCustomMessageBox
+{
+    using System;
+    using System.Drawing;
+    using System.Runtime.InteropServices;
+    using System.Windows;
+    using System.Windows.Interop;
+    using System.Windows.Media;
+    using System.Windows.Media.Imaging;
+
+    /// <summary>
+    /// TODO: Update summary.
+    /// </summary>
+    internal static class Util
+    {
+        [DllImport("user32.dll")]
+        static extern int GetWindowLong(IntPtr hwnd, int index);
+
+        [DllImport("user32.dll")]
+        static extern int SetWindowLong(IntPtr hwnd, int index, int newStyle);
+
+        [DllImport("user32.dll")]
+        static extern bool SetWindowPos(IntPtr hwnd, IntPtr hwndInsertAfter, int x, int y, int width, int height, uint flags);
+
+        [DllImport("user32.dll")]
+        static extern IntPtr SendMessage(IntPtr hwnd, uint msg, IntPtr wParam, IntPtr lParam);
+
+        const int GWL_EXSTYLE = -20;
+        const int WS_EX_DLGMODALFRAME = 0x0001;
+        const int SWP_NOSIZE = 0x0001;
+        const int SWP_NOMOVE = 0x0002;
+        const int SWP_NOZORDER = 0x0004;
+        const int SWP_FRAMECHANGED = 0x0020;
+        const uint WM_SETICON = 0x0080;
+
+
+        internal static ImageSource ToImageSource(this Icon icon)
+        {
+            ImageSource imageSource = Imaging.CreateBitmapSourceFromHIcon(
+                icon.Handle,
+                Int32Rect.Empty,
+                BitmapSizeOptions.FromEmptyOptions());
+
+            return imageSource;
+        }
+
+        /// <summary>
+        /// Keyboard Accellerators are used in Windows to allow easy shortcuts to controls like Buttons and 
+        /// MenuItems. These allow users to press the Alt key, and a shortcut key will be highlighted on the 
+        /// control. If the user presses that key, that control will be activated.
+        /// This method checks a string if it contains a keyboard accellerator. If it doesn't, it adds one to the
+        /// beginning of the string. If there are two strings with the same accellerator, Windows handles it.
+        /// The keyboard accellerator character for WPF is underscore (_). It will not be visible.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        internal static string TryAddKeyboardAccellerator(this string input)
+        {
+            if (input == null)
+                return input;
+
+            const string accellerator = "_";            // This is the default WPF accellerator symbol - used to be & in WinForms
+
+            // If it already contains an accellerator, do nothing
+            if (input.Contains(accellerator)) return input;
+
+            return accellerator + input;
+        }
+
+        /// <summary>
+        /// Removes the icon from the given window.
+        /// See https://stackoverflow.com/a/18581096
+        /// </summary>
+        /// <param name="window">The window to remove the icon from.</param>
+        internal static void RemoveIcon(Window window)
+        {
+            // Get this window's handle
+            IntPtr hwnd = new WindowInteropHelper(window).Handle;
+            // Change the extended window style to not show a window icon
+            int extendedStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
+            SetWindowLong(hwnd, GWL_EXSTYLE, extendedStyle | WS_EX_DLGMODALFRAME);
+            // Update the window's non-client area to reflect the changes
+            SetWindowPos(hwnd, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
+        }
+    }
+}

MPF/MPF.csproj

@@ -1,19 +1,19 @@
 <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
-    <TargetFrameworks>net48;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>net48;netcoreapp3.1;net5.0-windows</TargetFrameworks>
+    <PlatformTarget>x86</PlatformTarget>
     <OutputType>WinExe</OutputType>
     <UseWindowsForms>true</UseWindowsForms>
     <UseWPF>true</UseWPF>
-    <ApplicationIcon>Icon.ico</ApplicationIcon>
-    <Prefer32Bit>true</Prefer32Bit>
+    <ApplicationIcon>Images\Icon.ico</ApplicationIcon>
     <Title>MPF</Title>
     <AssemblyName>MPF</AssemblyName>
     <Description>Frontend for various dumping programs</Description>
     <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
     <Copyright>Copyright (c)2019-2021</Copyright>
     <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
-    <Version>2.0</Version>
+    <Version>2.3</Version>
     <AssemblyVersion>$(Version)</AssemblyVersion>
     <FileVersion>$(Version)</FileVersion>
     <IncludeSource>true</IncludeSource>
@@ -27,11 +27,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.6.1" GeneratePathProperty="true">
+    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="1.8.0" GeneratePathProperty="true">
       <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="System.Configuration.ConfigurationManager" Version="6.0.0-preview.3.21201.4" />
-    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.0" />
+    <PackageReference Include="System.Configuration.ConfigurationManager" Version="6.0.0-rc.1.21451.13" />
+    <PackageReference Include="Unclassified.NetRevisionTask" Version="0.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
@@ -39,14 +42,26 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Resource Include="Images\ring-code-guide.png" />
+    <None Remove="Images\ring-code-guide-2-layer.png" />
   </ItemGroup>
 
   <ItemGroup>
+    <Resource Include="Images\Icon.ico" />
+    <Resource Include="Images\ring-code-guide-2-layer.png" />
+    <Resource Include="Images\ring-code-guide-1-layer.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
     <ProjectReference Include="..\MPF.Library\MPF.Library.csproj">
       <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
       <Name>MPF.Library</Name>
     </ProjectReference>
+    <ProjectReference Include="..\RedumpLib\RedumpLib.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="PresentationFramework.Aero" />
   </ItemGroup>
 
 </Project>

MPF/OptionsLoader.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Configuration;
+using MPF.Core.Data;
+
+namespace MPF
+{
+    public static class OptionsLoader
+    {
+        /// <summary>
+        /// Load the current set of options from the application configuration
+        /// </summary>
+        public static Options LoadFromConfig()
+        {
+            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+
+            var settings = configFile.AppSettings.Settings;
+            var dict = new Dictionary<string, string>();
+
+            foreach (string key in settings.AllKeys)
+            {
+                dict[key] = settings[key]?.Value ?? string.Empty;
+            }
+
+            return new Options(dict);
+        }
+
+        /// <summary>
+        /// Save the current set of options to the application configuration
+        /// </summary>
+        public static void SaveToConfig(Options options)
+        {
+            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+
+            // Loop through all settings in Options and save them, overwriting existing settings
+            foreach (var kvp in options)
+            {
+                configFile.AppSettings.Settings.Remove(kvp.Key);
+                configFile.AppSettings.Settings.Add(kvp.Key, kvp.Value);
+            }
+
+            configFile.Save(ConfigurationSaveMode.Modified);
+        }
+    }
+}

MPF/UserControls/LogOutput.xaml

@@ -9,21 +9,21 @@
     <Grid>
         <StackPanel Orientation="Vertical">
             <Grid Height="22" Margin="10 10 10 0">
-                <ProgressBar x:Name="ProgressBar" />
+                <ProgressBar x:Name="ProgressBar" Style="{DynamicResource CustomProgressBarStyle}" />
                 <TextBlock x:Name="ProgressLabel" Grid.Row="0" Height="22" HorizontalAlignment="Center" VerticalAlignment="Center" Padding="0 2 0 0" />
             </Grid>
             
             <Border Height="180" Background="White" BorderBrush="Gainsboro" BorderThickness="1" Margin="10">
-                <ScrollViewer Name="OutputViewer" SizeChanged="OutputViewerSizeChanged">
-                    <RichTextBox Name="Output" FontFamily="Consolas" Background="#202020" IsReadOnly="true" TextChanged="OnTextChanged" />
+                <ScrollViewer Name="OutputViewer" Template="{DynamicResource CustomScrollViewerControlStyle}">
+                    <RichTextBox Name="Output" FontFamily="Consolas" Background="#FF202020" IsReadOnly="true" />
                 </ScrollViewer>
             </Border>
 
             <GroupBox Grid.Row="2" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
                 <UniformGrid Columns="4" Margin="5,5,5,5" Height="28">
                     <Label/> <!-- Empty label for padding -->
-                    <Button Name="ClearButton" Height="25" Width="80" Content="Clear" Click="OnClearButton" />
-                    <Button Name="SaveButton" Height="25" Width="80" Content="Save" Click="OnSaveButton" />
+                    <Button Name="ClearButton" Height="25" Width="80" Content="Clear" Style="{DynamicResource CustomButtonStyle}" />
+                    <Button Name="SaveButton" Height="25" Width="80" Content="Save" Style="{DynamicResource CustomButtonStyle}" />
                     <Label/> <!-- Empty label for padding -->
                 </UniformGrid>
             </GroupBox>

MPF/UserControls/LogOutput.xaml.cs

@@ -1,537 +1,19 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Documents;
-using System.Windows.Media;
-using MPF.Data;
+using System.Windows.Controls;
+using MPF.GUI.ViewModels;
 
 namespace MPF.UserControls
 {
     public partial class LogOutput : UserControl
     {
         /// <summary>
-        /// Paragraph backing the log
+        /// Read-only access to the current log view model
         /// </summary>
-        private readonly Paragraph _paragraph;
-
-        /// <summary>
-        /// Cached value of the last line written
-        /// </summary>
-        private Run lastLine = null;
-
-        /// <summary>
-        /// Queue of items that need to be logged
-        /// </summary>
-        private readonly ProcessingQueue<LogLine> logQueue;
-
-        /// <summary>
-        /// List of Matchers for progress tracking
-        /// </summary>
-        private readonly List<Matcher?> _matchers;
-
-        /// <summary>
-        /// Cached value of the last matcher used
-        /// </summary>
-        private Matcher? lastUsedMatcher = null;
-
-        /// <summary>
-        /// Regex pattern to find DiscImageCreator progress messages
-        /// </summary>
-        private const string DiscImageCreatorProgressPattern = @"\s*(\d+)\/\s*(\d+)$";
+        public LogViewModel LogViewModel => DataContext as LogViewModel;
 
         public LogOutput()
         {
             InitializeComponent();
-            DataContext = this;
-
-            var document = new FlowDocument();
-            _paragraph = new Paragraph();
-            document.Blocks.Add(_paragraph);
-            Output.Document = document;
-
-            _matchers = new List<Matcher?>();
-            AddAaruMatchers();
-            AddDiscImageCreatorMatchers();
-
-            logQueue = new ProcessingQueue<LogLine>(ProcessLogLine);
+            DataContext = new LogViewModel(this);
         }
-
-        #region Matching
-
-        /// <summary>
-        /// Matching wrapper
-        /// </summary>
-        private struct Matcher
-        {
-            private readonly string prefix;
-            private readonly Regex regex;
-            private readonly int start;
-            private readonly string progressBarText;
-            private readonly Action<Match, string> lambda;
-
-            public Matcher(string prefix, string regex, string progressBarText, Action<Match, string> lambda)
-            {
-                this.prefix = prefix;
-                this.regex = new Regex(regex);
-                this.start = prefix.Length;
-                this.progressBarText = progressBarText;
-                this.lambda = lambda;
-            }
-
-            /// <summary>
-            /// Check if the text matches the prefix
-            /// </summary>
-            /// <param name="text">Text to check</param>
-            /// <returns>True if the line starts with the prefix, false otherwise</returns>
-            public bool Matches(string text) => text.StartsWith(prefix);
-
-            /// <summary>
-            /// Generate a Match and apply the lambda
-            /// </summary>
-            /// <param name="text">Text to match and apply from</param>
-            public void Apply(string text)
-            {
-                Match match = regex?.Match(text, start);
-                lambda?.Invoke(match, progressBarText);
-            }
-        }
-
-        /// <summary>
-        /// Add all Matchers for Aaru
-        /// </summary>
-        private void AddAaruMatchers()
-        {
-            // TODO: Determine matchers that can be added
-        }
-
-        /// <summary>
-        /// Add all Matchers for DiscImageCreator
-        /// </summary>
-        private void AddDiscImageCreatorMatchers()
-        {
-            #region Pre-dump Checking
-
-            _matchers.Add(new Matcher(
-                "Checking EXE",
-                DiscImageCreatorProgressPattern,
-                "Checking executables...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Checking Pregap sync, msf, mode (LBA)",
-                @"\s*-(\d+)$",
-                "Checking Pregap sync, msf, mode",
-                (match, text) =>
-                {
-                    ProgressBar.Value = 0;
-                    ProgressLabel.Text = text;
-                }));
-
-            _matchers.Add(new Matcher(
-                "Checking SubQ adr (Track)",
-                DiscImageCreatorProgressPattern,
-                "Checking SubQ adr...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Checking SubQ ctl (Track)",
-                DiscImageCreatorProgressPattern,
-                "Checking SubQ ctl...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Checking SubRtoW (Track)",
-                DiscImageCreatorProgressPattern,
-                "Checking SubRtoW...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Reading DirectoryRecord",
-                DiscImageCreatorProgressPattern,
-                "Reading directory records...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Scanning sector for anti-mod string (LBA)",
-                DiscImageCreatorProgressPattern,
-                "Scanning sectors for anti-mod string...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            #endregion
-
-            #region Dumping
-
-            _matchers.Add(new Matcher(
-                @"Creating iso(LBA)",
-                DiscImageCreatorProgressPattern,
-                "Creating ISO...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                @"Creating .scm (LBA)",
-                DiscImageCreatorProgressPattern,
-                "Creating scrambled image...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            #endregion
-
-            #region Post-Dump Processing
-
-            _matchers.Add(new Matcher(
-                "Checking sectors:",
-                DiscImageCreatorProgressPattern,
-                "Checking for errors...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Creating bin (Track)",
-                DiscImageCreatorProgressPattern,
-                "Creating BIN(s)...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Creating cue and ccd (Track)",
-                DiscImageCreatorProgressPattern,
-                "Creating CUE and CCD...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Descrambling data sector of img:",
-                 DiscImageCreatorProgressPattern,
-                "Descrambling image...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            _matchers.Add(new Matcher(
-                "Scanning sector (LBA)",
-                DiscImageCreatorProgressPattern,
-                "Scanning sectors for protection...",
-                StandardDiscImageCreatorProgress
-            ));
-
-            #endregion
-        }
-
-        #endregion
-
-        #region Logging
-
-        /// <summary>
-        /// Log level for output
-        /// </summary>
-        private enum LogLevel
-        {
-            USER,
-            VERBOSE,
-            ERROR,
-            SECRET,
-        }
-
-        /// <summary>
-        /// Log line wrapper
-        /// </summary>
-        private struct LogLine
-        {
-            public readonly string Text;
-            public readonly LogLevel LogLevel;
-
-            public LogLine(string text, LogLevel logLevel)
-            {
-                this.Text = text;
-                this.LogLevel = logLevel;
-            }
-
-            /// <summary>
-            /// Get the foreground Brush for the current LogLevel
-            /// </summary>
-            /// <returns>Brush representing the color</returns>
-            public Brush GetForegroundColor()
-            {
-                switch (this.LogLevel)
-                {
-                    case LogLevel.SECRET:
-                        return Brushes.Blue;
-                    case LogLevel.ERROR:
-                        return Brushes.Red;
-                    case LogLevel.VERBOSE:
-                        return Brushes.Yellow;
-                    case LogLevel.USER:
-                    default:
-                        return Brushes.White;
-                }
-            }
-
-            /// <summary>
-            /// Generate a Run object from the current LogLine
-            /// </summary>
-            /// <returns>Run object based on internal values</returns>
-            public Run GenerateRun()
-            {
-                return new Run { Text = this.Text, Foreground = GetForegroundColor() };
-            }
-        }
-
-        /// <summary>
-        /// Enqueue text to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void Log(string text) => LogInternal(text);
-
-        /// <summary>
-        /// Enqueue text with a newline to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void LogLn(string text) => Log(text + "\n");
-
-        /// <summary>
-        /// Enqueue error text to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void ErrorLog(string text) => LogInternal(text, LogLevel.ERROR);
-
-        /// <summary>
-        /// Enqueue error text with a newline to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void ErrorLogLn(string text) => ErrorLog(text + "\n");
-
-        /// <summary>
-        /// Enqueue secret text to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void SecretLog(string text) => LogInternal(text, LogLevel.SECRET);
-
-        /// <summary>
-        /// Enqueue secret text with a newline to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void SecretLogLn(string text) => SecretLog(text + "\n");
-
-        /// <summary>
-        /// Enqueue verbose text to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void VerboseLog(string text) => LogInternal(text, LogLevel.VERBOSE);
-
-        /// <summary>
-        /// Enqueue verbose text with a newline to the log
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        public void VerboseLogLn(string text) => VerboseLog(text + "\n");
-
-        /// <summary>
-        /// Reset the progress bar state
-        /// </summary>
-        public void ResetProgressBar()
-        {
-            Dispatcher.Invoke(() =>
-            {
-                ProgressBar.Value = 0;
-                ProgressLabel.Text = string.Empty;
-            });
-        }
-
-        /// <summary>
-        /// Enqueue text to the log with formatting
-        /// </summary>
-        /// <param name="text">Text to write to the log</param>
-        /// <param name="logLevel">LogLevel for the log, defaults to USER</param>
-        private void LogInternal(string text, LogLevel logLevel = LogLevel.USER)
-        {
-            // Null text gets ignored
-            if (text == null)
-                return;
-
-            // If we have verbose logs but not enabled, ignore
-            if (logLevel == LogLevel.VERBOSE && !ViewModels.OptionsViewModel.VerboseLogging)
-                return;            
-
-            // Enqueue the text
-            logQueue.Enqueue(new LogLine(text, logLevel));
-        }
-
-        /// <summary>
-        /// Process the log lines in the queue
-        /// </summary>
-        /// <param name="nextLogLine">LogLine item to process</param>
-        private void ProcessLogLine(LogLine nextLogLine)
-        {
-            // Null text gets ignored
-            string nextText = Dispatcher.Invoke(() => nextLogLine.Text);
-            if (nextText == null)
-                return;
-
-            try
-            {
-                // If we're not processing log formatting, just append and continue
-                if (!ViewModels.OptionsViewModel.EnableLogFormatting)
-                {
-                    AppendToTextBox(nextLogLine);
-                    return;
-                }
-
-                // Get last line
-                lastLine = lastLine ?? GetLastLine();
-
-                // Always append if there's no previous line
-                if (lastLine == null)
-                {
-                    AppendToTextBox(nextLogLine);
-                    lastUsedMatcher = _matchers.FirstOrDefault(m => m?.Matches(nextText) == true);
-                }
-                // Return always means overwrite
-                else if (nextText.StartsWith("\r"))
-                {
-                    ReplaceLastLine(nextLogLine);
-                }
-                // If we have a cached matcher and we match
-                else if (lastUsedMatcher?.Matches(nextText) == true)
-                {
-                    ReplaceLastLine(nextLogLine);
-                }
-                else
-                {
-                    // Get the first matching Matcher
-                    var firstMatcher = _matchers.FirstOrDefault(m => m?.Matches(nextText) == true);
-                    if (firstMatcher.HasValue)
-                    {
-                        string lastText = Dispatcher.Invoke(() => { return lastLine.Text; });
-                        if (firstMatcher.Value.Matches(lastText))
-                            ReplaceLastLine(nextLogLine);
-                        else if (string.IsNullOrWhiteSpace(lastText))
-                            ReplaceLastLine(nextLogLine);
-                        else
-                            AppendToTextBox(nextLogLine);
-
-                        // Cache the last used Matcher
-                        lastUsedMatcher = firstMatcher;
-                    }
-                    // Default case for all other text
-                    else
-                    {
-                        AppendToTextBox(nextLogLine);
-                        lastUsedMatcher = null;
-                    }
-                }
-
-                // Update the bar if needed
-                if (ViewModels.OptionsViewModel.EnableProgressProcessing)
-                    ProcessStringForProgressBar(nextText, lastUsedMatcher);
-            }
-            catch (Exception ex)
-            {
-                // In the event that something fails horribly, we want to log
-                AppendToTextBox(new LogLine(ex.ToString(), LogLevel.ERROR));
-            }
-        }
-
-        /// <summary>
-        /// Append log line to the log text box
-        /// </summary>
-        /// <param name="logLine">LogLine value to append</param>
-        private void AppendToTextBox(LogLine logLine)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                var run = logLine.GenerateRun();
-                _paragraph.Inlines.Add(run);
-                lastLine = run;
-            });
-        }
-
-        /// <summary>
-        /// Get the last line written to the log text box
-        /// </summary>
-        private Run GetLastLine()
-        {
-            return Dispatcher.Invoke(() =>
-            {
-                if (!_paragraph.Inlines.Any())
-                    return null;
-
-                return _paragraph.Inlines.LastInline as Run;
-            });
-        }
-
-        /// <summary>
-        /// Process text if it should update the progress bar
-        /// </summary>
-        /// <param name="text">Text to check and update with</param>
-        private void ProcessStringForProgressBar(string text, Matcher? matcher)
-        {
-            Dispatcher.Invoke(() => { matcher?.Apply(text); });
-        }
-
-        /// <summary>
-        /// Replace the last line written to the log text box
-        /// </summary>
-        /// <param name="logLine">LogLine value to append</param>
-        private void ReplaceLastLine(LogLine logLine)
-        {
-            Dispatcher.Invoke(() =>
-            {
-                lastLine.Text = logLine.Text;
-                lastLine.Foreground = logLine.GetForegroundColor();
-            });
-        }
-
-        #endregion
-
-        #region EventHandlers
-
-        private void OnClearButton(object sender, EventArgs e)
-        {
-            _paragraph.Inlines.Clear();
-            ResetProgressBar();
-        }
-        
-        private void OnSaveButton(object sender, EventArgs e)
-        {
-            using (StreamWriter tw = new StreamWriter(File.OpenWrite("console.log")))
-            {
-                foreach (var inline in _paragraph.Inlines)
-                {
-                    if (inline is Run run)
-                        tw.Write(run.Text);
-                }
-            }
-        }
-
-        private void OnTextChanged(object sender, TextChangedEventArgs e)
-        {
-            OutputViewer.ScrollToBottom();
-        }
-
-        private void OutputViewerSizeChanged(object sender, SizeChangedEventArgs e)
-        {
-            OutputViewer.ScrollToBottom();
-        }
-
-        private void StandardDiscImageCreatorProgress(Match match, string text)
-        {
-            if (uint.TryParse(match.Groups[1].Value, out uint current) && uint.TryParse(match.Groups[2].Value, out uint total))
-            {
-                float percentProgress = (current / (float)total) * 100;
-                ProgressBar.Value = percentProgress;
-                ProgressLabel.Text = string.Format($"{text} ({percentProgress:N2}%)");
-            }
-        }
-
-        #endregion
     }
 }