Bump version

* Attempt to read PS3 firmware version

* Improve PS3 Firmware Version parsing

* Enable PS3 Firmware Version detection for all 3 Programs

* Big endian byte location

* Contents field not Comments field

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,27 @@
+---
+name: Feature Request
+about: For when you know better than me what you want
+title: "[Request]"
+labels: enhancement
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
+- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
+- Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
+
+If none of those apply, then continue...
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/informational.md

@@ -0,0 +1,21 @@
+---
+name: Info
+about: Something you need to tell me
+title: "[Info]"
+labels: question
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
+- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
+- Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
+
+If none of those apply, then continue...
+
+**Is your information related to one of the dumping programs supported or something that isn't a bug in the code? Please describe.**
+A clear and concise description of what the information is. Ex. With the latest build of DumpingProgram, it [...]
+
+**Additional context**
+Add any other context or screenshots about the information here.

.github/ISSUE_TEMPLATE/issue-report.md

@@ -0,0 +1,48 @@
+---
+name: Issue Report
+about: Tell me what's wrong, seriously
+title: "[Problem]"
+labels: bug
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the issue has already been addressed.
+- Is it copy protection related? If so, report the issue [here](https://github.com/mnadareski/BurnOutSharp/issues) instead.
+- Check multiple discs to help narrow down the issue
+- Check the Options to see if changing any of those affects your issue.
+
+If all of those fail, then continue...
+
+**Version**
+What version are you using? 
+
+- [ ] Stable release (version here)
+- [ ] WIP release (version here)
+
+**Build**
+What runtime version are you using?
+
+- [ ] .NET Framework 4.8 running on (Operating System)
+- [ ] .NET 6.0 running on (Operating System)
+- [ ] .NET 7.0 running on (Operating System)
+
+**Describe the issue**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/MPF.Check/bin/Debug/net6.0/MPF.Check.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/MPF.Check",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "omnisharp.projectLoadTimeout": 480
+}

.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/MPF.sln",
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "${workspaceFolder}/MPF/MPF.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

App.config

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-  <appSettings>
-    <add key="dicPath" value="Programs\DiscImageCreator.exe"/>
-    <add key="psxt001zPath" value="psxt001z.exe"/>
-    <add key="sgRawPath" value="sg_raw.exe"/>
-    <add key="defaultOutputPath" value="ISO"/>
-  </appSettings>
-</configuration>

App.xaml

@@ -1,9 +0,0 @@
-<Application x:Class="DICUI.App"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:DICUI"
-             StartupUri="MainWindow.xaml">
-    <Application.Resources>
-         
-    </Application.Resources>
-</Application>

App.xaml.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Configuration;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Windows;
-
-namespace DICUI
-{
-    /// <summary>
-    /// Interaction logic for App.xaml
-    /// </summary>
-    public partial class App : Application
-    {
-    }
-}

Constants.cs

@@ -1,102 +0,0 @@
-namespace DICUI
-{
-    public static class UIElements
-    {
-        public const string StartDumping = "Start Dumping";
-        public const string StopDumping = "Stop Dumping";
-    }
-
-    public static class DICCommands
-    {
-        // Commands
-
-        public const string CompactDiscCommand = "cd";
-        public const string DataCommand = "data";
-        public const string AudioCommand = "audio";
-        public const string GDROMCommand = "gd";
-        public const string GDROMSwapCommand = "swap";
-        public const string DVDCommand = "dvd";
-        public const string BDCommand = "bd";
-        public const string FloppyCommand = "fd";
-        public const string StopCommand = "stop";
-        public const string StartCommand = "start";
-        public const string EjectCommand = "eject";
-        public const string CloseCommand = "close";
-        public const string ResetCommand = "reset";
-        public const string SubCommand = "sub";
-        public const string MDSCommand = "mds";
-        public const string DriveSpeedCommand = "ls"; // Unlisted in help text
-
-        // DIC Flags
-
-        public const string ForceUnitAccessFlag = "/f";
-        public const string DisableBeepFlag = "/q";
-        public const string CDAddOffsetFlag = "/a";
-        public const string CDBEOpcodeFlag = "/be";
-        public const string CDD8OpcodeFlag = "/d8";
-        public const string CDC2OpcodeFlag = "/c2";
-        public const string CDMCNFlag = "/m";
-        public const string CDAMSFFlag = "/p";
-        public const string CDReverseFlag = "/r";
-        public const string CDMultiSessionFlag = "/ms";
-        public const string CDScanFileProtectFlag = "/sf";
-        public const string CDScanSectorProtectFlag = "/ss";
-        public const string CDScanAnitModFlag = "/am";
-        public const string CDNoFixSubPFlag = "/np";
-        public const string CDNoFixSubQFlag = "/nq";
-        public const string CDNoFixSubRtoWFlag = "/nr";
-        public const string CDNoFixSubQLibCryptFlag = "/nl";
-        public const string CDNoFixSubQSecuROMFlag = "/ns";
-        public const string CDSubchannelReadLevelFlag = "/s";
-        public const string DVDCMIFlag = "/c";
-        public const string DVDRawFlag = "/raw";
-    }
-
-    public static class Template
-    {
-        // Manual information
-
-        public const string TitleField = "Title";
-        public const string DiscNumberField = "Disc Number / Letter";
-        public const string DiscTitleField = "Disc Title";
-        public const string CategoryField = "Category";
-        public const string RegionField = "Region";
-        public const string LanguagesField = "Languages";
-        public const string DiscSerialField = "Disc Serial";
-        public const string BarcodeField = "Barcode";
-        public const string ISBNField = "ISBN";
-        public const string CommentsField = "Comments";
-        public const string ContentsField = "Contents";
-        public const string VersionField = "Version";
-        public const string EditionField = "Edition/Release";
-        public const string CopyProtectionField = "Copy Protection";
-        public const string MasteringRingField = "Mastering Ring";
-        public const string MasteringSIDField = "Mastering SID Code";
-        public const string MouldSIDField = "Mould SID Code";
-        public const string AdditionalMouldField = "Additional Mould";
-        public const string ToolstampField = "Toolstamp or Mastering Code";
-
-        // Automatic Information
-
-        public const string PVDField = "Primary Volume Descriptor (PVD)";
-        public const string DATField = "DAT";
-        public const string ErrorCountField = "Error Count";
-        public const string CuesheetField = "Cuesheet";
-        public const string SubIntentionField = "SubIntention (SecuROM)";
-        public const string WriteOffsetField = "WriteOffset";
-        public const string LayerbreakField = "Layerbreak";
-        public const string PlaystationEXEDateField = "EXE Date"; // TODO: Not automatic yet
-        public const string PlayStationEDCField = "EDC"; // TODO: Not automatic yet
-        public const string PlayStationAntiModchipField = "Anti-modchip"; // TODO: Not automatic yet
-        public const string PlayStationLibCryptField = "LibCrypt"; // TODO: Not automatic yet
-        public const string SaturnHeaderField = "Header"; // TODO: Not automatic yet
-        public const string SaturnBuildDateField = "Build Date"; // TODO: Not automatic yet
-
-        // Default values
-
-        public const string RequiredValue = "(REQUIRED)";
-        public const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
-        public const string OptionalValue = "(OPTIONAL)";
-        public const string YesNoValue = "Yes/No";
-    }
-}

DICUI.csproj

@@ -1,131 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{7B1B75EB-8940-466F-BD51-76471A57F9BE}</ProjectGuid>
-    <OutputType>WinExe</OutputType>
-    <RootNamespace>DICUI</RootNamespace>
-    <AssemblyName>DICUI</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <WarningLevel>4</WarningLevel>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <PublishUrl>C:\Users\admin\Desktop\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>1</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <PublishWizardCompleted>true</PublishWizardCompleted>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>x86</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ApplicationIcon>Icon.ico</ApplicationIcon>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ManifestCertificateThumbprint>654CEE5FEAF46C8C1C369D7ED34DA157828A8D2F</ManifestCertificateThumbprint>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ManifestKeyFile>WpfApp1_TemporaryKey.pfx</ManifestKeyFile>
-  </PropertyGroup>
-  <PropertyGroup>
-    <GenerateManifests>true</GenerateManifests>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignManifests>false</SignManifests>
-  </PropertyGroup>
-  <PropertyGroup />
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Configuration" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xaml">
-      <RequiredTargetFramework>4.0</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="WindowsBase" />
-    <Reference Include="PresentationCore" />
-    <Reference Include="PresentationFramework" />
-  </ItemGroup>
-  <ItemGroup>
-    <ApplicationDefinition Include="App.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </ApplicationDefinition>
-    <Compile Include="Constants.cs" />
-    <Compile Include="Utilities.cs" />
-    <Page Include="MainWindow.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-    <Compile Include="App.xaml.cs">
-      <DependentUpon>App.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Enumerations.cs" />
-    <Compile Include="MainWindow.xaml.cs">
-      <DependentUpon>MainWindow.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Properties\AssemblyInfo.cs">
-      <SubType>Code</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="App.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include=".NETFramework,Version=v4.6.1">
-      <Visible>False</Visible>
-      <ProductName>Microsoft .NET Framework 4.6.1 %28x86 and x64%29</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="Icon.ico" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>

DICUI.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2036
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI", "DICUI.csproj", "{7B1B75EB-8940-466F-BD51-76471A57F9BE}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {73C62E6A-6584-4D93-83B5-ECB1FBDB469B}
-	EndGlobalSection
-EndGlobal

Enumerations.cs

@@ -1,107 +0,0 @@
-namespace DICUI
-{
-    /// <summary>
-    /// Known disc types
-    /// </summary>
-    public enum DiscType
-    {
-        NONE = 0,
-        CD,
-        DVD5,
-        DVD9,
-        GDROM,
-        HDDVD,
-        BD25,
-        BD50,
-
-        // Special Formats
-        GameCubeGameDisc,
-        UMD,
-        
-        // Keeping this separate since it's currently unsupported in the UI
-        Floppy = 99,
-    }
-
-    /// <summary>
-    /// Known systems
-    /// </summary>
-    /// <remarks>Ensure that Utilities methods are updated as well</remarks>
-    public enum KnownSystem
-    {
-        NONE = 0,
-
-        #region Consoles
-
-        BandaiPlaydiaQuickInteractiveSystem,
-        BandaiApplePippin,
-        CommodoreAmigaCD32,
-        CommodoreAmigaCDTV,
-        MattelHyperscan,
-        MicrosoftXBOX,
-        MicrosoftXBOX360,
-        MicrosoftXBOXOne,
-        NECPCEngineTurboGrafxCD,
-        NECPCFX,
-        NintendoGameCube,
-        NintendoWii,
-        NintendoWiiU,
-        Panasonic3DOInteractiveMultiplayer,
-        PhilipsCDi,
-        SegaCDMegaCD,
-        SegaDreamcast,
-        SegaSaturn,
-        SNKNeoGeoCD,
-        SonyPlayStation,
-        SonyPlayStation2,
-        SonyPlayStation3,
-        SonyPlayStation4,
-        SonyPlayStationPortable,
-        VMLabsNuon,
-        VTechVFlashVSmilePro,
-        ZAPiTGamesGameWaveFamilyEntertainmentSystem,
-
-        #endregion
-
-        #region Computers
-
-        AcornArchimedes,
-        AppleMacintosh,
-        CommodoreAmigaCD,
-        FujitsuFMTowns,
-        IBMPCCompatible,
-        NECPC88,
-        NECPC98,
-        SharpX68000,
-
-        #endregion
-
-        #region Arcade
-
-        NamcoSegaNintendoTriforce,
-        NamcoSystem246,
-        SegaChihiro,
-        SegaLindbergh,
-        SegaNaomi,
-        SegaNaomi2,
-        TABAustriaQuizard,
-        TandyMemorexVisualInformationSystem,
-
-        #endregion
-
-        #region Other
-
-        AudioCD,
-        BDVideo,
-        DVDVideo,
-        EnhancedCD,
-        PalmOS,
-        PhilipsCDiDigitalVideo,
-        PhotoCD,
-        PlayStationGameSharkUpdates,
-        TaoiKTV,
-        TomyKissSite,
-        VideoCD,
-
-        #endregion
-    }
-}

LICENSE

@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    DICUI  Copyright (C) 2018  ReignStumble
+    MPF  Copyright (C) 2018  ReignStumble
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

MPF.Check/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/>
+    </startup>
+</configuration>

MPF.Check/MPF.Check.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net6.0;net7.0</TargetFrameworks>
+    <RuntimeIdentifiers>win-x64;linux-x64;osx-x64</RuntimeIdentifiers>
+    <OutputType>Exe</OutputType>
+    <Title>MPF Check</Title>
+    <Description>Validator for various dumping programs</Description>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2023</Copyright>
+    <VersionPrefix>2.7.5</VersionPrefix>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='net48'">
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="2.9.0" GeneratePathProperty="true">
+      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.1.1" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <Content Include="$(PkgBurnOutSharp)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
+  </ItemGroup>
+
+</Project>

MPF.Check/Program.cs

@@ -0,0 +1,118 @@
+using System;
+using System.IO;
+using BinaryObjectScanner;
+using MPF.Core;
+using MPF.Core.Data;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Check
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Try processing the standalone arguments
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
+            {
+                if (standaloneProcessed == null)
+                    DisplayHelp();
+                return;
+            }
+
+            // Try processing the common arguments
+            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
+            if (!success)
+            {
+                DisplayHelp(error);
+                return;
+            }
+
+            // Loop through and process options
+            (var options, var seedInfo, var path, int startIndex) = OptionsLoader.LoadFromArguments(args, startIndex: 2);
+            if (options.InternalProgram == InternalProgram.NONE)
+            {
+                DisplayHelp("A program name needs to be provided");
+                return;
+            }
+
+            // Make new Progress objects
+            var resultProgress = new Progress<Result>();
+            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+            var protectionProgress = new Progress<ProtectionProgress>();
+            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
+
+            // Validate the supplied credentials
+#if NET48
+            (bool? _, string message) = RedumpWebClient.ValidateCredentials(options?.RedumpUsername, options?.RedumpPassword);
+#else
+            (bool? _, string? message) = RedumpHttpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).ConfigureAwait(false).GetAwaiter().GetResult();
+#endif
+            if (!string.IsNullOrWhiteSpace(message))
+                Console.WriteLine(message);
+
+            // Loop through all the rest of the args
+            for (int i = startIndex; i < args.Length; i++)
+            {
+                // Check for a file
+                if (!File.Exists(args[i].Trim('"')))
+                {
+                    DisplayHelp($"{args[i].Trim('"')} does not exist");
+                    return;
+                }
+
+                // Get the full file path
+                string filepath = Path.GetFullPath(args[i].Trim('"'));
+
+                // Now populate an environment
+#if NET48
+                Drive drive = null;
+#else
+                Drive? drive = null;
+#endif
+                if (!string.IsNullOrWhiteSpace(path))
+                    drive = Drive.Create(null, path);
+
+                var env = new DumpEnvironment(options, filepath, drive, knownSystem, mediaType, internalProgram: null, parameters: null);
+
+                // Finally, attempt to do the output dance
+                var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress).ConfigureAwait(false).GetAwaiter().GetResult();
+                Console.WriteLine(result.Message);
+            }
+        }
+
+        /// <summary>
+        /// Display help for MPF.Check
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+#if NET48
+        private static void DisplayHelp(string error = null)
+#else
+        private static void DisplayHelp(string? error = null)
+#endif
+        {
+            if (error != null)
+                Console.WriteLine(error);
+
+            Console.WriteLine("Usage:");
+            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");
+            Console.WriteLine("-lm, --listmedia        List supported media types");
+            Console.WriteLine("-ls, --listsystems      List supported system types");
+            Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
+            Console.WriteLine();
+
+            Console.WriteLine("Check Options:");
+            var supportedArguments = OptionsLoader.PrintSupportedArguments();
+            foreach (string argument in supportedArguments)
+            {
+                Console.WriteLine(argument);
+            }
+            Console.WriteLine();
+        }
+    }
+}

MPF.Check/launchSettings.json

@@ -0,0 +1,7 @@
+{
+  "profiles": {
+    "MPF.Check": {
+      "commandName": "Project"
+    }
+  }
+}

MPF.Core/ConsoleLogger.cs

@@ -0,0 +1,33 @@
+using System;
+using BinaryObjectScanner;
+using MPF.Core.Data;
+
+namespace MPF.Core
+{
+    public static class ConsoleLogger
+    {
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+#if NET48
+        public static void ProgressUpdated(object sender, Result value)
+#else
+        public static void ProgressUpdated(object? sender, Result value)
+#endif
+        {
+            Console.WriteLine(value.Message);
+        }
+
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+#if NET48
+        public static void ProgressUpdated(object sender, ProtectionProgress value)
+#else
+        public static void ProgressUpdated(object? sender, ProtectionProgress value)
+#endif
+        {
+            Console.WriteLine($"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}");
+        }
+    }
+}

MPF.Core/Converters/EnumConverter.cs

@@ -0,0 +1,345 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Reflection;
+using MPF.Core.Data;
+using SabreTools.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;
+            }
+        }
+
+        #endregion
+
+        #region Convert to Long Name
+
+        /// <summary>
+        /// Long name method cache
+        /// </summary>
+#if NET48
+        private static readonly ConcurrentDictionary<Type, MethodInfo> LongNameMethods = new ConcurrentDictionary<Type, MethodInfo>();
+#else
+        private static readonly ConcurrentDictionary<Type, MethodInfo?> LongNameMethods = new ConcurrentDictionary<Type, MethodInfo?>();
+#endif
+
+        /// <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 var method))
+                {
+                    method = typeof(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 ?? string.Empty;
+                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.DiscImageCreator:
+                    return "DiscImageCreator";
+                case InternalProgram.Redumper:
+                    return "Redumper";
+
+                #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>
+#if NET48
+        public static InternalProgram ToInternalProgram(string internalProgram)
+#else
+        public static InternalProgram ToInternalProgram(string? internalProgram)
+#endif
+        {
+            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 "rd":
+                case "redumper":
+                    return InternalProgram.Redumper;
+
+                // 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

@@ -0,0 +1,121 @@
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Constant values for UI
+    /// </summary>
+    public static class Interface
+    {
+        // Button values
+        public const string StartDumping = "Start Dumping";
+        public const string StopDumping = "Stop Dumping";
+
+        // Byte arrays for signatures
+        public static readonly byte[] SaturnSectorZeroStart = new byte[] { 0x53, 0x45, 0x47, 0x41, 0x20, 0x53, 0x45, 0x47, 0x41, 0x53, 0x41, 0x54, 0x55, 0x52, 0x4E, 0x20 };
+
+        // Lists of known drive speed ranges
+        public 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 };
+        public static IReadOnlyList<int> DVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IReadOnlyList<int> HDDVD { get; } = CD.Where(s => s <= 24).ToList();
+        public static IReadOnlyList<int> BD { get; } = CD.Where(s => s <= 16).ToList();
+        public static IReadOnlyList<int> Unknown { get; } = new List<int> { 1 };
+
+        /// <summary>
+        /// Get list of all drive speeds for a given MediaType
+        /// </summary>
+        /// <param name="type">MediaType? that represents the current item</param>
+        /// <returns>Read-only list of drive speeds</returns>
+        public static IReadOnlyList<int> GetSpeedsForMediaType(MediaType? type)
+        {
+            switch (type)
+            {
+                case MediaType.CDROM:
+                case MediaType.GDROM:
+                    return CD;
+                case MediaType.DVD:
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return DVD;
+                case MediaType.HDDVD:
+                    return HDDVD;
+                case MediaType.BluRay:
+                    return BD;
+                default:
+                    return Unknown;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Template field values for submission info
+    /// </summary>
+    public static class Template
+    {
+        // Manual information
+
+        public const string TitleField = "Title";
+        public const string ForeignTitleField = "Foreign Title (Non-latin)";
+        public const string DiscNumberField = "Disc Number / Letter";
+        public const string DiscTitleField = "Disc Title";
+        public const string SystemField = "System";
+        public const string MediaTypeField = "Media Type";
+        public const string CategoryField = "Category";
+        public const string RegionField = "Region";
+        public const string LanguagesField = "Languages";
+        public const string PlaystationLanguageSelectionViaField = "Language Selection Via";
+        public const string DiscSerialField = "Disc Serial";
+        public const string BarcodeField = "Barcode";
+        public const string CommentsField = "Comments";
+        public const string ContentsField = "Contents";
+        public const string VersionField = "Version";
+        public const string EditionField = "Edition/Release";
+        public const string PlayStation3WiiDiscKeyField = "Disc Key";
+        public const string PlayStation3DiscIDField = "Disc ID";
+        public const string GameCubeWiiBCAField = "BCA";
+        public const string CopyProtectionField = "Copy Protection";
+        public const string MasteringRingField = "Mastering Code (laser branded/etched)";
+        public const string MasteringSIDField = "Mastering SID Code";
+        public const string MouldSIDField = "Mould SID Code";
+        public const string AdditionalMouldField = "Additional Mould";
+        public const string ToolstampField = "Toolstamp or Mastering Code (engraved/stamped)";
+
+        // Automatic Information
+
+        public const string DumpingProgramField = "Dumping Program";
+        public const string DumpingDateField = "Date";
+        public const string DumpingDriveManufacturer = "Manufacturer";
+        public const string DumpingDriveModel = "Model";
+        public const string DumpingDriveFirmware = "Firmware";
+        public const string ReportedDiscType = "Reported Disc Type";
+        public const string PVDField = "Primary Volume Descriptor (PVD)";
+        public const string DATField = "DAT";
+        public const string SizeField = "Size";
+        public const string CRC32Field = "CRC32";
+        public const string MD5Field = "MD5";
+        public const string SHA1Field = "SHA1";
+        public const string FullyMatchingIDField = "Fully Matching ID";
+        public const string PartiallyMatchingIDsField = "Partially Matching IDs";
+        public const string ErrorCountField = "Error Count";
+        public const string CuesheetField = "Cuesheet";
+        public const string SubIntentionField = "SubIntention Data (SecuROM/LibCrypt)";
+        public const string WriteOffsetField = "Write Offset";
+        public const string LayerbreakField = "Layerbreak";
+        public const string EXEDateBuildDate = "EXE/Build Date";
+        public const string HeaderField = "Header";
+        public const string PICField = "Permanent Information & Control (PIC)";
+        public const string PlayStationEDCField = "EDC";
+        public const string PlayStationAntiModchipField = "Anti-modchip";
+        public const string PlayStationLibCryptField = "LibCrypt";
+        public const string XBOXSSRanges = "Security Sector Ranges";
+
+        // Default values
+
+        public const string RequiredValue = "(REQUIRED)";
+        public const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
+        public const string OptionalValue = "(OPTIONAL)";
+        public const string DiscNotDetected = "Disc Not Detected";
+    }
+}

MPF.Core/Data/Drive.cs

@@ -0,0 +1,602 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.Management.Infrastructure;
+using Microsoft.Management.Infrastructure.Generic;
+using MPF.Core.Converters;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Represents information for a single drive
+    /// </summary>
+    /// <remarks>
+    /// TODO: Can the Aaru models be used instead of the ones I've created here?
+    /// </remarks>
+    public class Drive
+    {
+        #region Fields
+
+        /// <summary>
+        /// Represents drive type
+        /// </summary>
+        public InternalDriveType? InternalDriveType { get; set; }
+
+        /// <summary>
+        /// Drive partition format
+        /// </summary>
+#if NET48
+        public string DriveFormat { get; private set; } = null;
+#else
+        public string? DriveFormat { get; private set; } = null;
+#endif
+
+        /// <summary>
+        /// Windows drive path
+        /// </summary>
+#if NET48
+        public string Name { get; private set; } = null;
+#else
+        public string? Name { get; private set; } = null;
+#endif
+
+        /// <summary>
+        /// Represents if Windows has marked the drive as active
+        /// </summary>
+        public bool MarkedActive { get; private set; } = false;
+
+        /// <summary>
+        /// Represents the total size of the drive
+        /// </summary>
+        public long TotalSize { get; private set; } = default;
+
+        /// <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>
+#if NET48
+        public string VolumeLabel { get; private set; } = null;
+#else
+        public string? VolumeLabel { get; private set; } = null;
+#endif
+
+        #endregion
+
+        #region Derived Fields
+
+        /// <summary>
+        /// Media label as read by Windows, formatted to avoid odd outputs
+        /// </summary>
+#if NET48
+        public string FormattedVolumeLabel
+#else
+        public string? FormattedVolumeLabel
+#endif
+        {
+            get
+            {
+                string volumeLabel = Template.DiscNotDetected;
+                if (this.MarkedActive)
+                {
+                    if (string.IsNullOrWhiteSpace(this.VolumeLabel))
+                        volumeLabel = "track";
+                    else
+                        volumeLabel = this.VolumeLabel;
+                }
+
+                foreach (char c in Path.GetInvalidFileNameChars())
+                    volumeLabel = volumeLabel.Replace(c, '_');
+
+                return volumeLabel;
+            }
+        }
+
+        /// <summary>
+        /// Read-only access to the drive letter
+        /// </summary>
+        /// <remarks>Should only be used in UI applications</remarks>
+        public char? Letter => this.Name?[0] ?? '\0';
+
+        #endregion
+
+        /// <summary>
+        /// Protected constructor
+        /// </summary>
+        protected Drive() { }
+
+        /// <summary>
+        /// Create a new Drive object from a drive type and device path
+        /// </summary>
+        /// <param name="driveType">InternalDriveType value representing the drive type</param>
+        /// <param name="devicePath">Path to the device according to the local machine</param>
+#if NET48
+        public static Drive Create(InternalDriveType? driveType, string devicePath)
+#else
+        public static Drive? Create(InternalDriveType? driveType, string devicePath)
+#endif
+        {
+            // Create a new, empty drive object
+            var drive = new Drive()
+            {
+                InternalDriveType = driveType,
+            };
+
+            // If we have an invalid device path, return null
+            if (string.IsNullOrWhiteSpace(devicePath))
+                return null;
+
+            // Sanitize a Windows-formatted long device path
+            if (devicePath.StartsWith("\\\\.\\"))
+#if NET48
+                devicePath = devicePath.Substring("\\\\.\\".Length);
+#else
+                devicePath = devicePath["\\\\.\\".Length..];
+#endif
+
+            // Create and validate the drive info object
+            var driveInfo = new DriveInfo(devicePath);
+            if (driveInfo == null || driveInfo == default)
+                return null;
+
+            // Fill in the rest of the data
+            drive.PopulateFromDriveInfo(driveInfo);
+
+            return drive;
+        }
+
+        /// <summary>
+        /// Populate all fields from a DriveInfo object
+        /// </summary>
+        /// <param name="driveInfo">DriveInfo object to populate from</param>
+#if NET48
+        private void PopulateFromDriveInfo(DriveInfo driveInfo)
+#else
+        private void PopulateFromDriveInfo(DriveInfo? driveInfo)
+#endif
+        {
+            // If we have an invalid DriveInfo, just return
+            if (driveInfo == null || driveInfo == default)
+                return;
+
+            // Populate the data fields
+            this.Name = driveInfo.Name;
+            this.MarkedActive = driveInfo.IsReady;
+            if (this.MarkedActive)
+            {
+                this.DriveFormat = driveInfo.DriveFormat;
+                this.TotalSize = driveInfo.TotalSize;
+                this.VolumeLabel = driveInfo.VolumeLabel;
+            }
+            else
+            {
+                this.DriveFormat = string.Empty;
+                this.TotalSize = default;
+                this.VolumeLabel = string.Empty;
+            }
+        }
+
+        #region Public Functionality
+
+        /// <summary>
+        /// Create a list of active drives matched to their volume labels
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>Active drives, matched to labels, if possible</returns>
+        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
+        {
+            var drives = GetDriveList(ignoreFixedDrives);
+            drives = drives.OrderBy(i => i == null ? "\0" : i.Name).ToList();
+            return drives;
+        }
+
+        /// <summary>
+        /// Get the current media type from drive letter
+        /// </summary>
+        /// <param name="system"></param>
+        /// <returns></returns>
+#if NET48
+        public (MediaType?, string) GetMediaType(RedumpSystem? system)
+#else
+        public (MediaType?, string?) GetMediaType(RedumpSystem? system)
+#endif
+        {
+            // Take care of the non-optical stuff first
+            switch (this.InternalDriveType)
+            {
+                case Data.InternalDriveType.Floppy:
+                    return (MediaType.FloppyDisk, null);
+                case Data.InternalDriveType.HardDisk:
+                    return (MediaType.HardDisk, null);
+                case Data.InternalDriveType.Removable:
+                    return (MediaType.FlashDrive, null);
+            }
+
+            // Some systems should default to certain media types
+            switch (system)
+            {
+                // CD
+                case RedumpSystem.Panasonic3DOInteractiveMultiplayer:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.SegaDreamcast:
+                case RedumpSystem.SegaSaturn:
+                case RedumpSystem.SonyPlayStation:
+                case RedumpSystem.VideoCD:
+                    return (MediaType.CDROM, null);
+
+                // DVD
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.MicrosoftXbox:
+                case RedumpSystem.MicrosoftXbox360:
+                    return (MediaType.DVD, null);
+
+                // HD-DVD
+                case RedumpSystem.HDDVDVideo:
+                    return (MediaType.HDDVD, null);
+
+                // Blu-ray
+                case RedumpSystem.BDVideo:
+                case RedumpSystem.MicrosoftXboxOne:
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                case RedumpSystem.SonyPlayStation3:
+                case RedumpSystem.SonyPlayStation4:
+                case RedumpSystem.SonyPlayStation5:
+                    return (MediaType.BluRay, null);
+
+                // GameCube
+                case RedumpSystem.NintendoGameCube:
+                    return (MediaType.NintendoGameCubeGameDisc, null);
+
+                // Wii
+                case RedumpSystem.NintendoWii:
+                    return (MediaType.NintendoWiiOpticalDisc, null);
+
+                // WiiU
+                case RedumpSystem.NintendoWiiU:
+                    return (MediaType.NintendoWiiUOpticalDisc, null);
+
+                // PSP
+                case RedumpSystem.SonyPlayStationPortable:
+                    return (MediaType.UMD, null);
+            }
+
+            // Handle optical media by size and filesystem
+            if (this.TotalSize >= 0 && this.TotalSize <= 800_000_000 && (this.DriveFormat == "CDFS" || this.DriveFormat == "UDF"))
+                return (MediaType.CDROM, null);
+            else if (this.TotalSize > 800_000_000 && this.TotalSize <= 8_540_000_000 && (this.DriveFormat == "CDFS" || this.DriveFormat == "UDF"))
+                return (MediaType.DVD, null);
+            else if (this.TotalSize > 8_540_000_000)
+                return (MediaType.BluRay, null);
+
+            return (null, "Could not determine media type!");
+        }
+
+        /// <summary>
+        /// Get the current system from drive
+        /// </summary>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public RedumpSystem? GetRedumpSystem(RedumpSystem? defaultValue)
+        {
+            // If we can't read the media in that drive, we can't do anything
+            if (!Directory.Exists(this.Name))
+                return defaultValue;
+
+            // We're going to assume for floppies, HDDs, and removable drives
+            if (this.InternalDriveType != Data.InternalDriveType.Optical)
+                return RedumpSystem.IBMPCcompatible;
+
+            // Check volume labels first
+            RedumpSystem? systemFromLabel = GetRedumpSystemFromVolumeLabel();
+            if (systemFromLabel != null)
+                return systemFromLabel;
+
+            // Get a list of files for quicker checking
+            #region Consoles
+
+            // Bandai Playdia Quick Interactive System
+            try
+            {
+                List<string> files = Directory.EnumerateFiles(this.Name, "*", SearchOption.TopDirectoryOnly).ToList();
+
+                if (files.Any(f => f.EndsWith(".AJS", StringComparison.OrdinalIgnoreCase))
+                    && files.Any(f => f.EndsWith(".GLB", StringComparison.OrdinalIgnoreCase)))
+                {
+                    return RedumpSystem.BandaiPlaydiaQuickInteractiveSystem;
+                }
+            }
+            catch { }
+
+            // Mattel Fisher-Price iXL
+            if (File.Exists(Path.Combine(this.Name, "iXL", "iXLUpdater.exe")))
+            {
+                return RedumpSystem.MattelFisherPriceiXL;
+            }
+
+            // Microsoft Xbox 360
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "$SystemUpdate"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "$SystemUpdate")).Any()
+                    && this.TotalSize <= 500_000_000)
+                {
+                    return RedumpSystem.MicrosoftXbox360;
+                }
+            }
+            catch { }
+
+            // Microsoft Xbox One
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "MSXC"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "MSXC")).Any())
+                {
+                    return RedumpSystem.MicrosoftXboxOne;
+                }
+            }
+            catch { }
+
+            // Sega Dreamcast
+            if (File.Exists(Path.Combine(this.Name, "IP.BIN")))
+            {
+                return RedumpSystem.SegaDreamcast;
+            }
+
+            // Sega Mega-CD / Sega-CD
+            if (File.Exists(Path.Combine(this.Name, "_BOOT", "IP.BIN"))
+                || File.Exists(Path.Combine(this.Name, "_BOOT", "SP.BIN"))
+                || File.Exists(Path.Combine(this.Name, "_BOOT", "SP_AS.BIN"))
+                || File.Exists(Path.Combine(this.Name, "FILESYSTEM.BIN")))
+            {
+                return RedumpSystem.SegaMegaCDSegaCD;
+            }
+
+            // Sony PlayStation and Sony PlayStation 2
+            string psxExePath = Path.Combine(this.Name, "PSX.EXE");
+            string systemCnfPath = Path.Combine(this.Name, "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;
+            }
+
+            // Sony PlayStation 3
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "PS3_GAME"))
+                    || Directory.Exists(Path.Combine(this.Name, "PS3_UPDATE"))
+                    || File.Exists(Path.Combine(this.Name, "PS3_DISC.SFB")))
+                {
+                    return RedumpSystem.SonyPlayStation3;
+                }
+            }
+            catch { }
+
+            // Sony PlayStation 4
+            // There are more possible paths that could be checked.
+            //  There are some entries that can be found on most PS4 discs:
+            //    "/app/GAME_SERIAL/app.pkg"
+            //    "/bd/param.sfo"
+            //    "/license/rif"
+            // There are also extra files that can be found on some discs:
+            //    "/patch/GAME_SERIAL/patch.pkg" can be found in Redump entry 66816.
+            //        Originally on disc as "/patch/CUSA11302/patch.pkg".
+            //        Is used as an on-disc update for the base game app without needing to get update from the internet.
+            //    "/addcont/GAME_SERIAL/CONTENT_ID/ac.pkg" can be found in Redump entry 97619.
+            //        Originally on disc as "/addcont/CUSA00288/FFXIVEXPS400001A/ac.pkg".
+            if (File.Exists(Path.Combine(this.Name, "PS4", "UPDATE", "PS4UPDATE.PUP")))
+            {
+                return RedumpSystem.SonyPlayStation4;
+            }
+
+            // V.Tech V.Flash / V.Smile Pro
+            if (File.Exists(Path.Combine(this.Name, "0SYSTEM")))
+            {
+                return RedumpSystem.VTechVFlashVSmilePro;
+            }
+
+            #endregion
+
+            #region Computers
+
+            // Sharp X68000
+            if (File.Exists(Path.Combine(this.Name, "COMMAND.X")))
+            {
+                return RedumpSystem.SharpX68000;
+            }
+
+            #endregion
+
+            #region Video Formats
+
+            // BD-Video
+            if (Directory.Exists(Path.Combine(this.Name, "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(this.Name, "AUDIO_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "AUDIO_TS")).Any())
+                {
+                    return RedumpSystem.DVDAudio;
+                }
+
+                else if (Directory.Exists(Path.Combine(this.Name, "VIDEO_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "VIDEO_TS")).Any())
+                {
+                    return RedumpSystem.DVDVideo;
+                }
+            }
+            catch { }
+
+            // HD-DVD-Video
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "HVDVD_TS"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "HVDVD_TS")).Any())
+                {
+                    return RedumpSystem.HDDVDVideo;
+                }
+            }
+            catch { }
+
+            // VCD
+            try
+            {
+                if (Directory.Exists(Path.Combine(this.Name, "VCD"))
+                    && Directory.EnumerateFiles(Path.Combine(this.Name, "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;
+
+            // Sega Mega-CD / Sega-CD
+            if (this.VolumeLabel.Equals("Sega_CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SegaMegaCDSegaCD;
+
+            // 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>
+        /// Refresh the current drive information based on path
+        /// </summary>
+        public void RefreshDrive()
+        {
+            var driveInfo = DriveInfo.GetDrives().FirstOrDefault(d => d?.Name == this.Name);
+            this.PopulateFromDriveInfo(driveInfo);
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Get all current attached Drives
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>List of drives, null on error</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>
+        private static List<Drive> GetDriveList(bool ignoreFixedDrives)
+        {
+            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
+            if (!ignoreFixedDrives)
+            {
+                desiredDriveTypes.Add(DriveType.Fixed);
+                desiredDriveTypes.Add(DriveType.Removable);
+            }
+
+            // TODO: Reduce reliance on `DriveInfo`
+            // https://github.com/aaru-dps/Aaru/blob/5164a154e2145941472f2ee0aeb2eff3338ecbb3/Aaru.Devices/Windows/ListDevices.cs#L66
+
+            // Create an output drive list
+            var drives = new List<Drive>();
+
+            // Get all standard supported drive types
+            try
+            {
+                drives = DriveInfo.GetDrives()
+                    .Where(d => desiredDriveTypes.Contains(d.DriveType))
+                    .Select(d => Create(EnumConverter.ToInternalDriveType(d.DriveType), d.Name) ?? new Drive())
+                    .ToList();
+            }
+            catch
+            {
+                return drives;
+            }
+
+            // Find and update all floppy drives
+            try
+            {
+                CimSession session = CimSession.Create(null);
+                var collection = session.QueryInstances("root\\CIMV2", "WQL", "SELECT * FROM Win32_LogicalDisk");
+
+                foreach (CimInstance instance in collection)
+                {
+                    CimKeyedCollection<CimProperty> properties = instance.CimInstanceProperties;
+                    uint? mediaType = properties["MediaType"]?.Value as uint?;
+                    if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
+                    {
+                        char devId = (properties["Caption"].Value as string ?? string.Empty)[0];
+                        drives.ForEach(d => { if (d?.Name != null && d.Name[0] == devId) { d.InternalDriveType = Data.InternalDriveType.Floppy; } });
+                    }
+                }
+            }
+            catch
+            {
+                // No-op
+            }
+
+            return drives;
+        }
+
+        #endregion
+    }
+}

MPF.Core/Data/Enumerations.cs

@@ -0,0 +1,58 @@
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Available hashing types
+    /// </summary>
+    public enum Hash
+    {
+        CRC32,
+        CRC64,
+        MD5,
+        SHA1,
+        SHA256,
+        SHA384,
+        SHA512,
+        XxHash32,
+        XxHash64,
+    }
+
+    /// <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,
+        DiscImageCreator,
+        Redumper,
+
+        // Verification support only
+        CleanRip,
+        DCDumper,
+        UmdImageCreator,
+    }
+
+    /// <summary>
+    /// Log level for output
+    /// </summary>
+    public enum LogLevel
+    {
+        USER,
+        VERBOSE,
+        ERROR,
+        SECRET,
+    }
+}

MPF.Core/Data/IniFile.cs

@@ -0,0 +1,320 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace MPF.Core.Data
+{
+    public class IniFile : IDictionary<string, string>
+    {
+#if NET48
+        private Dictionary<string, string> _keyValuePairs = new Dictionary<string, string>();
+#else
+        private Dictionary<string, string> _keyValuePairs = new();
+#endif
+
+        public string this[string key]
+        {
+            get
+            {
+#if NET48
+                if (_keyValuePairs == null)
+                    _keyValuePairs = new Dictionary<string, string>();
+#else
+                _keyValuePairs ??= new Dictionary<string, string>();
+#endif
+
+                key = key.ToLowerInvariant();
+                if (_keyValuePairs.ContainsKey(key))
+                    return _keyValuePairs[key];
+
+                return string.Empty;
+            }
+            set
+            {
+#if NET48
+                if (_keyValuePairs == null)
+                    _keyValuePairs = new Dictionary<string, string>();
+#else
+                _keyValuePairs ??= new Dictionary<string, string>();
+#endif
+
+                key = key.ToLowerInvariant();
+                _keyValuePairs[key] = value;
+            }
+        }
+
+        /// <summary>
+        /// Create an empty INI file
+        /// </summary>
+        public IniFile()
+        {
+        }
+
+        /// <summary>
+        /// Populate an INI file from path
+        /// </summary>
+        public IniFile(string path)
+        {
+            this.Parse(path);
+        }
+
+        /// <summary>
+        /// Populate an INI file from stream
+        /// </summary>
+        public IniFile(Stream stream)
+        {
+            this.Parse(stream);
+        }
+
+        /// <summary>
+        /// Add or update a key and value to the INI file
+        /// </summary>
+        public void AddOrUpdate(string key, string value)
+        {
+            _keyValuePairs[key.ToLowerInvariant()] = value;
+        }
+
+        /// <summary>
+        /// Remove a key from the INI file
+        /// </summary>
+        public void Remove(string key)
+        {
+            _keyValuePairs.Remove(key.ToLowerInvariant());
+        }
+
+        /// <summary>
+        /// Read an INI file based on the path
+        /// </summary>
+        public bool Parse(string path)
+        {
+            // If we don't have a file, we can't read it
+            if (!File.Exists(path))
+                return false;
+
+            using (var fileStream = File.OpenRead(path))
+            {
+                return Parse(fileStream);
+            }
+        }
+
+        /// <summary>
+        /// Read an INI file from a stream
+        /// </summary>
+        public bool Parse(Stream stream)
+        {
+            // If the stream is invalid or unreadable, we can't process it
+            if (stream == null || !stream.CanRead || stream.Position >= stream.Length - 1)
+                return false;
+
+            // Keys are case-insensitive by default
+            try
+            {
+                using (var sr = new StreamReader(stream))
+                {
+                    string section = string.Empty;
+                    while (!sr.EndOfStream)
+                    {
+                        var line = sr.ReadLine()?.Trim();
+
+                        // Empty lines are skipped
+                        if (string.IsNullOrWhiteSpace(line))
+                        {
+                            // No-op, we don't process empty lines
+                        }
+
+                        // Comments start with ';'
+                        else if (line.StartsWith(";"))
+                        {
+                            // No-op, we don't process comments
+                        }
+
+                        // Section titles are surrounded by square brackets
+                        else if (line.StartsWith("["))
+                        {
+                            section = line.TrimStart('[').TrimEnd(']');
+                        }
+
+                        // Valid INI lines are in the format key=value
+#if NET48
+                        else if (line.Contains("="))
+#else
+                        else if (line.Contains('='))
+#endif
+                        {
+                            // Split the line by '=' for key-value pairs
+                            string[] data = line.Split('=');
+
+                            // If the value field contains an '=', we need to put them back in
+                            string key = data[0].Trim();
+                            string value = string.Join("=", data.Skip(1)).Trim();
+
+                            // Section names are prepended to the key with a '.' separating
+                            if (!string.IsNullOrEmpty(section))
+                                key = $"{section}.{key}";
+
+                            // Set or overwrite keys in the returned dictionary
+                            _keyValuePairs[key.ToLowerInvariant()] = value;
+                        }
+
+                        // All other lines are ignored
+                    }
+                }
+            }
+            catch
+            {
+                // We don't care what the error was, just catch and return
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Write an INI file to a path
+        /// </summary>
+        public bool Write(string path)
+        {
+            // If we don't have a valid dictionary with values, we can't write out
+            if (_keyValuePairs == null || _keyValuePairs.Count == 0)
+                return false;
+
+            using (var fileStream = File.OpenWrite(path))
+            {
+                return Write(fileStream);
+            }
+        }
+
+        /// <summary>
+        /// Write an INI file to a stream
+        /// </summary>
+        public bool Write(Stream stream)
+        {
+            // If we don't have a valid dictionary with values, we can't write out
+            if (_keyValuePairs == null || _keyValuePairs.Count == 0)
+                return false;
+
+            // If the stream is invalid or unwritable, we can't output to it
+            if (stream == null || !stream.CanWrite || stream.Position >= stream.Length - 1)
+                return false;
+
+            try
+            {
+                using (var sw = new StreamWriter(stream))
+                {
+                    // Order the dictionary by keys to link sections together
+                    var orderedKeyValuePairs = _keyValuePairs.OrderBy(kvp => kvp.Key);
+
+                    string section = string.Empty;
+                    foreach (var keyValuePair in orderedKeyValuePairs)
+                    {
+                        // Extract the key and value
+                        string key = keyValuePair.Key;
+                        string value = keyValuePair.Value;
+
+                        // We assume '.' is a section name separator
+                        if (key.Contains('.'))
+                        {
+                            // Split the key by '.'
+                            string[] data = keyValuePair.Key.Split('.');
+
+                            // If the key contains an '.', we need to put them back in
+                            string newSection = data[0].Trim();
+                            key = string.Join(".", data.Skip(1)).Trim();
+
+                            // If we have a new section, write it out
+                            if (!string.Equals(newSection, section, StringComparison.OrdinalIgnoreCase))
+                            {
+                                sw.WriteLine($"[{newSection}]");
+                                section = newSection;
+                            }
+                        }
+
+                        // Now write out the key and value in a standardized way
+                        sw.WriteLine($"{key}={value}");
+                    }
+                }
+            }
+            catch
+            {
+                // We don't care what the error was, just catch and return
+                return false;
+            }
+
+            return true;
+        }
+
+        #region IDictionary Impelementations
+
+        public ICollection<string> Keys => ((IDictionary<string, string>)_keyValuePairs).Keys;
+
+        public ICollection<string> Values => ((IDictionary<string, string>)_keyValuePairs).Values;
+
+        public int Count => ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Count;
+
+        public bool IsReadOnly => ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).IsReadOnly;
+
+        public void Add(string key, string value)
+        {
+            ((IDictionary<string, string>)_keyValuePairs).Add(key.ToLowerInvariant(), value);
+        }
+
+        bool IDictionary<string, string>.Remove(string key)
+        {
+            return ((IDictionary<string, string>)_keyValuePairs).Remove(key.ToLowerInvariant());
+        }
+
+        public bool TryGetValue(string key, out string value)
+        {
+            bool result = ((IDictionary<string, string>)_keyValuePairs).TryGetValue(key.ToLowerInvariant(), out var temp);
+            value = temp ?? string.Empty;
+            return result;
+        }
+
+        public void Add(KeyValuePair<string, string> item)
+        {
+            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
+            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Add(newItem);
+        }
+
+        public void Clear()
+        {
+            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Clear();
+        }
+
+        public bool Contains(KeyValuePair<string, string> item)
+        {
+            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
+            return ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Contains(newItem);
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return _keyValuePairs.ContainsKey(key.ToLowerInvariant());
+        }
+
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex)
+        {
+            ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(KeyValuePair<string, string> item)
+        {
+            var newItem = new KeyValuePair<string, string>(item.Key.ToLowerInvariant(), item.Value);
+            return ((ICollection<KeyValuePair<string, string>>)_keyValuePairs).Remove(newItem);
+        }
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            return ((IEnumerable<KeyValuePair<string, string>>)_keyValuePairs).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable)_keyValuePairs).GetEnumerator();
+        }
+
+        #endregion
+    }
+}

MPF.Core/Data/Options.cs

@@ -0,0 +1,755 @@
+using System.Collections.Generic;
+using MPF.Core.Converters;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Data
+{
+    public class Options
+    {
+        /// <summary>
+        /// All settings in the form of a dictionary
+        /// </summary>
+#if NET48
+        public Dictionary<string, string> Settings { get; private set; }
+#else
+        public Dictionary<string, string?> Settings { get; private set; }
+#endif
+
+        /// <summary>
+        /// Indicate if the program is being run with a clean configuration
+        /// </summary>
+        public bool FirstRun
+        {
+            get { return GetBooleanSetting(Settings, "FirstRun", true); }
+            set { Settings["FirstRun"] = value.ToString(); }
+        }
+
+        #region Internal Program
+
+        /// <summary>
+        /// Path to Aaru
+        /// </summary>
+#if NET48
+        public string AaruPath
+#else
+        public string? AaruPath
+#endif
+        {
+            get { return GetStringSetting(Settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            set { Settings["AaruPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to DiscImageCreator
+        /// </summary>
+#if NET48
+        public string DiscImageCreatorPath
+#else
+        public string? DiscImageCreatorPath
+#endif
+        {
+            get { return GetStringSetting(Settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            set { Settings["DiscImageCreatorPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to Redumper
+        /// </summary>
+#if NET48
+        public string RedumperPath
+#else
+        public string? RedumperPath
+#endif
+        {
+            get { return GetStringSetting(Settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
+            set { Settings["RedumperPath"] = value; }
+        }
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram InternalProgram
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "InternalProgram", InternalProgram.DiscImageCreator.ToString());
+                var valueEnum = EnumConverter.ToInternalProgram(valueString);
+                return valueEnum == InternalProgram.NONE ? InternalProgram.DiscImageCreator : valueEnum;
+            }
+            set
+            {
+                Settings["InternalProgram"] = value.ToString();
+            }
+        }
+
+        #endregion
+
+        #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>
+        /// Fast update label - Skips disc checks and updates path only
+        /// </summary>
+        public bool FastUpdateLabel
+        {
+            get { return GetBooleanSetting(Settings, "FastUpdateLabel", false); }
+            set { Settings["FastUpdateLabel"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default output path for dumps
+        /// </summary>
+#if NET48
+        public string DefaultOutputPath
+#else
+        public string? DefaultOutputPath
+#endif
+        {
+            get { return GetStringSetting(Settings, "DefaultOutputPath", "ISO"); }
+            set { Settings["DefaultOutputPath"] = value; }
+        }
+
+        /// <summary>
+        /// Default system if none can be detected
+        /// </summary>
+        public RedumpSystem? DefaultSystem
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "DefaultSystem", null);
+                var valueEnum = Extensions.ToRedumpSystem(valueString ?? string.Empty);
+                return valueEnum;
+            }
+            set
+            {
+                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
+
+        /// <summary>
+        /// Default CD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedCD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedCD", 24); }
+            set { Settings["PreferredDumpSpeedCD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedDVD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedDVD", 16); }
+            set { Settings["PreferredDumpSpeedDVD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default HD-DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedHDDVD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedHDDVD", 8); }
+            set { Settings["PreferredDumpSpeedHDDVD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default BD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedBD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedBD", 8); }
+            set { Settings["PreferredDumpSpeedBD"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Aaru
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool AaruEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, "AaruEnableDebug", false); }
+            set { Settings["AaruEnableDebug"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool AaruEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, "AaruEnableVerbose", false); }
+            set { Settings["AaruEnableVerbose"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable force dumping of media by default
+        /// </summary>
+        public bool AaruForceDumping
+        {
+            get { return GetBooleanSetting(Settings, "AaruForceDumping", true); }
+            set { Settings["AaruForceDumping"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of sector/subchannel rereads
+        /// </summary>
+        public int AaruRereadCount
+        {
+            get { return GetInt32Setting(Settings, "AaruRereadCount", 5); }
+            set { Settings["AaruRereadCount"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Strip personal data information from Aaru metadata by default
+        /// </summary>
+        public bool AaruStripPersonalData
+        {
+            get { return GetBooleanSetting(Settings, "AaruStripPersonalData", false); }
+            set { Settings["AaruStripPersonalData"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region DiscImageCreator
+
+        /// <summary>
+        /// Enable multi-sector read flag by default
+        /// </summary>
+        public bool DICMultiSectorRead
+        {
+            get { return GetBooleanSetting(Settings, "DICMultiSectorRead", false); }
+            set { Settings["DICMultiSectorRead"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include a default multi-sector read value
+        /// </summary>
+        public int DICMultiSectorReadValue
+        {
+            get { return GetInt32Setting(Settings, "DICMultiSectorReadValue", 0); }
+            set { Settings["DICMultiSectorReadValue"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable overly-secure dumping flags by default
+        /// </summary>
+        /// <remarks>
+        /// Split this into component parts later. Currently does:
+        /// - Scan sector protection and set subchannel read level to 2 for CD
+        /// - Set scan file protect flag for DVD
+        /// </remarks>
+        public bool DICParanoidMode
+        {
+            get { return GetBooleanSetting(Settings, "DICParanoidMode", false); }
+            set { Settings["DICParanoidMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable the Quiet flag by default
+        /// </summary>
+        public bool DICQuietMode
+        {
+            get { return GetBooleanSetting(Settings, "DICQuietMode", false); }
+            set { Settings["DICQuietMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of C2 rereads
+        /// </summary>
+        public int DICRereadCount
+        {
+            get { return GetInt32Setting(Settings, "DICRereadCount", 20); }
+            set { Settings["DICRereadCount"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of DVD/HD-DVD/BD rereads
+        /// </summary>
+        public int DICDVDRereadCount
+        {
+            get { return GetInt32Setting(Settings, "DICDVDRereadCount", 10); }
+            set { Settings["DICDVDRereadCount"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Reset drive after dumping (useful for older drives)
+        /// </summary>
+        public bool DICResetDriveAfterDump
+        {
+            get { return GetBooleanSetting(Settings, "DICResetDriveAfterDump", false); }
+            set { Settings["DICResetDriveAfterDump"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Use the CMI flag for supported disc types
+        /// </summary>
+        public bool DICUseCMIFlag
+        {
+            get { return GetBooleanSetting(Settings, "DICUseCMIFlag", false); }
+            set { Settings["DICUseCMIFlag"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redumper
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool RedumperEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, "RedumperEnableDebug", false); }
+            set { Settings["RedumperEnableDebug"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool RedumperEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, "RedumperEnableVerbose", false); }
+            set { Settings["RedumperEnableVerbose"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable BE reading by default with Redumper
+        /// </summary>
+        public bool RedumperUseBEReading
+        {
+            get { return GetBooleanSetting(Settings, "RedumperUseBEReading", false); }
+            set { Settings["RedumperUseBEReading"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable generic drive type by default with Redumper
+        /// </summary>
+        public bool RedumperUseGenericDriveType
+        {
+            get { return GetBooleanSetting(Settings, "RedumperUseGenericDriveType", false); }
+            set { Settings["RedumperUseGenericDriveType"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of rereads
+        /// </summary>
+        public int RedumperRereadCount
+        {
+            get { return GetInt32Setting(Settings, "RedumperRereadCount", 20); }
+            set { Settings["RedumperRereadCount"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Extra Dumping Options
+
+        /// <summary>
+        /// Scan the disc for protection after dumping
+        /// </summary>
+        public bool ScanForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanForProtection", true); }
+            set { Settings["ScanForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Output all found protections to a separate file in the directory
+        /// </summary>
+        public bool OutputSeparateProtectionFile
+        {
+            get { return GetBooleanSetting(Settings, "OutputSeparateProtectionFile", true); }
+            set { Settings["OutputSeparateProtectionFile"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add placeholder values in the submission info
+        /// </summary>
+        public bool AddPlaceholders
+        {
+            get { return GetBooleanSetting(Settings, "AddPlaceholders", true); }
+            set { Settings["AddPlaceholders"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show the disc information window after dumping
+        /// </summary>
+        public bool PromptForDiscInformation
+        {
+            get { return GetBooleanSetting(Settings, "PromptForDiscInformation", true); }
+            set { Settings["PromptForDiscInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Pull all information from Redump if signed in
+        /// </summary>
+        public bool PullAllInformation
+        {
+            get { return GetBooleanSetting(Settings, "PullAllInformation", false); }
+            set { Settings["PullAllInformation"] = 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>
+        /// Limit outputs to Redump-supported values only
+        /// </summary>
+        public bool EnableRedumpCompatibility
+        {
+            get { return GetBooleanSetting(Settings, "EnableRedumpCompatibility", true); }
+            set { Settings["EnableRedumpCompatibility"] = 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>
+        public bool EjectAfterDump
+        {
+            get { return GetBooleanSetting(Settings, "EjectAfterDump", false); }
+            set { Settings["EjectAfterDump"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Ignore fixed drives when populating the list
+        /// </summary>
+        public bool IgnoreFixedDrives
+        {
+            get { return GetBooleanSetting(Settings, "IgnoreFixedDrives", true); }
+            set { Settings["IgnoreFixedDrives"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show dumping tools in their own window instead of in the log
+        /// </summary>
+        public bool ToolsInSeparateWindow
+        {
+            get { return GetBooleanSetting(Settings, "ToolsInSeparateWindow", true); }
+            set { Settings["ToolsInSeparateWindow"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add the dump filename as a suffix to the auto-generated files
+        /// </summary>
+        public bool AddFilenameSuffix
+        {
+            get { return GetBooleanSetting(Settings, "AddFilenameSuffix", false); }
+            set { Settings["AddFilenameSuffix"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Output the compressed JSON version of the submission info
+        /// </summary>
+        public bool OutputSubmissionJSON
+        {
+            get { return GetBooleanSetting(Settings, "OutputSubmissionJSON", false); }
+            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>
+        public bool CompressLogFiles
+        {
+            get { return GetBooleanSetting(Settings, "CompressLogFiles", true); }
+            set { Settings["CompressLogFiles"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Delete unnecessary files to reduce space
+        /// </summary>
+        public bool DeleteUnnecessaryFiles
+        {
+            get { return GetBooleanSetting(Settings, "DeleteUnnecessaryFiles", false); }
+            set { Settings["DeleteUnnecessaryFiles"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Skip Options
+
+        /// <summary>
+        /// Skip detecting media type on disc scan
+        /// </summary>
+        public bool SkipMediaTypeDetection
+        {
+            get { return GetBooleanSetting(Settings, "SkipMediaTypeDetection", false); }
+            set { Settings["SkipMediaTypeDetection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Skip detecting known system on disc scan
+        /// </summary>
+        public bool SkipSystemDetection
+        {
+            get { return GetBooleanSetting(Settings, "SkipSystemDetection", false); }
+            set { Settings["SkipSystemDetection"] = value.ToString(); }
+        }
+
+        #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>
+        /// 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>
+        /// Enable verbose and debug logs to be written
+        /// </summary>
+        public bool VerboseLogging
+        {
+            get { return GetBooleanSetting(Settings, "VerboseLogging", true); }
+            set { Settings["VerboseLogging"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Have the log panel expanded by default on startup
+        /// </summary>
+        public bool OpenLogWindowAtStartup
+        {
+            get { return GetBooleanSetting(Settings, "OpenLogWindowAtStartup", true); }
+            set { Settings["OpenLogWindowAtStartup"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redump Login Information
+
+#if NET48
+        public string RedumpUsername
+#else
+        public string? RedumpUsername
+#endif
+        {
+            get { return GetStringSetting(Settings, "RedumpUsername", ""); }
+            set { Settings["RedumpUsername"] = value; }
+        }
+
+        // TODO: Figure out a way to keep this encrypted in some way, BASE64 to start?
+#if NET48
+        public string RedumpPassword
+#else
+        public string? RedumpPassword
+#endif
+        {
+            get
+            {
+                return GetStringSetting(Settings, "RedumpPassword", "");
+            }
+            set { Settings["RedumpPassword"] = value; }
+        }
+
+        /// <summary>
+        /// Determine if a complete set of Redump credentials might exist
+        /// </summary>
+        public bool HasRedumpLogin { get => !string.IsNullOrWhiteSpace(RedumpUsername) && !string.IsNullOrWhiteSpace(RedumpPassword); }
+
+        #endregion
+
+        /// <summary>
+        /// Constructor taking a dictionary for settings
+        /// </summary>
+        /// <param name="settings"></param>
+#if NET48
+        public Options(Dictionary<string, string> settings = null)
+#else
+        public Options(Dictionary<string, string?>? settings = null)
+#endif
+        {
+#if NET48
+            this.Settings = settings ?? new Dictionary<string, string>();
+#else
+            this.Settings = settings ?? new Dictionary<string, string?>();
+#endif
+        }
+
+        /// <summary>
+        /// Constructor taking an existing Options object
+        /// </summary>
+        /// <param name="source"></param>
+#if NET48
+        public Options(Options source)
+#else
+        public Options(Options? source)
+#endif
+        {
+#if NET48
+            Settings = new Dictionary<string, string>(source?.Settings ?? new Dictionary<string, string>());
+#else
+            Settings = new Dictionary<string, string?>(source?.Settings ?? new Dictionary<string, string?>());
+#endif
+        }
+
+        /// <summary>
+        /// Accessor for the internal dictionary
+        /// </summary>
+#if NET48
+        public string this[string key]
+#else
+        public string? this[string key]
+#endif
+        {
+            get => this.Settings[key];
+            set => this.Settings[key] = value;
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Get a Boolean setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+#if NET48
+        private static bool GetBooleanSetting(Dictionary<string, string> settings, string key, bool defaultValue)
+#else
+        private static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
+#endif
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (bool.TryParse(settings[key], out bool value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get an Int32 setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+#if NET48
+        private static int GetInt32Setting(Dictionary<string, string> settings, string key, int defaultValue)
+#else
+        private static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
+#endif
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (int.TryParse(settings[key], out int value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get a String setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+#if NET48
+        private static string GetStringSetting(Dictionary<string, string> settings, string key, string defaultValue)
+#else
+        private static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
+#endif
+        {
+            if (settings.ContainsKey(key))
+                return settings[key];
+            else
+                return defaultValue;
+        }
+
+        #endregion
+    }
+}

MPF.Core/Data/ProcessingQueue.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MPF.Core.Data
+{
+    public class ProcessingQueue<T> : IDisposable
+    {
+        /// <summary>
+        /// Internal queue to hold data to process
+        /// </summary>
+        private readonly ConcurrentQueue<T> InternalQueue;
+
+        /// <summary>
+        /// Custom processing step for dequeued data
+        /// </summary>
+        private readonly Action<T> CustomProcessing;
+
+        /// <summary>
+        /// Cancellation method for the processing task
+        /// </summary>
+        private readonly CancellationTokenSource TokenSource;
+
+        public ProcessingQueue(Action<T> customProcessing)
+        {
+            this.InternalQueue = new ConcurrentQueue<T>();
+            this.CustomProcessing = customProcessing;
+            this.TokenSource = new CancellationTokenSource();
+            Task.Run(() => ProcessQueue(), this.TokenSource.Token);
+        }
+
+        /// <summary>
+        /// Dispose the current instance
+        /// </summary>
+        public void Dispose() => this.TokenSource.Cancel();
+
+        /// <summary>
+        /// Enqueue a new item for processing
+        /// </summary>
+        /// <param name="item"></param>
+        public void Enqueue(T item)
+        {
+            // Only accept new data when not cancelled
+            if (item != null && !this.TokenSource.IsCancellationRequested)
+                this.InternalQueue.Enqueue(item);
+        }
+
+        /// <summary>
+        /// Process
+        /// </summary>
+        private void ProcessQueue()
+        {
+            while (true)
+            {
+                // Nothing in the queue means we get to idle
+                if (this.InternalQueue.Count == 0)
+                {
+                    if (this.TokenSource.IsCancellationRequested)
+                        break;
+
+                    Thread.Sleep(10);
+                    continue;
+                }
+
+                // Get the next item from the queue
+                if (!this.InternalQueue.TryDequeue(out var nextItem))
+                    continue;
+
+                // Invoke the lambda, if possible
+                this.CustomProcessing?.Invoke(nextItem);
+            }
+        }
+    }
+}

MPF.Core/Data/Result.cs

@@ -0,0 +1,60 @@
+namespace MPF.Core.Data
+{
+    /// <summary>
+    /// Generic success/failure result object, with optional message
+    /// </summary>
+    public class Result
+    {
+        /// <summary>
+        /// Internal representation of success
+        /// </summary>
+        private readonly bool success;
+
+        /// <summary>
+        /// Optional message for the result
+        /// </summary>
+        public string Message { get; private set; }
+
+        private Result(bool success, string message)
+        {
+            this.success = success;
+            this.Message = message;
+        }
+
+        /// <summary>
+        /// Create a default success result with no message
+        /// </summary>
+        public static Result Success() => new Result(true, "");
+
+        /// <summary>
+        /// Create a success result with a custom message
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+#if NET48
+        public static Result Success(string message) => new Result(true, message);
+#else
+        public static Result Success(string? message) => new Result(true, message ?? string.Empty);
+#endif
+
+        /// <summary>
+        /// Create a default failure result with no message
+        /// </summary>
+        /// <returns></returns>
+        public static Result Failure() => new Result(false, "");
+
+        /// <summary>
+        /// Create a failure result with a custom message
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+#if NET48
+        public static Result Failure(string message) => new Result(false, message);
+#else
+        public static Result Failure(string? message) => new Result(false, message ?? string.Empty);
+#endif
+
+        /// <summary>
+        /// Results can be compared to boolean values based on the success value
+        /// </summary>
+        public static implicit operator bool(Result result) => result.success;
+    }
+}

MPF.Core/DumpEnvironment.cs

@@ -0,0 +1,651 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.Core.Data;
+using MPF.Core.Modules;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core
+{
+    /// <summary>
+    /// Represents the state of all settings to be used during dumping
+    /// </summary>
+    public class DumpEnvironment
+    {
+        #region Output paths
+
+        /// <summary>
+        /// Base output file path to write files to
+        /// </summary>
+        public string OutputPath { get; private set; }
+
+        #endregion
+
+        #region UI information
+
+        /// <summary>
+        /// Drive object representing the current drive
+        /// </summary>
+#if NET48
+        public Drive Drive { get; private set; }
+#else
+        public Drive? Drive { get; private set; }
+#endif
+
+        /// <summary>
+        /// Currently selected system
+        /// </summary>
+        public RedumpSystem? System { get; private set; }
+
+        /// <summary>
+        /// Currently selected media type
+        /// </summary>
+        public MediaType? Type { get; private set; }
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram InternalProgram { get; private set; }
+
+        /// <summary>
+        /// Options object representing user-defined options
+        /// </summary>
+        public Data.Options Options { get; private set; }
+
+        /// <summary>
+        /// Parameters object representing what to send to the internal program
+        /// </summary>
+#if NET48
+        public BaseParameters Parameters { get; private set; }
+#else
+        public BaseParameters? Parameters { get; private set; }
+#endif
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Generic way of reporting a message
+        /// </summary>
+#if NET48
+        public EventHandler<string> ReportStatus;
+#else
+        public EventHandler<string>? ReportStatus;
+#endif
+
+        /// <summary>
+        /// Queue of items that need to be logged
+        /// </summary>
+#if NET48
+        private ProcessingQueue<string> outputQueue;
+#else
+        private ProcessingQueue<string>? outputQueue;
+#endif
+
+        /// <summary>
+        /// Event handler for data returned from a process
+        /// </summary>
+#if NET48
+        private void OutputToLog(object proc, string args) => outputQueue?.Enqueue(args);
+#else
+        private void OutputToLog(object? proc, string args) => outputQueue?.Enqueue(args);
+#endif
+
+        /// <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="outputPath"></param>
+        /// <param name="drive"></param>
+        /// <param name="system"></param>
+        /// <param name="type"></param>
+        /// <param name="internalProgram"></param>
+        /// <param name="parameters"></param>
+        public DumpEnvironment(Data.Options options,
+            string outputPath,
+#if NET48
+            Drive drive,
+#else
+            Drive? drive,
+#endif
+            RedumpSystem? system,
+            MediaType? type,
+            InternalProgram? internalProgram,
+#if NET48
+            string parameters)
+#else
+            string? parameters)
+#endif
+        {
+            // Set options object
+            Options = options;
+
+            // Output paths
+            OutputPath = InfoTool.NormalizeOutputPaths(outputPath, false);
+
+            // UI information
+            Drive = drive;
+            System = system ?? options.DefaultSystem;
+            Type = type ?? MediaType.NONE;
+            InternalProgram = internalProgram ?? options.InternalProgram;
+
+            // Dumping program
+            SetParameters(parameters);
+        }
+
+        #region Public Functionality
+
+        /// <summary>
+        /// Set the parameters object based on the internal program and parameters string
+        /// </summary>
+        /// <param name="parameters">String representation of the parameters</param>
+#if NET48
+        public void SetParameters(string parameters)
+#else
+        public void SetParameters(string? parameters)
+#endif
+        {
+#if NET48
+            switch (InternalProgram)
+            {
+                // Dumping support
+                case InternalProgram.Aaru:
+                    Parameters = new Modules.Aaru.Parameters(parameters) { ExecutablePath = Options.AaruPath };
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
+                    break;
+
+                case InternalProgram.Redumper:
+                    Parameters = new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath };
+                    break;
+
+                // Verification support only
+                case InternalProgram.CleanRip:
+                    Parameters = new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null };
+                    break;
+
+                case InternalProgram.DCDumper:
+                    Parameters = null; // TODO: Create correct parameter type when supported
+                    break;
+
+                case InternalProgram.UmdImageCreator:
+                    Parameters = new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null };
+                    break;
+
+                // This should never happen, but it needs a fallback
+                default:
+                    Parameters = new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath };
+                    break;
+            }
+#else
+            Parameters = InternalProgram switch
+            {
+                // Dumping support
+                InternalProgram.Aaru => new Modules.Aaru.Parameters(parameters) { ExecutablePath = Options.AaruPath },
+                InternalProgram.DiscImageCreator => new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath },
+                InternalProgram.Redumper => new Modules.Redumper.Parameters(parameters) { ExecutablePath = Options.RedumperPath },
+
+                // Verification support only
+                InternalProgram.CleanRip => new Modules.CleanRip.Parameters(parameters) { ExecutablePath = null },
+                InternalProgram.DCDumper => null, // TODO: Create correct parameter type when supported
+                InternalProgram.UmdImageCreator => new Modules.UmdImageCreator.Parameters(parameters) { ExecutablePath = null },
+
+                // This should never happen, but it needs a fallback
+                _ => new Modules.DiscImageCreator.Parameters(parameters) { ExecutablePath = Options.DiscImageCreatorPath },
+            };
+#endif
+
+            // Set system and type
+            if (Parameters != null)
+            {
+                Parameters.System = System;
+                Parameters.Type = 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>
+#if NET48
+        public string GetFullParameters(int? driveSpeed)
+#else
+        public string? GetFullParameters(int? driveSpeed)
+#endif
+        {
+            // 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
+#if NET48
+                switch (InternalProgram)
+                {
+                    case InternalProgram.Aaru:
+                        Parameters = new Modules.Aaru.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options);
+                        break;
+
+                    case InternalProgram.DiscImageCreator:
+                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options);
+                        break;
+
+                    case InternalProgram.Redumper:
+                        Parameters = new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options);
+                        break;
+
+                    // This should never happen, but it needs a fallback
+                    default:
+                        Parameters = new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options);
+                        break;
+                }
+#else
+                Parameters = InternalProgram switch
+                {
+                    InternalProgram.Aaru => new Modules.Aaru.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                    InternalProgram.DiscImageCreator => new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                    InternalProgram.Redumper => new Modules.Redumper.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+
+                    // This should never happen, but it needs a fallback
+                    _ => new Modules.DiscImageCreator.Parameters(System, Type, Drive.Name, OutputPath, driveSpeed, Options),
+                };
+#endif
+
+                // 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>
+#if NET48
+        public async Task<string> EjectDisc() =>
+#else
+        public async Task<string?> EjectDisc() =>
+#endif
+            await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Eject);
+
+        /// <summary>
+        /// Reset the current drive using DiscImageCreator
+        /// </summary>
+#if NET48
+        public async Task<string> ResetDrive() =>
+#else
+        public async Task<string?> ResetDrive() =>
+#endif
+            await RunStandaloneDiscImageCreatorCommand(Modules.DiscImageCreator.CommandStrings.Reset);
+
+        /// <summary>
+        /// Execute the initial invocation of the dumping programs
+        /// </summary>
+        /// <param name="progress">Optional result progress callback</param>
+#if NET48
+        public async Task<Result> Run(IProgress<Result> progress = null)
+#else
+        public async Task<Result> Run(IProgress<Result>? progress = null)
+#endif
+        {
+            // If we don't have parameters
+            if (Parameters == null)
+                return Result.Failure("Error! Current configuration is not supported!");
+
+            // 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);
+                if (Parameters.ReportStatus != null)
+                    Parameters.ReportStatus += OutputToLog;
+            }
+
+            // Execute internal tool
+            progress?.Report(Result.Success($"Executing {InternalProgram}... {(Options.ToolsInSeparateWindow ? "please wait!" : "see log for output!")}"));
+
+            var directoryName = Path.GetDirectoryName(OutputPath);
+            if (!string.IsNullOrWhiteSpace(directoryName))
+                Directory.CreateDirectory(directoryName);
+
+            await Task.Run(() => Parameters.ExecuteInternalProgram(Options.ToolsInSeparateWindow));
+            progress?.Report(Result.Success($"{InternalProgram} has finished!"));
+
+            // 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>
+        /// <param name="seedInfo">A seed SubmissionInfo object that contains user data</param>
+        /// <returns>Result instance with the outcome</returns>
+        public async Task<Result> VerifyAndSaveDumpOutput(
+#if NET48
+            IProgress<Result> resultProgress = null,
+            IProgress<ProtectionProgress> protectionProgress = null,
+            Func<SubmissionInfo, (bool?, SubmissionInfo)> processUserInfo = null,
+            SubmissionInfo seedInfo = null)
+#else
+            IProgress<Result>? resultProgress = null,
+            IProgress<ProtectionProgress>? protectionProgress = null,
+            Func<SubmissionInfo?, (bool?, SubmissionInfo?)>? processUserInfo = null,
+            SubmissionInfo? seedInfo = null)
+#endif
+        {
+            resultProgress?.Report(Result.Success("Gathering submission information... please wait!"));
+
+            // Get the output directory and filename separately
+            var outputDirectory = Path.GetDirectoryName(OutputPath);
+            var outputFilename = Path.GetFileName(OutputPath);
+
+            // Check to make sure that the output had all the correct files
+            (bool foundFiles, List<string> missingFiles) = InfoTool.FoundAllFiles(outputDirectory, outputFilename, 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..."));
+            var submissionInfo = await SubmissionInfoTool.ExtractOutputInformation(
+                OutputPath,
+                Drive,
+                System,
+                Type,
+                Options,
+                Parameters,
+                resultProgress,
+                protectionProgress);
+            resultProgress?.Report(Result.Success("Extracting information complete!"));
+
+            // Inject seed submission info data, if necessary
+            if (seedInfo != null)
+            {
+                resultProgress?.Report(Result.Success("Injecting user-supplied information..."));
+                SubmissionInfoTool.InjectSubmissionInformation(submissionInfo, seedInfo);
+                resultProgress?.Report(Result.Success("Information injection complete!"));
+            }
+
+            // Eject the disc automatically if configured to
+            if (Options.EjectAfterDump == true)
+            {
+                resultProgress?.Report(Result.Success($"Ejecting disc in drive {Drive?.Name}"));
+                await EjectDisc();
+            }
+
+            // Reset the drive automatically if configured to
+            if (InternalProgram == InternalProgram.DiscImageCreator && Options.DICResetDriveAfterDump)
+            {
+                resultProgress?.Report(Result.Success($"Resetting drive {Drive?.Name}"));
+                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..."));
+            (var formattedValues, var formatResult) = InfoTool.FormatOutputData(submissionInfo, Options);
+            if (formattedValues == null)
+                resultProgress?.Report(Result.Success(formatResult));
+            else
+                resultProgress?.Report(Result.Failure(formatResult));
+
+            // Get the filename suffix for auto-generated files
+            var filenameSuffix = Options.AddFilenameSuffix ? Path.GetFileNameWithoutExtension(outputFilename) : null;
+
+            // Write the text output
+            resultProgress?.Report(Result.Success("Writing information to !submissionInfo.txt..."));
+            (bool txtSuccess, string txtResult) = InfoTool.WriteOutputData(outputDirectory, filenameSuffix, formattedValues);
+            if (txtSuccess)
+                resultProgress?.Report(Result.Success(txtResult));
+            else
+                resultProgress?.Report(Result.Failure(txtResult));
+
+            // Write the copy protection output
+            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Any())
+            {
+                if (Options.ScanForProtection && Options.OutputSeparateProtectionFile)
+                {
+                    resultProgress?.Report(Result.Success("Writing protection to !protectionInfo.txt..."));
+                    bool scanSuccess = InfoTool.WriteProtectionData(outputDirectory, filenameSuffix, submissionInfo);
+                    if (scanSuccess)
+                        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{(Options.IncludeArtifacts ? ".gz" : string.Empty)}..."));
+                bool jsonSuccess = InfoTool.WriteOutputData(outputDirectory, filenameSuffix, submissionInfo, Options.IncludeArtifacts);
+                if (jsonSuccess)
+                    resultProgress?.Report(Result.Success("Writing complete!"));
+                else
+                    resultProgress?.Report(Result.Failure("Writing could not complete!"));
+            }
+
+            // Compress the logs, if required
+            if (Options.CompressLogFiles)
+            {
+                resultProgress?.Report(Result.Success("Compressing log files..."));
+                (bool compressSuccess, string compressResult) = InfoTool.CompressLogFiles(outputDirectory, filenameSuffix, outputFilename, Parameters);
+                if (compressSuccess)
+                    resultProgress?.Report(Result.Success(compressResult));
+                else
+                    resultProgress?.Report(Result.Failure(compressResult));
+            }
+
+            // Delete unnecessary files, if required
+            if (Options.DeleteUnnecessaryFiles)
+            {
+                resultProgress?.Report(Result.Success("Deleting unnecessary files..."));
+                (bool deleteSuccess, string deleteResult) = InfoTool.DeleteUnnecessaryFiles(outputDirectory, outputFilename, Parameters);
+                if (deleteSuccess)
+                    resultProgress?.Report(Result.Success(deleteResult));
+                else
+                    resultProgress?.Report(Result.Failure(deleteResult));
+            }
+
+            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()
+        {
+            // Missing drive means it can never be valid
+            if (Drive == null)
+                return false;
+
+            bool parametersValid = Parameters?.IsValid() ?? false;
+            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 internal program async with an input set of parameters
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <returns>Standard output from commandline window</returns>
+        private static 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 (Parameters == null || !ParametersValid())
+                return Result.Failure("Error! Current configuration is not supported!");
+
+            // Fix the output paths, just in case
+            OutputPath = InfoTool.NormalizeOutputPaths(OutputPath, false);
+
+            // Validate that the output path isn't on the dumping drive
+            if (Drive?.Name != null && OutputPath.StartsWith(Drive.Name))
+                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 (Drive?.Name != null && fullExecutablePath.StartsWith(Drive.Name))
+                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>
+#if NET48
+        private async Task<string> RunStandaloneDiscImageCreatorCommand(string command)
+#else
+        private async Task<string?> RunStandaloneDiscImageCreatorCommand(string command)
+#endif
+        {
+            // Validate that DiscImageCreator is all set
+            if (!RequiredProgramsExist())
+                return null;
+
+            // Validate we're not trying to eject a non-optical
+            if (Drive == null || Drive.InternalDriveType != InternalDriveType.Optical)
+                return null;
+
+            CancelDumping();
+
+            var parameters = new Modules.DiscImageCreator.Parameters(string.Empty)
+            {
+                BaseCommand = command,
+                DrivePath = Drive.Name,
+                ExecutablePath = Options.DiscImageCreatorPath,
+            };
+
+            return await ExecuteInternalProgram(parameters);
+        }
+
+        #endregion
+    }
+}

MPF.Core/Hashing/Hasher.cs

@@ -0,0 +1,401 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Hashing;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+using MPF.Core.Data;
+
+namespace MPF.Core.Hashing
+{
+    public sealed class Hasher : IDisposable
+    {
+        #region Properties
+
+        /// <summary>
+        /// Hash type associated with the current state
+        /// </summary>
+#if NET48
+        public Hash HashType { get; private set; }
+#else
+        public Hash HashType { get; init; }
+#endif
+
+        /// <summary>
+        /// Current hash in bytes
+        /// </summary>
+#if NET48
+        public byte[] CurrentHashBytes
+#else
+        public byte[]? CurrentHashBytes
+#endif
+        {
+            get
+            {
+#if NET48
+                switch (_hasher)
+                {
+                    case HashAlgorithm ha:
+                        return ha.Hash;
+                    case NonCryptographicHashAlgorithm ncha:
+                        return ncha.GetCurrentHash().Reverse().ToArray();
+                    default:
+                        return null;
+                }
+#else
+                return (_hasher) switch
+                {
+                    HashAlgorithm ha => ha.Hash,
+                    NonCryptographicHashAlgorithm ncha => ncha.GetCurrentHash().Reverse().ToArray(),
+                    _ => null,
+                };
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Current hash as a string
+        /// </summary>
+#if NET48
+        public string CurrentHashString => ByteArrayToString(CurrentHashBytes);
+#else
+        public string? CurrentHashString => ByteArrayToString(CurrentHashBytes);
+#endif
+
+        #endregion
+
+        #region Private Fields
+
+        /// <summary>
+        /// Internal hasher being used for processing
+        /// </summary>
+        /// <remarks>May be either a HashAlgorithm or NonCryptographicHashAlgorithm</remarks>
+#if NET48
+        private object _hasher;
+#else
+        private object? _hasher;
+#endif
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="hashType">Hash type to instantiate</param>
+        public Hasher(Hash hashType)
+        {
+            this.HashType = hashType;
+            GetHasher();
+        }
+
+        /// <summary>
+        /// Generate the correct hashing class based on the hash type
+        /// </summary>
+        private void GetHasher()
+        {
+#if NET48
+            switch (HashType)
+            {
+                case Hash.CRC32:
+                    _hasher = new Crc32();
+                    break;
+                case Hash.CRC64:
+                    _hasher = new Crc64();
+                    break;
+                case Hash.MD5:
+                    _hasher = MD5.Create();
+                    break;
+                case Hash.SHA1:
+                    _hasher = SHA1.Create();
+                    break;
+                case Hash.SHA256:
+                    _hasher = SHA256.Create();
+                    break;
+                case Hash.SHA384:
+                    _hasher = SHA384.Create();
+                    break;
+                case Hash.SHA512:
+                    _hasher = SHA512.Create();
+                    break;
+                case Hash.XxHash32:
+                    _hasher = new XxHash32();
+                    break;
+                case Hash.XxHash64:
+                    _hasher = new XxHash64();
+                    break;
+            }
+#else
+            _hasher = HashType switch
+            {
+                Hash.CRC32 => new Crc32(),
+                Hash.CRC64 => new Crc64(),
+                Hash.MD5 => MD5.Create(),
+                Hash.SHA1 => SHA1.Create(),
+                Hash.SHA256 => SHA256.Create(),
+                Hash.SHA384 => SHA384.Create(),
+                Hash.SHA512 => SHA512.Create(),
+                Hash.XxHash32 => new XxHash32(),
+                Hash.XxHash64 => new XxHash64(),
+                _ => null,
+            };
+#endif
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (_hasher is IDisposable disposable)
+                disposable.Dispose();
+        }
+
+        #endregion
+
+        #region Static Hashing
+
+        /// <summary>
+        /// Get hashes from an input file path
+        /// </summary>
+        /// <param name="filename">Path to the input file</param>
+        /// <returns>True if hashing was successful, false otherwise</returns>
+#if NET48
+        public static bool GetFileHashes(string filename, out long size, out string crc32, out string md5, out string sha1)
+#else
+        public static bool GetFileHashes(string filename, out long size, out string? crc32, out string? md5, out string? sha1)
+#endif
+        {
+            // Set all initial values
+            crc32 = null; md5 = null; sha1 = null;
+
+            // Get all file hashes
+            var fileHashes = GetFileHashes(filename, out size);
+            if (fileHashes == null)
+                return false;
+
+            // Assign the file hashes and return
+            crc32 = fileHashes[Hash.CRC32];
+            md5 = fileHashes[Hash.MD5];
+            sha1 = fileHashes[Hash.SHA1];
+            return true;
+        }
+
+        /// <summary>
+        /// Get hashes from an input file path
+        /// </summary>
+        /// <param name="filename">Path to the input file</param>
+        /// <returns>Dictionary containing hashes on success, null on error</returns>
+#if NET48
+        public static Dictionary<Hash, string> GetFileHashes(string filename, out long size)
+#else
+        public static Dictionary<Hash, string?>? GetFileHashes(string filename, out long size)
+#endif
+        {
+            // If the file doesn't exist, we can't do anything
+            if (!File.Exists(filename))
+            {
+                size = -1;
+                return null;
+            }
+
+            // Set the file size
+            size = new FileInfo(filename).Length;
+
+            // Create the output dictionary
+#if NET48
+            var hashDict = new Dictionary<Hash, string>();
+#else
+            var hashDict = new Dictionary<Hash, string?>();
+#endif
+
+            // Open the input file
+            var input = File.OpenRead(filename);
+
+            // Return the hashes from the stream
+            return GetStreamHashes(input);
+        }
+
+        /// <summary>
+        /// Get hashes from an input Stream
+        /// </summary>
+        /// <param name="input">Stream to hash</param>
+        /// <returns>Dictionary containing hashes on success, null on error</returns>
+#if NET48
+        public static Dictionary<Hash, string> GetStreamHashes(Stream input)
+#else
+        public static Dictionary<Hash, string?>? GetStreamHashes(Stream input)
+#endif
+        {
+            // Create the output dictionary
+#if NET48
+            var hashDict = new Dictionary<Hash, string>();
+#else
+            var hashDict = new Dictionary<Hash, string?>();
+#endif
+
+            try
+            {
+                // Get a list of hashers to run over the buffer
+                var hashers = new Dictionary<Hash, Hasher>
+                {
+                    { Hash.CRC32, new Hasher(Hash.CRC32) },
+                    { Hash.CRC64, new Hasher(Hash.CRC64) },
+                    { Hash.MD5, new Hasher(Hash.MD5) },
+                    { Hash.SHA1, new Hasher(Hash.SHA1) },
+                    { Hash.SHA256, new Hasher(Hash.SHA256) },
+                    { Hash.SHA384, new Hasher(Hash.SHA384) },
+                    { Hash.SHA512, new Hasher(Hash.SHA512) },
+                    { Hash.XxHash32, new Hasher(Hash.XxHash32) },
+                    { Hash.XxHash64, new Hasher(Hash.XxHash64) },
+                };
+
+                // Initialize the hashing helpers
+                var loadBuffer = new ThreadLoadBuffer(input);
+                int buffersize = 3 * 1024 * 1024;
+                byte[] buffer0 = new byte[buffersize];
+                byte[] buffer1 = new byte[buffersize];
+
+                /*
+                Please note that some of the following code is adapted from
+                RomVault. This is a modified version of how RomVault does
+                threaded hashing. As such, some of the terminology and code
+                is the same, though variable names and comments may have
+                been tweaked to better fit this code base.
+                */
+
+                // Pre load the first buffer
+                long refsize = input.Length;
+                int next = refsize > buffersize ? buffersize : (int)refsize;
+                input.Read(buffer0, 0, next);
+                int current = next;
+                refsize -= next;
+                bool bufferSelect = true;
+
+                while (current > 0)
+                {
+                    // Trigger the buffer load on the second buffer
+                    next = refsize > buffersize ? buffersize : (int)refsize;
+                    if (next > 0)
+                        loadBuffer.Trigger(bufferSelect ? buffer1 : buffer0, next);
+
+                    byte[] buffer = bufferSelect ? buffer0 : buffer1;
+
+                    // Run hashes in parallel
+                    Parallel.ForEach(hashers, h => h.Value.Process(buffer, current));
+
+                    // Wait for the load buffer worker, if needed
+                    if (next > 0)
+                        loadBuffer.Wait();
+
+                    // Setup for the next hashing step
+                    current = next;
+                    refsize -= next;
+                    bufferSelect = !bufferSelect;
+                }
+
+                // Finalize all hashing helpers
+                loadBuffer.Finish();
+                Parallel.ForEach(hashers, h => h.Value.Terminate());
+
+                // Get the results
+                hashDict[Hash.CRC32] = hashers[Hash.CRC32].CurrentHashString;
+                hashDict[Hash.CRC64] = hashers[Hash.CRC64].CurrentHashString;
+                hashDict[Hash.MD5] = hashers[Hash.MD5].CurrentHashString;
+                hashDict[Hash.SHA1] = hashers[Hash.SHA1].CurrentHashString;
+                hashDict[Hash.SHA256] = hashers[Hash.SHA256].CurrentHashString;
+                hashDict[Hash.SHA384] = hashers[Hash.SHA384].CurrentHashString;
+                hashDict[Hash.SHA512] = hashers[Hash.SHA512].CurrentHashString;
+                hashDict[Hash.XxHash32] = hashers[Hash.XxHash32].CurrentHashString;
+                hashDict[Hash.XxHash64] = hashers[Hash.XxHash64].CurrentHashString;
+                hashDict[Hash.CRC64] = hashers[Hash.CRC64].CurrentHashString;
+
+                // Dispose of the hashers
+                loadBuffer.Dispose();
+                foreach (var hasher in hashers.Values)
+                {
+                    hasher.Dispose();
+                }
+
+                return hashDict;
+            }
+            catch (IOException)
+            {
+                return null;
+            }
+            finally
+            {
+                input.Dispose();
+            }
+        }
+
+        #endregion
+
+        #region Hashing
+
+        /// <summary>
+        /// Process a buffer of some length with the internal hash algorithm
+        /// </summary>
+        public void Process(byte[] buffer, int size)
+        {
+            switch (_hasher)
+            {
+                case HashAlgorithm ha:
+                    ha.TransformBlock(buffer, 0, size, null, 0);
+                    break;
+                case NonCryptographicHashAlgorithm ncha:
+                    var bufferSpan = new ReadOnlySpan<byte>(buffer, 0, size);
+                    ncha.Append(bufferSpan);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Finalize the internal hash algorigthm
+        /// </summary>
+        /// <remarks>NonCryptographicHashAlgorithm implementations do not need finalization</remarks>
+        public void Terminate()
+        {
+            byte[] emptyBuffer = Array.Empty<byte>();
+            switch (_hasher)
+            {
+                case HashAlgorithm ha:
+                    ha.TransformFinalBlock(emptyBuffer, 0, 0);
+                    break;
+            }
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Convert a byte array to a hex string
+        /// </summary>
+        /// <param name="bytes">Byte array to convert</param>
+        /// <returns>Hex string representing the byte array</returns>
+        /// <link>http://stackoverflow.com/questions/311165/how-do-you-convert-byte-array-to-hexadecimal-string-and-vice-versa</link>
+#if NET48
+        private static string ByteArrayToString(byte[] bytes)
+#else
+        private static string? ByteArrayToString(byte[]? bytes)
+#endif
+        {
+            // If we get null in, we send null out
+            if (bytes == null)
+                return null;
+
+            try
+            {
+                string hex = BitConverter.ToString(bytes);
+                return hex.Replace("-", string.Empty).ToLowerInvariant();
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Hashing/ThreadLoadBuffer.cs

@@ -0,0 +1,85 @@
+using System;
+using System.IO;
+using System.Threading;
+
+//namespace Compress.ThreadReaders
+namespace MPF.Core.Hashing
+{
+    public class ThreadLoadBuffer : IDisposable
+    {
+        private readonly AutoResetEvent _waitEvent;
+        private readonly AutoResetEvent _outEvent;
+        private readonly Thread _tWorker;
+
+#if NET48
+        private byte[] _buffer;
+#else
+        private byte[]? _buffer;
+#endif
+        private int _size;
+        private readonly Stream _ds;
+        private bool _finished;
+        public bool errorState;
+
+        public int SizeRead;
+
+        public ThreadLoadBuffer(Stream ds)
+        {
+            _waitEvent = new AutoResetEvent(false);
+            _outEvent = new AutoResetEvent(false);
+            _finished = false;
+            _ds = ds;
+            errorState = false;
+
+            _tWorker = new Thread(MainLoop);
+            _tWorker.Start();
+        }
+
+        public void Dispose()
+        {
+            _waitEvent.Close();
+            _outEvent.Close();
+        }
+
+        private void MainLoop()
+        {
+            while (true)
+            {
+                _waitEvent.WaitOne();
+                if (_finished)
+                {
+                    break;
+                }
+                try
+                {
+                    if (_buffer != null)
+                        SizeRead = _ds.Read(_buffer, 0, _size);
+                }
+                catch (Exception)
+                {
+                    errorState = true;
+                }
+                _outEvent.Set();
+            }
+        }
+
+        public void Trigger(byte[] buffer, int size)
+        {
+            _buffer = buffer;
+            _size = size;
+            _waitEvent.Set();
+        }
+
+        public void Wait()
+        {
+            _outEvent.WaitOne();
+        }
+
+        public void Finish()
+        {
+            _finished = true;
+            _waitEvent.Set();
+            _tWorker.Join();
+        }
+    }
+}

MPF.Core/MPF.Core.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net6.0;net7.0</TargetFrameworks>
+    <RuntimeIdentifiers>win-x64;linux-x64;osx-x64</RuntimeIdentifiers>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2023</Copyright>
+    <VersionPrefix>2.7.5</VersionPrefix>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='net48'">
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="MPF.Test" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BurnOutSharp" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="2.9.0" GeneratePathProperty="true">
+      <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="psxt001z" Version="0.21.0-beta1" />
+    <PackageReference Include="SabreTools.Models" Version="1.1.5" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.1.1" />
+    <PackageReference Include="SabreTools.Serialization" Version="1.1.7" />
+    <PackageReference Include="System.IO.Compression" Version="4.3.0" />
+    <PackageReference Include="System.IO.Compression.ZipFile" Version="4.3.0" />
+    <PackageReference Include="System.IO.Hashing" Version="7.0.0" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+  </ItemGroup>
+
+</Project>

MPF.Core/Modules/Aaru/Constants.cs

@@ -0,0 +1,491 @@
+namespace MPF.Core.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";
+        public const string DatabaseStats = "stats";
+        public const string DatabaseUpdate = "update";
+
+        // Device Family
+        public const string DevicePrefixShort = "dev";
+        public const string DevicePrefixLong = "device";
+        public const string DeviceInfo = "info";
+        public const string DeviceList = "list";
+        public const string DeviceReport = "report";
+
+        // Filesystem Family
+        public const string FilesystemPrefixShort = "fi";
+        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";
+
+        // Image Family
+        public const string ImagePrefixShort = "i";
+        public const string ImagePrefixLong = "image";
+        public const string ImageChecksumShort = "chk";
+        public const string ImageChecksumLong = "checksum";
+        public const string ImageCompareShort = "cmp";
+        public const string ImageCompareLong = "compare";
+        public const string ImageConvert = "convert";
+        public const string ImageCreateSidecar = "create-sidecar";
+        public const string ImageDecode = "decode";
+        public const string ImageEntropy = "entropy";
+        public const string ImageInfo = "info";
+        public const string ImageOptions = "options";
+        public const string ImagePrint = "print";
+        public const string ImageVerify = "verify";
+
+        // Media Family
+        public const string MediaPrefixShort = "m";
+        public const string MediaPrefixLong = "media";
+        public const string MediaDump = "dump";
+        public const string MediaInfo = "info";
+        public const string MediaScan = "scan";
+
+        // Standalone Commands
+        public const string Configure = "configure";
+        public const string Formats = "formats";
+        public const string ListEncodings = "list-encodings";
+        public const string ListNamespaces = "list-namespaces";
+        public const string Remote = "remote";
+    }
+
+    /// <summary>
+    /// Supported encodings for Aaru
+    /// </summary>
+    /// TODO: Use to verify encoding settings
+    public static class EncodingStrings
+    {
+        public const string ArabicMac = "x-mac-arabic";
+        public const string AtariASCII = "atascii";
+        public const string CentralEuropeanMac = "x-mac-ce";
+        public const string CommodorePETSCII = "petscii";
+        public const string CroatianMac = "x-mac-croatian";
+        public const string CyrillicMac = "x-mac-cryillic";
+        public const string FarsiMac = "x-mac-farsi";
+        public const string GreekMac = "x-mac-greek";
+        public const string HebrewMac = "x-mac-hebrew";
+        public const string RomanianMac = "x-mac-romanian";
+        public const string SinclairZXSpectrum = "spectrum";
+        public const string SinclairZX80 = "zx80";
+        public const string SinclairZX81 = "zx81";
+        public const string TurkishMac = "x-mac-turkish";
+        public const string UkrainianMac = "x-mac-ukrainian";
+        public const string Unicode = "utf-16";
+        public const string UnicodeBigEndian = "utf-16BE";
+        public const string UnicodeUTF32BigEndian = "utf-32BE";
+        public const string UnicodeUTF32 = "utf-32";
+        public const string UnicodeUTF7 = "utf-7";
+        public const string UnicodeUTF8 = "utf-8";
+        public const string USASCII = "us-ascii";
+        public const string WesternEuropeanAppleII = "apple2";
+        public const string WesternEuropeanAppleIIc = "apple2c";
+        public const string WesternEuropeanAppleIIe = "apple2e";
+        public const string WesternEuropeanAppleIIgs = "apple2gs";
+        public const string WesternEuropeanAppleLisa = "lisa";
+        public const string WesternEuropeanAtariST = "atarist";
+        public const string WesternEuropeanGEM = "gem";
+        public const string WesternEuropeanGEOS = "geos";
+        public const string WesternEuropeanISO = "iso-8859-1";
+        public const string WesternEuropeanMac = "macintosh";
+        public const string WesternEuropeanRadix50 = "radix50";
+    }
+
+    /// <summary>
+    /// Dumping flags for Aaru
+    /// </summary>
+    public static class FlagStrings
+    {
+        // Boolean flags
+        public const string Adler32Short = "-a";
+        public const string Adler32Long = "--adler32";
+        public const string ClearLong = "--clear";
+        public const string ClearAllLong = "--clear-all";
+        public const string CRC16Long = "--crc16";
+        public const string CRC32Short = "-c";
+        public const string CRC32Long = "--crc32";
+        public const string CRC64Long = "--crc64";
+        public const string DebugShort = "-d";
+        public const string DebugLong = "--debug";
+        public const string DiskTagsShort = "-f";
+        public const string DiskTagsLong = "--disk-tags";
+        public const string DuplicatedSectorsShort = "-p";
+        public const string DuplicatedSectorsLong = "--duplicated-sectors";
+        public const string EjectLong = "--eject";
+        public const string ExtendedAttributesShort = "-x";
+        public const string ExtendedAttributesLong = "--xattrs";
+        public const string FilesystemsShort = "-f";
+        public const string FilesystemsLong = "--filesystems";
+        public const string FirstPregapLong = "--first-pregap";
+        public const string FixOffsetLong = "--fix-offset";
+        public const string FixSubchannelLong = "--fix-subchannel";
+        public const string FixSubchannelCrcLong = "--fix-subchannel-crc";
+        public const string FixSubchannelPositionLong = "--fix-subchannel-position";
+        public const string Fletcher16Long = "--fletcher16";
+        public const string Fletcher32Long = "--fletcher32";
+        public const string ForceShort = "-f";
+        public const string ForceLong = "--force";
+        public const string GenerateSubchannelsLong = "--generate-subchannels";
+        public const string HelpShort = "-h";
+        public const string HelpShortAlt = "-?";
+        public const string HelpLong = "--help";
+        public const string LongFormatShort = "-l";
+        public const string LongFormatLong = "--long-format";
+        public const string LongSectorsShort = "-r";
+        public const string LongSectorsLong = "--long-sectors";
+        public const string MD5Short = "-m";
+        public const string MD5Long = "--md5";
+        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";
+        public const string ResumeLong = "--resume";
+        public const string RetrySubchannelLong = "--retry-subchannel";
+        public const string SectorTagsShort = "-p";
+        public const string SectorTagsLong = "--sector-tags";
+        public const string SeparatedTracksShort = "-t";
+        public const string SeparatedTracksLong = "--separated-tracks";
+        public const string SHA1Short = "-s";
+        public const string SHA1Long = "--sha1";
+        public const string SHA256Long = "--sha256";
+        public const string SHA384Long = "--sha384";
+        public const string SHA512Long = "--sha512";
+        public const string SkipCdiReadyHoleLong = "--skip-cdiready-hole";
+        public const string SpamSumShort = "-f";
+        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";
+        public const string VerifyDiscLong = "--verify-disc";
+        public const string VerifySectorsShort = "-s";
+        public const string VerifySectorsLong = "--verify-sectors";
+        public const string VersionLong = "--version";
+        public const string WholeDiscShort = "-w";
+        public const string WholeDiscLong = "--whole-disc";
+
+        // Int8 flags
+        public const string SpeedLong = "--speed";
+
+        // Int16 flags
+        public const string RetryPassesShort = "-p";
+        public const string RetryPassesLong = "--retry-passes";
+        public const string WidthShort = "-w";
+        public const string WidthLong = "--width";
+
+        // Int32 flags
+        public const string BlockSizeShort = "-b";
+        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";
+        public const string SkipLong = "--skip";
+
+        // Int64 flags
+        public const string LengthShort = "-l"; // or "all"
+        public const string LengthLong = "--length"; // or "all"
+        public const string StartShort = "-s";
+        public const string StartLong = "--start";
+
+        // String flags
+        public const string CommentsLong = "--comments";
+        public const string CreatorLong = "--creator";
+        public const string DriveManufacturerLong = "--drive-manufacturer";
+        public const string DriveModelLong = "--drive-model";
+        public const string DriveRevisionLong = "--drive-revision";
+        public const string DriveSerialLong = "--drive-serial";
+        public const string EncodingShort = "-e";
+        public const string EncodingLong = "--encoding";
+        public const string FormatConvertShort = "-p";
+        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";
+        public const string MediaManufacturerLong = "--media-manufacturer";
+        public const string MediaModelLong = "--media-model";
+        public const string MediaPartNumberLong = "--media-partnumber";
+        public const string MediaSerialLong = "--media-serial";
+        public const string MediaTitleLong = "--media-title";
+        public const string MHDDLogShort = "-m";
+        public const string MHDDLogLong = "--mhdd-log";
+        public const string NamespaceShort = "-n";
+        public const string NamespaceLong = "--namespace";
+        public const string OptionsShort = "-O";
+        public const string OptionsLong = "--options";
+        public const string OutputPrefixShort = "-w";
+        public const string OutputPrefixLong = "--output-prefix";
+        public const string ResumeFileShort = "-r";
+        public const string ResumeFileLong = "--resume-file";
+        public const string SubchannelLong = "--subchannel";
+        public const string XMLSidecarShort = "-x";
+        public const string XMLSidecarLong = "--cicm-xml";
+    }
+
+    /// <summary>
+    /// Supported formats for Aaru
+    /// </summary>
+    /// TODO: Use to verify format settings
+    public static class FormatStrings
+    {
+        // Supported filters
+        public const string AppleDouble = "AppleDouble";
+        public const string AppleSingle = "AppleSingle";
+        public const string BZip2 = "BZip2";
+        public const string GZip = "GZip";
+        public const string LZip = "LZip";
+        public const string MacBinary = "MacBinary";
+        public const string NoFilter = "No filter";
+        public const string PCExchange = "PCExchange";
+        public const string XZ = "XZ";
+
+        // Read-only media image formats
+        public const string AppleDiskArchivalRetrievalTool = "Apple Disk Archival/Retrieval Tool";
+        public const string AppleNewDiskImageFormat = "Apple New Disk Image Format";
+        public const string AppleNIB = "Apple NIB";
+        public const string BlindWrite4 = "BlindWrite 4";
+        public const string BlindWrite5 = "BlindWrite 5";
+        public const string CPCEMUDiskFileAndExtendedCPCDiskFile = "CPCEMU Disk-File and Extended CPC Disk-File";
+        public const string D2FDiskImage = "d2f disk image";
+        public const string D88DiskImage = "D88 Disk Image";
+        public const string DIMDiskImage = "DIM Disk Image";
+        public const string DiscFerret = "DiscFerret";
+        public const string DiscJuggler = "DiscJuggler";
+        public const string DreamcastGDIImage = "Dreamcast GDI image";
+        public const string DunfieldsIMD = "Dunfield's IMD";
+        public const string HDCopyDiskImage = "HD-Copy disk image";
+        public const string KryoFluxSTREAM = "KryoFlux STREAM";
+        public const string MAMECompressedHunksOfData = "MAME Compressed Hunks of Data";
+        public const string MicrosoftVHDX = "Microsoft VHDX";
+        public const string NeroBurningROMImage = "Nero Burning ROM image";
+        public const string PartCloneDiskImage = "PartClone disk image";
+        public const string PartimageDiskImage = "Partimage disk image";
+        public const string SpectrumFloppyDiskImage = "Spectrum Floppy Disk Image";
+        public const string SuperCardPro = "SuperCardPro";
+        public const string SydexCopyQM = "Sydex CopyQM";
+        public const string SydexTeleDisk = "Sydex TeleDisk";
+
+        // Read/write media image formats
+        public const string AaruFormat = "Aaru Format";
+        public const string ACTApricotDiskImage = "ACT Apricot Disk Image";
+        public const string Alcohol120MediaDescriptorStructure = "Alcohol 120% Media Descriptor Structure";
+        public const string Anex86DiskImage = "Anex86 Disk Image";
+        public const string Apple2InterleavedDiskImage = "Apple ][Interleaved Disk Image";
+        public const string Apple2IMG = "Apple 2IMG";
+        public const string AppleDiskCopy42 = "Apple DiskCopy 4.2";
+        public const string AppleUniversalDiskImageFormat = "Apple Universal Disk Image Format";
+        public const string BasicLisaUtility = "Basic Lisa Utility";
+        public const string CDRDAOTocfile = "CDRDAO tocfile";
+        public const string CDRWinCuesheet = "CDRWin cuesheet";
+        public const string CisCopyDiskImageDCFile = "CisCopy Disk Image(DC-File)";
+        public const string CloneCD = "CloneCD";
+        public const string CopyTape = "CopyTape";
+        public const string DigitalResearchDiskCopy = "Digital Research DiskCopy";
+        public const string IBMSaveDskF = "IBM SaveDskF";
+        public const string MAXIDiskImage = "MAXI Disk image";
+        public const string ParallelsDiskImage = "Parallels disk image";
+        public const string QEMUCopyOnWriteDiskImage = "QEMU Copy-On-Write disk image";
+        public const string QEMUCopyOnWriteDiskImageV2 = "QEMU Copy-On-Write disk image v2";
+        public const string QEMUEnhancedDiskImage = "QEMU Enhanced Disk image";
+        public const string RawDiskImage = "Raw Disk Image";
+        public const string RayAracheliansDiskIMage = "Ray Arachelian's Disk IMage";
+        public const string RSIDEHardDiskImage = "RS-IDE Hard Disk Image";
+        public const string T98HardDiskImage = "T98 Hard Disk Image";
+        public const string T98NextNHDr0DiskImage = "T98-Next NHD r0 Disk Image";
+        public const string Virtual98DiskImage = "Virtual98 Disk Image";
+        public const string VirtualBoxDiskImage = "VirtualBox Disk Image";
+        public const string VirtualPC = "VirtualPC";
+        public const string VMwareDiskImage = "VMware disk image";
+
+        // Supported filesystems for identification and information only
+        public const string AcornAdvancedDiscFilingSystem = "Acorn Advanced Disc Filing System";
+        public const string AlexanderOsipovDOSFileSystem = "Alexander Osipov DOS file system";
+        public const string AmigaDOSFilesystem = "Amiga DOS filesystem";
+        public const string AppleFileSystem = "Apple File System";
+        public const string AppleHFSPlusFilesystem = "Apple HFS+ filesystem";
+        public const string AppleHierarchicalFileSystem = "Apple Hierarchical File System";
+        public const string AppleProDOSFilesystem = "Apple ProDOS filesystem";
+        public const string AtheOSFilesystem = "AtheOS Filesystem";
+        public const string BeFilesystem = "Be Filesystem";
+        public const string BSDFastFileSystem = "BSD Fast File System(aka UNIX File System, UFS)";
+        public const string BTreeFileSystem = "B-tree file system";
+        public const string CommodoreFileSystem = "Commodore file system";
+        public const string CramFilesystem = "Cram filesystem";
+        public const string DumpEightPlugin = "dump(8) Plugin";
+        public const string ECMA67 = "ECMA-67";
+        public const string ExtentFileSystemPlugin = "Extent File System Plugin";
+        public const string F2FSPlugin = "F2FS Plugin";
+        public const string Files11OnDiskStructure = "Files-11 On-Disk Structure";
+        public const string FossilFilesystemPlugin = "Fossil Filesystem Plugin";
+        public const string HAMMERFilesystem = "HAMMER Filesystem";
+        public const string HighPerformanceOpticalFileSystem = "High Performance Optical File System";
+        public const string HPLogicalInterchangeFormatPlugin = "HP Logical Interchange Format Plugin";
+        public const string JFSPlugin = "JFS Plugin";
+        public const string LinuxExtendedFilesystem = "Linux extended Filesystem";
+        public const string LinuxExtendedFilesystem234 = "Linux extended Filesystem 2, 3 and 4";
+        public const string LocusFilesystemPlugin = "Locus Filesystem Plugin";
+        public const string MicroDOSFileSystem = "MicroDOS file system";
+        public const string MicrosoftExtendedFileAllocationTable = "Microsoft Extended File Allocation Table";
+        public const string MinixFilesystem = "Minix Filesystem";
+        public const string NewTechnologyFileSystem = "New Technology File System(NTFS)";
+        public const string NILFS2Plugin = "NILFS2 Plugin";
+        public const string NintendoOpticalFilesystems = "Nintendo optical filesystems";
+        public const string OS2HighPerformanceFileSystem = "OS/2 High Performance File System";
+        public const string OS9RandomBlockFilePlugin = "OS-9 Random Block File Plugin";
+        public const string PCEngineCDPlugin = "PC Engine CD Plugin";
+        public const string PCFXPlugin = "PC-FX Plugin";
+        public const string ProfessionalFileSystem = "Professional File System";
+        public const string QNX4Plugin = "QNX4 Plugin";
+        public const string QNX6Plugin = "QNX6 Plugin";
+        public const string ReiserFilesystemPlugin = "Reiser Filesystem Plugin";
+        public const string Reiser4FilesystemPlugin = "Reiser4 Filesystem Plugin";
+        public const string ResilientFileSystemPlugin = "Resilient File System plugin";
+        public const string RT11FileSystem = "RT-11 file system";
+        public const string SmartFileSystem = "SmartFileSystem";
+        public const string SolarOSFilesystem = "Solar_OS filesystem";
+        public const string SquashFilesystem = "Squash filesystem";
+        public const string UNICOSFilesystemPlugin = "UNICOS Filesystem Plugin";
+        public const string UniversalDiskFormat = "Universal Disk Format";
+        public const string UNIXBootFilesystem = "UNIX Boot filesystem";
+        public const string UNIXSystemVFilesystem = "UNIX System V filesystem";
+        public const string VeritasFilesystem = "Veritas filesystem";
+        public const string VMwareFilesystem = "VMware filesystem";
+        public const string XFSFilesystemPlugin = "XFS Filesystem Plugin";
+        public const string XiaFilesystem = "Xia filesystem";
+        public const string ZFSFilesystemPlugin = "ZFS Filesystem Plugin";
+
+        // Supported filesystems that can read their contents
+        public const string AppleDOSFileSystem = "Apple DOS File System";
+        public const string AppleLisaFileSystem = "Apple Lisa File System";
+        public const string AppleMacintoshFileSystem = "Apple Macintosh File System";
+        public const string CPMFileSystem = "CP/M File System";
+        public const string FATXFilesystemPlugin = "FATX Filesystem Plugin";
+        public const string ISO9660Filesystem = "ISO9660 Filesystem";
+        public const string MicrosoftFileAllocationTable = "Microsoft File Allocation Table";
+        public const string OperaFilesystemPlugin = "Opera Filesystem Plugin";
+        public const string UCSDPascalFilesystem = "U.C.S.D.Pascal filesystem";
+
+        // Supported partitioning schemes
+        public const string AcornFileCorePartitions = "Acorn FileCore partitions";
+        public const string ACTApricotPartitions = "ACT Apricot partitions";
+        public const string AmigaRigidDiskBlock = "Amiga Rigid Disk Block";
+        public const string ApplePartitionMap = "Apple Partition Map";
+        public const string AtariPartitions = "Atari partitions";
+        public const string BSDDisklabel = "BSD disklabel";
+        public const string DECDisklabel = "DEC disklabel";
+        public const string DragonFlyBSD64bitDisklabel = "DragonFly BSD 64-bit disklabel";
+        public const string GUIDPartitionTable = "GUID Partition Table";
+        public const string Human68kPartitions = "Human 68k partitions";
+        public const string MasterBootRecord = "Master Boot Record";
+        public const string NECPC9800PartitionTable = "NEC PC-9800 partition table";
+        public const string NeXTDisklabel = "NeXT Disklabel";
+        public const string Plan9PartitionTable = "Plan9 partition table";
+        public const string RioKarmaPartitioning = "Rio Karma partitioning";
+        public const string SGIDiskVolumeHeader = "SGI Disk Volume Header";
+        public const string SunDisklabel = "Sun Disklabel";
+        public const string UNIXHardwired = "UNIX hardwired";
+        public const string UNIXVTOC = "UNIX VTOC";
+        public const string XboxPartitioning = "Xbox partitioning";
+        public const string XENIX = "XENIX";
+    }
+
+    /// <summary>
+    /// Supported namespaces for Aaru
+    /// </summary>
+    /// TODO: Use to verify namespace settings
+    public static class NamespaceStrings
+    {
+        // Namespaces for Apple Lisa File System
+        public const string LisaOfficeSystem = "office";
+        public const string LisaPascalWorkshop = "workshop"; // Default
+
+        // Namespaces for ISO9660 Filesystem
+        public const string JolietVolumeDescriptor = "joliet"; // Default
+        public const string PrimaryVolumeDescriptor = "normal";
+        public const string PrimaryVolumeDescriptorwithEncoding = "romeo";
+        public const string RockRidge = "rrip";
+        public const string PrimaryVolumeDescriptorVersionSuffix = "vms";
+
+        // Namespaces for Microsoft File Allocation Table
+        public const string DOS83UpperCase = "dos";
+        public const string LFNWhenAvailableWithFallback = "ecs"; // Default
+        public const string LongFileNames = "lfn";
+        public const string WindowsNT83MixedCase = "nt";
+        public const string OS2Extended = "os2";
+    }
+
+    /// <summary>
+    /// Supported options for Aaru
+    /// </summary>
+    /// TODO: Use to verify option settings
+    public static class OptionStrings
+    {
+        // Aaru format
+        public const string AaruCompress = "compress"; // boolean, default true;
+        public const string AaruDeduplicate = "deduplicate"; // boolean, default true
+        public const string AaruDictionary = "dictionary"; // number, default 33554432
+        public const string AaruMaxDDTSize = "max_ddt_size"; // number, default 256
+        public const string AaruMD5 = "md5"; // boolean, default false
+        public const string AaruSectorsPerBlock = "sectors_per_block"; // number, default 4096 [power of 2]
+        public const string AaruSHA1 = "sha1"; // boolean, default false
+        public const string AaruSHA256 = "sha256"; // boolean, default false
+        public const string AaruSpamSum = "spamsum"; // boolean, default false
+
+        // ACT Apricot Disk Image
+        public const string ACTApricotDiskImageCompress = "compress"; // boolean, default false
+
+        // Apple DiskCopy 4.2
+        public const string AppleDiskCopyMacOSX = "macosx"; // boolean, default false
+
+        // CDRDAO tocfile
+        public const string CDRDAOTocfileSeparate = "separate"; // boolean, default false
+
+        // CDRWin cuesheet
+        public const string CDRWinCuesheetSeparate = "separate"; // boolean, default false
+
+        // ISO9660 Filesystem
+        public const string ISO9660FSUseEvd = "use_evd"; // boolean, default false
+        public const string ISO9660FSUsePathTable = "use_path_table"; // boolean, default false
+        public const string ISO9660FSUseTransTbl = "use_trans_tbl"; // boolean, default false
+
+        // VMware disk image
+        public const string VMwareDiskImageAdapterType = "adapter_type"; // string, default ide [ide, lsilogic, buslogic, legacyESX]
+        public const string VMwareDiskImageHWVersion = "hwversion"; // number, default 4
+        public const string VMwareDiskImageSparse = "sparse"; // boolean, default false
+        public const string VMwareDiskImageSplit = "split"; // boolean, default false
+    }
+}

MPF.Core/Modules/Aaru/Converters.cs

@@ -0,0 +1,22 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.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.Core/Modules/CleanRIp/Parameters.cs

@@ -0,0 +1,474 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using SabreTools.RedumpLib.Data;
+
+#pragma warning disable IDE0051 // Remove unused private members
+
+namespace MPF.Core.Modules.CleanRip
+{
+    /// <summary>
+    /// Represents a generic set of CleanRip parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.CleanRip;
+
+        #endregion
+
+        /// <inheritdoc/>
+#if NET48
+        public Parameters(string parameters) : base(parameters) { }
+#else
+        public Parameters(string? parameters) : base(parameters) { }
+#endif
+
+        /// <inheritdoc/>
+#if NET48
+        public Parameters(RedumpSystem? system, MediaType? type, string drivePath, string filename, int? driveSpeed, Options options)
+#else
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+#endif
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            var missingFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    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:
+                    missingFiles.Add("Media and system combination not supported for CleanRip");
+                    break;
+            }
+
+            return (!missingFiles.Any(), missingFiles);
+        }
+
+        /// <inheritdoc/>
+#if NET48
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive drive, bool includeArtifacts)
+#else
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
+#endif
+        {
+            // Ensure that required sections exist
+            info = SubmissionInfoTool.EnsureAllSections(info);
+
+            // TODO: Determine if there's a CleanRip version anywhere
+#if NET48
+            info.DumpingInfo.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+#else
+            info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+#endif
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(basePath + "-dumpinfo.txt")?.ToString("yyyy-MM-dd HH:mm:ss");
+
+            var datafile = GenerateCleanripDatafile(basePath + ".iso", basePath + "-dumpinfo.txt");
+
+            // Get the individual hash data, as per internal
+            if (InfoTool.GetISOHashValues(datafile, out long size, out var crc32, out var md5, out var sha1))
+            {
+#if NET48
+                info.SizeAndChecksums.Size = size;
+#else
+                info.SizeAndChecksums!.Size = size;
+#endif
+                info.SizeAndChecksums.CRC32 = crc32;
+                info.SizeAndChecksums.MD5 = md5;
+                info.SizeAndChecksums.SHA1 = sha1;
+
+                // Dual-layer discs have the same size and layerbreak
+                if (size == 8511160320)
+                    info.SizeAndChecksums.Layerbreak = 2084960;
+            }
+
+            // Extract info based generically on MediaType
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (File.Exists(basePath + ".bca"))
+#if NET48
+                        info.Extras.BCA = GetBCA(basePath + ".bca");
+#else
+                        info.Extras!.BCA = GetBCA(basePath + ".bca");
+#endif
+
+                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out Region? gcRegion, out var gcVersion, out var gcName))
+                    {
+#if NET48
+                        info.CommonDiscInfo.Region = gcRegion ?? info.CommonDiscInfo.Region;
+                        info.VersionAndEditions.Version = gcVersion ?? info.VersionAndEditions.Version;
+                        info.CommonDiscInfo.CommentsSpecialFields[SiteCode.InternalName] = gcName ?? string.Empty;
+#else
+                        info.CommonDiscInfo!.Region = gcRegion ?? info.CommonDiscInfo.Region;
+                        info.VersionAndEditions!.Version = gcVersion ?? info.VersionAndEditions.Version;
+                        info.CommonDiscInfo.CommentsSpecialFields![SiteCode.InternalName] = gcName ?? string.Empty;
+#endif
+                    }
+
+                    break;
+            }
+
+            // Fill in any artifacts that exist, Base64-encoded, if we need to
+            if (includeArtifacts)
+            {
+#if NET48
+                if (info.Artifacts == null) info.Artifacts = new Dictionary<string, string>();
+#else
+                info.Artifacts ??= new Dictionary<string, string>();
+#endif
+
+                if (File.Exists(basePath + ".bca"))
+                    info.Artifacts["bca"] = GetBase64(GetFullFile(basePath + ".bca", binary: true)) ?? string.Empty;
+                if (File.Exists(basePath + "-dumpinfo.txt"))
+                    info.Artifacts["dumpinfo"] = GetBase64(GetFullFile(basePath + "-dumpinfo.txt")) ?? string.Empty;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetLogFilePaths(string basePath)
+        {
+            var logFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.DVD: // Only added here to help users; not strictly correct
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (File.Exists($"{basePath}-dumpinfo.txt"))
+                        logFiles.Add($"{basePath}-dumpinfo.txt");
+                    if (File.Exists($"{basePath}.bca"))
+                        logFiles.Add($"{basePath}.bca");
+
+                    break;
+            }
+
+            return logFiles;
+        }
+
+        #endregion
+
+        #region Information Extraction Methods
+
+        /// <summary>
+        /// Get a formatted datfile from the cleanrip output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <returns></returns>
+#if NET48
+        private static Datafile GenerateCleanripDatafile(string iso, string dumpinfo)
+#else
+        private static Datafile? GenerateCleanripDatafile(string iso, string dumpinfo)
+#endif
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return null;
+
+            using (var sr = File.OpenText(dumpinfo))
+            {
+                long size = new FileInfo(iso).Length;
+                string crc = string.Empty;
+                string md5 = string.Empty;
+                string sha1 = string.Empty;
+
+                try
+                {
+                    // Make sure this file is a dumpinfo
+                    if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                        return null;
+
+                    // Read all lines and gather dat information
+                    while (!sr.EndOfStream)
+                    {
+                        var line = sr.ReadLine()?.Trim();
+                        if (string.IsNullOrWhiteSpace(line))
+                            continue;
+#if NET48
+                        else if (line.StartsWith("CRC32"))
+                            crc = line.Substring(7).ToLowerInvariant();
+                        else if (line.StartsWith("MD5"))
+                            md5 = line.Substring(5);
+                        else if (line.StartsWith("SHA-1"))
+                            sha1 = line.Substring(7);
+#else
+                        else if (line.StartsWith("CRC32"))
+                            crc = line[7..].ToLowerInvariant();
+                        else if (line.StartsWith("MD5"))
+                            md5 = line[5..];
+                        else if (line.StartsWith("SHA-1"))
+                            sha1 = line[7..];
+#endif
+                    }
+
+                    return new Datafile
+                    {
+                        Games = new Game[]
+                        {
+                            new Game
+                            {
+                                Roms = new Rom[]
+                                {
+                                    new Rom { Name = Path.GetFileName(iso), Size = size.ToString(), Crc = crc, Md5 = md5, Sha1 = sha1 },
+                                }
+                            }
+                        }
+                    };
+                }
+                catch
+                {
+                    // We don't care what the exception is right now
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the hex contents of the BCA file
+        /// </summary>
+        /// <param name="bcaPath">Path to the BCA file associated with the dump</param>
+        /// <returns>BCA data as a hex string if possible, null on error</returns>
+        /// <remarks>https://stackoverflow.com/questions/9932096/add-separator-to-string-at-every-n-characters</remarks>
+#if NET48
+        private static string GetBCA(string bcaPath)
+#else
+        private static string? GetBCA(string bcaPath)
+#endif
+        {
+            // If the file doesn't exist, we can't get the info
+            if (!File.Exists(bcaPath))
+                return null;
+
+            try
+            {
+                var hex = GetFullFile(bcaPath, true);
+                if (hex == null)
+                    return null;
+
+                return Regex.Replace(hex, ".{32}", "$0\n");
+            }
+            catch
+            {
+                // We don't care what the error was right now
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get a formatted datfile from the cleanrip output, if possible
+        /// </summary>
+        /// <param name="iso">Path to ISO file</param>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <returns></returns>
+#if NET48
+        private static string GetCleanripDatfile(string iso, string dumpinfo)
+#else
+        private static string? GetCleanripDatfile(string iso, string dumpinfo)
+#endif
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return null;
+
+            using (var sr = File.OpenText(dumpinfo))
+            {
+                long size = new FileInfo(iso).Length;
+                string crc = string.Empty;
+                string md5 = string.Empty;
+                string sha1 = string.Empty;
+
+                try
+                {
+                    // Make sure this file is a dumpinfo
+                    if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                        return null;
+
+                    // Read all lines and gather dat information
+                    while (!sr.EndOfStream)
+                    {
+                        var line = sr.ReadLine()?.Trim();
+                        if (string.IsNullOrWhiteSpace(line))
+                            continue;
+#if NET48
+                        else if (line.StartsWith("CRC32"))
+                            crc = line.Substring(7).ToLowerInvariant();
+                        else if (line.StartsWith("MD5"))
+                            md5 = line.Substring(5);
+                        else if (line.StartsWith("SHA-1"))
+                            sha1 = line.Substring(7);
+#else
+                        else if (line.StartsWith("CRC32"))
+                            crc = line[7..].ToLowerInvariant();
+                        else if (line.StartsWith("MD5"))
+                            md5 = line[5..];
+                        else if (line.StartsWith("SHA-1"))
+                            sha1 = line[7..];
+#endif
+                    }
+
+                    return $"<rom name=\"{Path.GetFileName(iso)}\" size=\"{size}\" crc=\"{crc}\" md5=\"{md5}\" sha1=\"{sha1}\" />";
+                }
+                catch
+                {
+                    // We don't care what the exception is right now
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the extracted GC and Wii version
+        /// </summary>
+        /// <param name="dumpinfo">Path to discinfo file</param>
+        /// <param name="region">Output region, if possible</param>
+        /// <param name="version">Output internal version of the game</param>
+        /// <param name="name">Output internal name of the game</param>
+        /// <returns></returns>
+#if NET48
+        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string version, out string name)
+#else
+        private static bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string? version, out string? name)
+#endif
+        {
+            region = null; version = null; name = null;
+
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return false;
+
+            using (var sr = File.OpenText(dumpinfo))
+            {
+                try
+                {
+                    // Make sure this file is a dumpinfo
+                    if (sr.ReadLine()?.Contains("--File Generated by CleanRip") != true)
+                        return false;
+
+                    // Read all lines and gather dat information
+                    while (!sr.EndOfStream)
+                    {
+                        var line = sr.ReadLine()?.Trim();
+                        if (string.IsNullOrWhiteSpace(line))
+                        {
+                            continue;
+                        }
+                        else if (line.StartsWith("Version"))
+                        {
+#if NET48
+                            version = line.Substring("Version: ".Length);
+#else
+                            version = line["Version: ".Length..];
+#endif
+                        }
+                        else if (line.StartsWith("Internal Name"))
+                        {
+#if NET48
+                            name = line.Substring("Internal Name: ".Length);
+#else
+                            name = line["Internal Name: ".Length..];
+#endif
+                        }
+                        else if (line.StartsWith("Filename"))
+                        {
+#if NET48
+                            string serial = line.Substring("Filename: ".Length);
+#else
+                            string serial = line["Filename: ".Length..];
+#endif
+
+                            // char gameType = serial[0];
+                            // string gameid = serial[1] + serial[2];
+                            // string version = serial[4] + serial[5]
+
+                            switch (serial[3])
+                            {
+                                case 'A':
+                                    region = Region.World;
+                                    break;
+                                case 'D':
+                                    region = Region.Germany;
+                                    break;
+                                case 'E':
+                                    region = Region.UnitedStatesOfAmerica;
+                                    break;
+                                case 'F':
+                                    region = Region.France;
+                                    break;
+                                case 'I':
+                                    region = Region.Italy;
+                                    break;
+                                case 'J':
+                                    region = Region.Japan;
+                                    break;
+                                case 'K':
+                                    region = Region.SouthKorea;
+                                    break;
+                                case 'L':
+                                    region = Region.Europe; // Japanese import to Europe
+                                    break;
+                                case 'M':
+                                    region = Region.Europe; // American import to Europe
+                                    break;
+                                case 'N':
+                                    region = Region.UnitedStatesOfAmerica; // Japanese import to USA
+                                    break;
+                                case 'P':
+                                    region = Region.Europe;
+                                    break;
+                                case 'R':
+                                    region = Region.RussianFederation;
+                                    break;
+                                case 'S':
+                                    region = Region.Spain;
+                                    break;
+                                case 'Q':
+                                    region = Region.SouthKorea; // Korea with Japanese language
+                                    break;
+                                case 'T':
+                                    region = Region.SouthKorea; // Korea with English language
+                                    break;
+                                case 'X':
+                                    region = null; // Not a real region code
+                                    break;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+                catch
+                {
+                    // We don't care what the exception is right now
+                    return false;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Modules/Datafile.cs

@@ -0,0 +1,145 @@
+using System.Xml.Serialization;
+
+namespace MPF.Core.Modules
+{
+    [XmlRoot("datafile")]
+    public class Datafile
+    {
+        [XmlElement("header")]
+#if NET48
+        public Header Header;
+#else
+        public Header? Header;
+#endif
+
+        [XmlElement("game")]
+#if NET48
+        public Game[] Games;
+#else
+        public Game[]? Games;
+#endif
+    }
+
+    public class Header
+    {
+        [XmlElement("name")]
+#if NET48
+        public string Name;
+#else
+        public string? Name;
+#endif
+
+        [XmlElement("description")]
+#if NET48
+        public string Description;
+#else
+        public string? Description;
+#endif
+
+        [XmlElement("version")]
+#if NET48
+        public string Version;
+#else
+        public string? Version;
+#endif
+
+        [XmlElement("date")]
+#if NET48
+        public string Date;
+#else
+        public string? Date;
+#endif
+
+        [XmlElement("author")]
+#if NET48
+        public string Author;
+#else
+        public string? Author;
+#endif
+
+        [XmlElement("homepage")]
+#if NET48
+        public string Homepage;
+#else
+        public string? Homepage;
+#endif
+
+        [XmlElement("url")]
+#if NET48
+        public string Url;
+#else
+        public string? Url;
+#endif
+    }
+
+    public class Game
+    {
+        [XmlAttribute("name")]
+#if NET48
+        public string Name;
+#else
+        public string? Name;
+#endif
+
+        [XmlElement("category")]
+#if NET48
+        public string Category;
+#else
+        public string? Category;
+#endif
+
+        [XmlElement("description")]
+#if NET48
+        public string Description;
+#else
+        public string? Description;
+#endif
+
+        [XmlElement("rom")]
+#if NET48
+        public Rom[] Roms;
+#else
+        public Rom[]? Roms;
+#endif
+    }
+
+    public class Rom
+    {
+        [XmlAttribute("name")]
+#if NET48
+        public string Name;
+#else
+        public string? Name;
+#endif
+
+        [XmlAttribute("size")]
+#if NET48
+        public string Size;
+#else
+        public string? Size;
+#endif
+
+        [XmlAttribute("crc")]
+#if NET48
+        public string Crc;
+#else
+        public string? Crc;
+#endif
+
+        [XmlAttribute("md5")]
+#if NET48
+        public string Md5;
+#else
+        public string? Md5;
+#endif
+
+        [XmlAttribute("sha1")]
+#if NET48
+        public string Sha1;
+#else
+        public string? Sha1;
+#endif
+
+        // TODO: Add extended hashes here
+    }
+}

MPF.Core/Modules/DiscImageCreator/Constants.cs

@@ -0,0 +1,77 @@
+namespace MPF.Core.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";
+        public const string CompactDisc = "cd";
+        public const string Data = "data";
+        public const string DigitalVideoDisc = "dvd";
+        public const string Disk = "disk";
+        public const string DriveSpeed = "ls";
+        public const string Eject = "eject";
+        public const string Floppy = "fd";
+        public const string GDROM = "gd";
+        public const string MDS = "mds";
+        public const string Merge = "merge";
+        public const string Reset = "reset";
+        public const string SACD = "sacd";
+        public const string Start = "start";
+        public const string Stop = "stop";
+        public const string Sub = "sub";
+        public const string Swap = "swap";
+        public const string Tape = "tape";
+        public const string Version = "/v";
+        public const string XBOX = "xbox";
+        public const string XBOXSwap = "xboxswap";
+        public const string XGD2Swap = "xgd2swap";
+        public const string XGD3Swap = "xgd3swap";
+    }
+
+    /// <summary>
+    /// Dumping flags for DiscImageCreator
+    /// </summary>
+    public static class FlagStrings
+    {
+        public const string AddOffset = "/a";
+        public const string AMSF = "/p";
+        public const string AtariJaguar = "/aj";
+        public const string BEOpcode = "/be";
+        public const string C2Opcode = "/c2";
+        public const string CopyrightManagementInformation = "/c";
+        public const string D8Opcode = "/d8";
+        public const string DatExpand = "/d";
+        public const string DisableBeep = "/q";
+        public const string DVDReread = "/rr";
+        public const string ExtractMicroSoftCabFile = "/mscf";
+        public const string Fix = "/fix";
+        public const string ForceUnitAccess = "/f";
+        public const string MultiSectorRead = "/mr";
+        public const string NoFixSubP = "/np";
+        public const string NoFixSubQ = "/nq";
+        public const string NoFixSubQLibCrypt = "/nl";
+        public const string NoFixSubRtoW = "/nr";
+        public const string NoFixSubQSecuROM = "/ns";
+        public const string NoSkipSS = "/nss";
+        public const string PadSector = "/ps";
+        public const string Range = "/ra";
+        public const string Raw = "/raw";
+        public const string Resume = "/re";
+        public const string Reverse = "/r";
+        public const string ScanAntiMod = "/am";
+        public const string ScanFileProtect = "/sf";
+        public const string ScanSectorProtect = "/ss";
+        public const string SeventyFour = "/74";
+        public const string SkipSector = "/sk";
+        public const string SubchannelReadLevel = "/s";
+        public const string UseAnchorVolumeDescriptorPointer = "/avdp";
+        public const string VideoNow = "/vn";
+        public const string VideoNowColor = "/vnc";
+        public const string VideoNowXP = "/vnx";
+    }
+}

MPF.Core/Modules/DiscImageCreator/Converters.cs

@@ -0,0 +1,132 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.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>
+#if NET48
+        public static MediaType? ToMediaType(string baseCommand)
+#else
+        public static MediaType? ToMediaType(string? baseCommand)
+#endif
+        {
+            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>
+#if NET48
+        public static string Extension(MediaType? type)
+#else
+        public static string? Extension(MediaType? type)
+#endif
+        {
+            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.Core/Modules/Redumper/Constants.cs

@@ -0,0 +1,74 @@
+namespace MPF.Core.Modules.Redumper
+{
+    /// <summary>
+    /// Top-level commands for Redumper
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+        public const string CD = "cd";
+        public const string DVD = "dvd"; // Synonym for CD
+        public const string BluRay = "bd"; // Synonym for CD
+        public const string SACD = "sacd"; // Synonym for CD
+        public const string Dump = "dump";
+        public const string Info = "info";
+        public const string Protection = "protection";
+        public const string Refine = "refine";
+        public const string Split = "split";
+        public const string Verify = "verify";
+        public const string DVDKey = "dvdkey";
+        public const string DVDIsoKey = "dvdisokey";
+    }
+
+    /// <summary>
+    /// Dumping flags for Redumper
+    /// </summary>
+    public static class FlagStrings
+    {
+        // General
+        public const string HelpLong = "--help";
+        public const string HelpShort = "-h";
+        public const string Verbose = "--verbose";
+        public const string Debug = "--debug";
+        public const string Drive = "--drive";
+        public const string Speed = "--speed";
+        public const string Retries = "--retries";
+        public const string ImagePath = "--image-path";
+        public const string ImageName = "--image-name";
+        public const string Overwrite = "--overwrite";
+
+        // Drive Configuration
+        public const string DriveType = "--drive-type";
+        public const string DriveReadOffset = "--drive-read-offset";
+        public const string DriveC2Shift = "--drive-c2-shift";
+        public const string DrivePregapStart = "--drive-pregap-start";
+        public const string DriveReadMethod = "--drive-read-method";
+        public const string DriveSectorOrder = "--drive-sector-order";
+
+        // Drive Specific
+        public const string PlextorLeadinSkip = "--plextor-leadin-skip";
+        public const string PlextorLeadinRetries = "--plextor-leadin-retries";
+        public const string AsusSkipLeadout = "--asus-skip-leadout";
+
+        // Offset
+        public const string ForceOffset = "--force-offset";
+        public const string AudioSilenceThreshold = "--audio-silence-threshold";
+        public const string CorrectOffsetShift = "--correct-offset-shift";
+        public const string OffsetShiftRelocate = "--offset-shift-relocate";
+
+        // Split
+        public const string ForceSplit = "--force-split";
+        public const string LeaveUnchanged = "--leave-unchanged";
+        public const string ForceQTOC = "--force-qtoc";
+        public const string SkipFill = "--skip-fill";
+        public const string ISO9660Trim = "--iso9660-trim";
+
+        // Miscellaneous
+        public const string LBAStart = "--lba-start";
+        public const string LBAEnd = "--lba-end";
+        public const string RefineSubchannel = "--refine-subchannel";
+        public const string Skip = "--skip";
+        public const string DumpReadSize = "--dump-read-size";
+        public const string OverreadLeadout = "--overread-leadout";
+    }
+}

MPF.Core/Modules/Redumper/Converters.cs

@@ -0,0 +1,36 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.Redumper
+{
+    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>
+#if NET48
+        public static string Extension(MediaType? type)
+#else
+        public static string? Extension(MediaType? type)
+#endif
+        {
+            switch (type)
+            {
+                case MediaType.CDROM:
+                    return ".bin";
+                case MediaType.DVD:
+                case MediaType.HDDVD:
+                case MediaType.BluRay:
+                    return ".iso";
+                case MediaType.NONE:
+                default:
+                    return null;
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Modules/UmdImageCreator/Parameters.cs

@@ -0,0 +1,284 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using MPF.Core.Hashing;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Modules.UmdImageCreator
+{
+    /// <summary>
+    /// Represents a generic set of UmdImageCreator parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        #region Metadata
+
+        /// <inheritdoc/>
+        public override InternalProgram InternalProgram => InternalProgram.UmdImageCreator;
+
+        #endregion
+
+        /// <inheritdoc/>
+#if NET48
+        public Parameters(string parameters) : base(parameters) { }
+#else
+        public Parameters(string? parameters) : base(parameters) { }
+#endif
+
+        /// <inheritdoc/>
+#if NET48
+        public Parameters(RedumpSystem? system, MediaType? type, string drivePath, string filename, int? driveSpeed, Options options)
+#else
+        public Parameters(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Options options)
+#endif
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseParameters Implementations
+
+        /// <inheritdoc/>
+        public override (bool, List<string>) CheckAllOutputFilesExist(string basePath, bool preCheck)
+        {
+            var missingFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.UMD:
+                    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:
+                    missingFiles.Add("Media and system combination not supported for UmdImageCreator");
+                    break;
+            }
+
+            return (!missingFiles.Any(), missingFiles);
+        }
+
+        /// <inheritdoc/>
+#if NET48
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive drive, bool includeArtifacts)
+#else
+        public override void GenerateSubmissionInfo(SubmissionInfo info, Options options, string basePath, Drive? drive, bool includeArtifacts)
+#endif
+        {
+            // Ensure that required sections exist
+            info = SubmissionInfoTool.EnsureAllSections(info);
+
+            // TODO: Determine if there's a UMDImageCreator version anywhere
+#if NET48
+            info.DumpingInfo.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+#else
+            info.DumpingInfo!.DumpingProgram = EnumConverter.LongName(this.InternalProgram);
+#endif
+            info.DumpingInfo.DumpingDate = InfoTool.GetFileModifiedDate(basePath + "_disc.txt")?.ToString("yyyy-MM-dd HH:mm:ss");
+
+            // Extract info based generically on MediaType
+            switch (this.Type)
+            {
+                case MediaType.UMD:
+#if NET48
+                    info.Extras.PVD = GetPVD(basePath + "_mainInfo.txt") ?? string.Empty;
+#else
+                    info.Extras!.PVD = GetPVD(basePath + "_mainInfo.txt") ?? string.Empty;
+#endif
+
+                    if (Hasher.GetFileHashes(basePath + ".iso", out long filesize, out var crc32, out var md5, out var sha1))
+                    {
+#if NET48
+                        info.SizeAndChecksums.Size = filesize;
+#else
+                        info.SizeAndChecksums!.Size = filesize;
+#endif
+                        info.SizeAndChecksums.CRC32 = crc32;
+                        info.SizeAndChecksums.MD5 = md5;
+                        info.SizeAndChecksums.SHA1 = sha1;
+                    }
+
+                    if (GetUMDAuxInfo(basePath + "_disc.txt", out var title, out DiscCategory? umdcat, out var umdversion, out var umdlayer, out long umdsize))
+                    {
+#if NET48
+                        info.CommonDiscInfo.Title = title ?? string.Empty;
+                        info.CommonDiscInfo.Category = umdcat ?? DiscCategory.Games;
+                        info.VersionAndEditions.Version = umdversion ?? string.Empty;
+                        info.SizeAndChecksums.Size = umdsize;
+#else
+                        info.CommonDiscInfo!.Title = title ?? string.Empty;
+                        info.CommonDiscInfo.Category = umdcat ?? DiscCategory.Games;
+                        info.VersionAndEditions!.Version = umdversion ?? string.Empty;
+                        info.SizeAndChecksums!.Size = umdsize;
+#endif
+
+                        if (!string.IsNullOrWhiteSpace(umdlayer))
+                            info.SizeAndChecksums.Layerbreak = Int64.Parse(umdlayer ?? "-1");
+                    }
+
+                    break;
+            }
+
+            // Fill in any artifacts that exist, Base64-encoded, if we need to
+            if (includeArtifacts)
+            {
+#if NET48
+                if (info.Artifacts == null) info.Artifacts = new Dictionary<string, string>();
+#else
+                info.Artifacts ??= new Dictionary<string, string>();
+#endif
+
+                if (File.Exists(basePath + "_disc.txt"))
+                    info.Artifacts["disc"] = GetBase64(GetFullFile(basePath + "_disc.txt")) ?? string.Empty;
+                if (File.Exists(basePath + "_drive.txt"))
+                    info.Artifacts["drive"] = GetBase64(GetFullFile(basePath + "_drive.txt")) ?? string.Empty;
+                if (File.Exists(basePath + "_mainError.txt"))
+                    info.Artifacts["mainError"] = GetBase64(GetFullFile(basePath + "_mainError.txt")) ?? string.Empty;
+                if (File.Exists(basePath + "_mainInfo.txt"))
+                    info.Artifacts["mainInfo"] = GetBase64(GetFullFile(basePath + "_mainInfo.txt")) ?? string.Empty;
+                if (File.Exists(basePath + "_volDesc.txt"))
+                    info.Artifacts["volDesc"] = GetBase64(GetFullFile(basePath + "_volDesc.txt")) ?? string.Empty;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override List<string> GetLogFilePaths(string basePath)
+        {
+            var logFiles = new List<string>();
+            switch (this.Type)
+            {
+                case MediaType.UMD:
+                    if (File.Exists($"{basePath}_disc.txt"))
+                        logFiles.Add($"{basePath}_disc.txt");
+                    if (File.Exists($"{basePath}_drive.txt"))
+                        logFiles.Add($"{basePath}_drive.txt");
+                    if (File.Exists($"{basePath}_mainError.txt"))
+                        logFiles.Add($"{basePath}_mainError.txt");
+                    if (File.Exists($"{basePath}_mainInfo.txt"))
+                        logFiles.Add($"{basePath}_mainInfo.txt");
+                    if (File.Exists($"{basePath}_volDesc.txt"))
+                        logFiles.Add($"{basePath}_volDesc.txt");
+
+                    break;
+            }
+
+            return logFiles;
+        }
+
+        #endregion
+
+        #region Information Extraction Methods
+
+        /// <summary>
+        /// Get the PVD from the input file, if possible
+        /// </summary>
+        /// <param name="mainInfo">_mainInfo.txt file location</param>
+        /// <returns>Newline-deliminated PVD if possible, null on error</returns>
+#if NET48
+        private static string GetPVD(string mainInfo)
+#else
+        private static string? GetPVD(string mainInfo)
+#endif
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(mainInfo))
+                return null;
+
+            using (var sr = File.OpenText(mainInfo))
+            {
+                try
+                {
+                    // Make sure we're in the right sector
+                    while (sr.ReadLine()?.StartsWith("========== LBA[000016, 0x0000010]: Main Channel ==========") == false) ;
+
+                    // Fast forward to the PVD
+                    while (sr.ReadLine()?.StartsWith("0310") == false) ;
+
+                    // Now that we're at the PVD, read each line in and concatenate
+                    string pvd = "";
+                    for (int i = 0; i < 6; i++)
+                        pvd += sr.ReadLine() + "\n"; // 320-370
+
+                    return pvd;
+                }
+                catch
+                {
+                    // We don't care what the exception is right now
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the UMD auxiliary info from the outputted files, if possible
+        /// </summary>
+        /// <param name="disc">_disc.txt file location</param>
+        /// <returns>True on successful extraction of info, false otherwise</returns>
+#if NET48
+        private static bool GetUMDAuxInfo(string disc, out string title, out DiscCategory? umdcat, out string umdversion, out string umdlayer, out long umdsize)
+#else
+        private static bool GetUMDAuxInfo(string disc, out string? title, out DiscCategory? umdcat, out string? umdversion, out string? umdlayer, out long umdsize)
+#endif
+        {
+            title = null; umdcat = null; umdversion = null; umdlayer = null; umdsize = -1;
+
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(disc))
+                return false;
+
+            using (var sr = File.OpenText(disc))
+            {
+                try
+                {
+                    // Loop through everything to get the first instance of each required field
+                    var line = string.Empty;
+                    while (!sr.EndOfStream)
+                    {
+                        line = sr.ReadLine()?.Trim();
+                        if (line == null)
+                            break;
+
+                        if (line.StartsWith("TITLE") && title == null)
+#if NET48
+                            title = line.Substring("TITLE: ".Length);
+#else
+                            title = line["TITLE: ".Length..];
+#endif
+                        else if (line.StartsWith("DISC_VERSION") && umdversion == null)
+                            umdversion = line.Split(' ')[1];
+                        else if (line.StartsWith("pspUmdTypes"))
+                            umdcat = InfoTool.GetUMDCategory(line.Split(' ')[1]);
+                        else if (line.StartsWith("L0 length"))
+                            umdlayer = line.Split(' ')[2];
+                        else if (line.StartsWith("FileSize:"))
+                            umdsize = Int64.Parse(line.Split(' ')[1]);
+                    }
+
+                    // If the L0 length is the size of the full disc, there's no layerbreak
+                    if (Int64.TryParse(umdlayer, out long umdlayerValue) && umdlayerValue * 2048 == umdsize)
+                        umdlayer = null;
+
+                    return true;
+                }
+                catch
+                {
+                    // We don't care what the exception is right now
+                    return false;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

MPF.Core/Protection.cs

@@ -0,0 +1,343 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using BinaryObjectScanner.Protection;
+using psxt001z;
+
+namespace MPF.Core
+{
+    public static class Protection
+    {
+        /// <summary>
+        /// Run protection scan on a given path
+        /// </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>Set of all detected copy protections with an optional error string</returns>
+#if NET48
+        public static async Task<(Dictionary<string, List<string>>, string)> RunProtectionScanOnPath(string path, Data.Options options, IProgress<ProtectionProgress> progress = null)
+#else
+        public static async Task<(Dictionary<string, List<string>>?, string?)> RunProtectionScanOnPath(string path, Data.Options options, IProgress<ProtectionProgress>? progress = null)
+#endif
+        {
+            try
+            {
+                var found = await Task.Run(() =>
+                {
+                    var scanner = new Scanner(
+                        options.ScanArchivesForProtection,
+                        scanContents: true, // Hardcoded value to avoid issues
+                        scanGameEngines: false, // Hardcoded value to avoid issues
+                        options.ScanPackersForProtection,
+                        scanPaths: true, // Hardcoded value to avoid issues
+                        options.IncludeDebugProtectionInformation,
+                        progress);
+
+                    return scanner.GetProtections(path);
+                });
+
+                // If nothing was returned, return
+                if (found == null || !found.Any())
+                    return (null, null);
+
+                // Filter out any empty protections
+                var filteredProtections = found
+                    .Where(kvp => kvp.Value != null && kvp.Value.Any())
+                    .ToDictionary(
+                        kvp => kvp.Key,
+                        kvp => kvp.Value.OrderBy(s => s).ToList());
+
+                // Return the filtered set of protections
+                return (filteredProtections, null);
+            }
+            catch (Exception ex)
+            {
+                return (null, ex.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Format found protections to a deduplicated, ordered string
+        /// </summary>
+        /// <param name="protections">Dictionary of file to list of protection mappings</param>
+        /// <returns>Detected protections, if any</returns>
+#if NET48
+        public static string FormatProtections(Dictionary<string, List<string>> protections)
+#else
+        public static string? FormatProtections(Dictionary<string, List<string>>? protections)
+#endif
+        {
+            // If the filtered list is empty in some way, return
+            if (protections == null || !protections.Any())
+                return "None found [OMIT FROM SUBMISSION]";
+
+            // Get an ordered list of distinct found protections
+            var orderedDistinctProtections = protections
+                .SelectMany(kvp => kvp.Value)
+                .Distinct()
+                .OrderBy(p => p);
+
+            // Sanitize and join protections for writing
+            string protectionString = SanitizeFoundProtections(orderedDistinctProtections);
+            if (string.IsNullOrWhiteSpace(protectionString))
+                return "None found [OMIT FROM SUBMISSION]";
+
+            return protectionString;
+        }
+
+        /// <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>
+#if NET48
+        public static async Task<bool> GetPlayStationAntiModchipDetected(string path)
+#else
+        public static async Task<bool> GetPlayStationAntiModchipDetected(string? path)
+#endif
+        {
+            // If there is no valid path
+            if (string.IsNullOrEmpty(path))
+                return false;
+
+            return await Task.Run(() =>
+            {
+                try
+                {
+                    var antiModchip = new PSXAntiModchip();
+                    foreach (string file in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories))
+                    {
+                        try
+                        {
+                            byte[] fileContent = File.ReadAllBytes(file);
+                            var protection = antiModchip.CheckContents(file, fileContent, false);
+                            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)
+        {
+            // EXCEPTIONS
+            if (foundProtections.Any(p => p.StartsWith("[Exception opening file")))
+            {
+                foundProtections = foundProtections.Where(p => !p.StartsWith("[Exception opening file"));
+                foundProtections = foundProtections
+                    .Prepend("Exception occurred while scanning [RESCAN NEEDED]")
+                    .OrderBy(p => p);
+            }
+
+            // 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} .+", RegexOptions.Compiled)) && 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}", RegexOptions.Compiled)))
+                {
+                    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
+
+            // Cactus Data Shield / SafeDisc
+            if (foundProtections.Any(p => p == "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)"))
+            {
+                foundProtections = foundProtections
+                    .Where(p => p != "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)");
+
+                if (foundProtections.Any(p => !p.StartsWith("SafeDisc")))
+                    foundProtections = foundProtections.Append("Cactus Data Shield 300");
+            }
+
+            // SafeDisc
+            if (foundProtections.Any(p => p.StartsWith("SafeDisc")))
+            {
+                if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 2+");
+                }
+                else if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => !(Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 2+");
+                }
+                else if (foundProtections.Any(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}/+", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => !p.StartsWith("Macrovision Security Driver"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 2+");
+                }
+                else if (foundProtections.Any(p => p.StartsWith("Macrovision Security Driver")))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => p != "SafeDisc")
+                        .Where(p => p != "SafeDisc 1/Lite")
+                        .Where(p => p != "SafeDisc 2+");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 2+"))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .Where(p => p != "SafeDisc");
+                }
+                else if (foundProtections.Any(p => p == "SafeDisc 1/Lite"))
+                {
+                    foundProtections = foundProtections.Where(p => !p.StartsWith("Macrovision Protected Application"))
+                        .Where(p => !p.StartsWith("Macrovision Protection File"))
+                        .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]+\..+", RegexOptions.Compiled)))
+                {
+                    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.Core/UI/ComboBoxItems/Element.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core.Converters;
+
+namespace MPF.Core.UI.ComboBoxItems
+{
+    /// <summary>
+    /// A generic combo box element
+    /// </summary>
+    /// <typeparam name="T">Enum type representing the possible values</typeparam>
+    public class Element<T> : IEquatable<Element<T>>, IElement where T : struct, Enum
+    {
+        private readonly T Data;
+
+        public Element(T data) => Data = data;
+
+        /// <summary>
+        /// Allow elements to be used as their internal enum type
+        /// </summary>
+        /// <param name="item"></param>
+        public static implicit operator T? (Element<T> item) => item?.Data;
+
+        /// <inheritdoc/>
+        public string Name => EnumConverter.GetLongName(Data);
+
+        public override string ToString() => Name;
+
+        /// <summary>
+        /// Internal enum value
+        /// </summary>
+        public T Value => Data;
+
+        /// <summary>
+        /// Determine if the item is selected or not
+        /// </summary>
+        /// <remarks>Only applies to CheckBox type</remarks>
+        public bool IsChecked { get; set; }
+
+        /// <summary>
+        /// Generate all elements associated with the data enum type
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<Element<T>> GenerateElements()
+        {
+            return Enum.GetValues(typeof(T))
+                .OfType<T>()
+                .Select(e => new Element<T>(e));
+        }
+
+        /// <inheritdoc/>
+#if NET48
+        public bool Equals(Element<T> other)
+#else
+        public bool Equals(Element<T>? other)
+#endif
+        {
+            if (other == null)
+                return false;
+
+            return Name == other.Name;
+        }
+    }
+}

MPF.Core/UI/ComboBoxItems/IElement.cs

@@ -0,0 +1,10 @@
+namespace MPF.Core.UI.ComboBoxItems
+{
+    public interface IElement
+    {
+        /// <summary>
+        /// Display name for the combo box element
+        /// </summary>
+        string Name { get; }
+    }
+}

MPF.Core/UI/ComboBoxItems/RedumpSystemComboBoxItem.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.UI.ComboBoxItems
+{
+    /// <summary>
+    /// Represents a single item in the System combo box
+    /// </summary>
+    public class RedumpSystemComboBoxItem : IEquatable<RedumpSystemComboBoxItem>, IElement
+    {
+#if NET48
+        private readonly object Data;
+#else
+        private readonly object? Data;
+#endif
+
+        public RedumpSystemComboBoxItem(RedumpSystem? system) => Data = system;
+        public RedumpSystemComboBoxItem(SystemCategory? category) => Data = category;
+
+        public static implicit operator RedumpSystem?(RedumpSystemComboBoxItem item) => item.Data as RedumpSystem?;
+
+        /// <inheritdoc/>
+        public string Name
+        {
+            get
+            {
+                if (IsHeader)
+                    return "---------- " + (Data as SystemCategory?).LongName() + " ----------";
+                else
+                    return (Data as RedumpSystem?).LongName() ?? "No system selected";
+            }
+        }
+
+        public override string ToString() => Name;
+
+        /// <summary>
+        /// Internal enum value
+        /// </summary>
+        public RedumpSystem? Value => Data as RedumpSystem?;
+
+        /// <summary>
+        /// Determines if the item is a header value
+        /// </summary>
+        public bool IsHeader => Data is SystemCategory?;
+
+        /// <summary>
+        /// Determines if the item is a standard system value
+        /// </summary>
+        public bool IsSystem => Data is RedumpSystem?;
+
+        /// <summary>
+        /// Generate all elements for the known system combo box
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<RedumpSystemComboBoxItem> GenerateElements()
+        {
+            var knownSystems = Enum.GetValues(typeof(RedumpSystem))
+                .OfType<RedumpSystem?>()
+                .Where(s => !s.IsMarker() && s.GetCategory() != SystemCategory.NONE)
+                .ToList();
+
+            Dictionary<SystemCategory, List<RedumpSystem?>> mapping = knownSystems
+                .GroupBy(s => s.GetCategory())
+                .ToDictionary(
+                    k => k.Key,
+                    v => v
+                        .OrderBy(s => s.LongName())
+                        .ToList()
+                );
+
+            var systemsValues = new List<RedumpSystemComboBoxItem>
+            {
+                new RedumpSystemComboBoxItem((RedumpSystem?)null),
+            };
+
+            foreach (var group in mapping)
+            {
+                systemsValues.Add(new RedumpSystemComboBoxItem(group.Key));
+                group.Value.ForEach(system => systemsValues.Add(new RedumpSystemComboBoxItem(system)));
+            }
+
+            return systemsValues;
+        }
+
+        /// <inheritdoc/>
+#if NET48
+        public bool Equals(RedumpSystemComboBoxItem other)
+#else
+        public bool Equals(RedumpSystemComboBoxItem? other)
+#endif
+        {
+            if (other == null)
+                return false;
+
+            return Value == other.Value;
+        }
+    }
+}

MPF.Core/UI/ViewModels/DiscInformationViewModel.cs

@@ -0,0 +1,257 @@
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.UI.ViewModels
+{
+    public class DiscInformationViewModel
+    {
+        #region Fields
+
+        /// <summary>
+        /// Application-level Options object
+        /// </summary>
+        public Options Options { get; private set; }
+
+        /// <summary>
+        /// SubmissionInfo object to fill and save
+        /// </summary>
+        public SubmissionInfo SubmissionInfo { get; private set; }
+
+        #endregion
+
+        #region Lists
+
+        /// <summary>
+        /// List of available disc categories
+        /// </summary>
+        public List<Element<DiscCategory>> Categories { get; private set; } = Element<DiscCategory>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of available regions
+        /// </summary>
+        public List<Element<Region>> Regions { get; private set; } = Element<Region>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of Redump-supported Regions
+        /// </summary>
+#if NET48
+        private static readonly List<Region> RedumpRegions = new List<Region>
+#else
+        private static readonly List<Region> RedumpRegions = new()
+#endif
+        {
+            Region.Argentina,
+            Region.Asia,
+            Region.AsiaEurope,
+            Region.AsiaUSA,
+            Region.Australia,
+            Region.AustraliaGermany,
+            Region.AustraliaNewZealand,
+            Region.Austria,
+            Region.AustriaSwitzerland,
+            Region.Belarus,
+            Region.Belgium,
+            Region.BelgiumNetherlands,
+            Region.Brazil,
+            Region.Bulgaria,
+            Region.Canada,
+            Region.China,
+            Region.Croatia,
+            Region.Czechia,
+            Region.Denmark,
+            Region.Estonia,
+            Region.Europe,
+            Region.EuropeAsia,
+            Region.EuropeAustralia,
+            Region.EuropeCanada,
+            Region.EuropeGermany,
+            Region.Export,
+            Region.Finland,
+            Region.France,
+            Region.FranceSpain,
+            Region.Germany,
+            Region.GreaterChina,
+            Region.Greece,
+            Region.Hungary,
+            Region.Iceland,
+            Region.India,
+            Region.Ireland,
+            Region.Israel,
+            Region.Italy,
+            Region.Japan,
+            Region.JapanAsia,
+            Region.JapanEurope,
+            Region.JapanKorea,
+            Region.JapanUSA,
+            Region.SouthKorea,
+            Region.LatinAmerica,
+            Region.Lithuania,
+            Region.Netherlands,
+            Region.NewZealand,
+            Region.Norway,
+            Region.Poland,
+            Region.Portugal,
+            Region.Romania,
+            Region.RussianFederation,
+            Region.Scandinavia,
+            Region.Serbia,
+            Region.Singapore,
+            Region.Slovakia,
+            Region.SouthAfrica,
+            Region.Spain,
+            Region.SpainPortugal,
+            Region.Sweden,
+            Region.Switzerland,
+            Region.Taiwan,
+            Region.Thailand,
+            Region.Turkey,
+            Region.UnitedArabEmirates,
+            Region.UnitedKingdom,
+            Region.UKAustralia,
+            Region.Ukraine,
+            Region.UnitedStatesOfAmerica,
+            Region.USAAsia,
+            Region.USAAustralia,
+            Region.USABrazil,
+            Region.USACanada,
+            Region.USAEurope,
+            Region.USAGermany,
+            Region.USAJapan,
+            Region.USAKorea,
+            Region.World,
+        };
+
+        /// <summary>
+        /// List of available languages
+        /// </summary>
+        public List<Element<Language>> Languages { get; private set; } = Element<Language>.GenerateElements().ToList();
+
+        /// <summary>
+        /// List of Redump-supported Languages
+        /// </summary>
+#if NET48
+        private static readonly List<Language> RedumpLanguages = new List<Language>
+#else
+        private static readonly List<Language> RedumpLanguages = new()
+#endif
+        {
+            Language.Afrikaans,
+            Language.Albanian,
+            Language.Arabic,
+            Language.Armenian,
+            Language.Basque,
+            Language.Belarusian,
+            Language.Bulgarian,
+            Language.Catalan,
+            Language.Chinese,
+            Language.Croatian,
+            Language.Czech,
+            Language.Danish,
+            Language.Dutch,
+            Language.English,
+            Language.Estonian,
+            Language.Finnish,
+            Language.French,
+            Language.Gaelic,
+            Language.German,
+            Language.Greek,
+            Language.Hebrew,
+            Language.Hindi,
+            Language.Hungarian,
+            Language.Icelandic,
+            Language.Indonesian,
+            Language.Italian,
+            Language.Japanese,
+            Language.Korean,
+            Language.Latin,
+            Language.Latvian,
+            Language.Lithuanian,
+            Language.Macedonian,
+            Language.Norwegian,
+            Language.Polish,
+            Language.Portuguese,
+            Language.Panjabi,
+            Language.Romanian,
+            Language.Russian,
+            Language.Serbian,
+            Language.Slovak,
+            Language.Slovenian,
+            Language.Spanish,
+            Language.Swedish,
+            Language.Tamil,
+            Language.Thai,
+            Language.Turkish,
+            Language.Ukrainian,
+            Language.Vietnamese,
+        };
+
+        /// <summary>
+        /// List of available languages
+        /// </summary>
+        public List<Element<LanguageSelection>> LanguageSelections { get; private set; } = Element<LanguageSelection>.GenerateElements().ToList();
+
+        #endregion
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+#if NET48
+        public DiscInformationViewModel(Options options, SubmissionInfo submissionInfo)
+#else
+        public DiscInformationViewModel(Options options, SubmissionInfo? submissionInfo)
+#endif
+        {
+            Options = options;
+            SubmissionInfo = submissionInfo?.Clone() as SubmissionInfo ?? new SubmissionInfo();
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Load the current contents of the base SubmissionInfo to the UI
+        /// </summary>
+        /// TODO: Convert selected list item to binding
+        public void Load()
+        {
+            if (SubmissionInfo.CommonDiscInfo?.Languages != null)
+                Languages.ForEach(l => l.IsChecked = SubmissionInfo.CommonDiscInfo.Languages.Contains(l));
+            if (SubmissionInfo.CommonDiscInfo?.LanguageSelection != null)
+                LanguageSelections.ForEach(ls => ls.IsChecked = SubmissionInfo.CommonDiscInfo.LanguageSelection.Contains(ls));
+        }
+
+        /// <summary>
+        /// Save the current contents of the UI to the base SubmissionInfo
+        /// </summary>
+        /// TODO: Convert selected list item to binding
+        public void Save()
+        {
+            if (SubmissionInfo.CommonDiscInfo == null) SubmissionInfo.CommonDiscInfo = new CommonDiscInfoSection();
+            SubmissionInfo.CommonDiscInfo.Languages = Languages.Where(l => l.IsChecked).Select(l => l?.Value).ToArray();
+            if (!SubmissionInfo.CommonDiscInfo.Languages.Any())
+                SubmissionInfo.CommonDiscInfo.Languages = new Language?[] { null };
+            SubmissionInfo.CommonDiscInfo.LanguageSelection = LanguageSelections.Where(ls => ls.IsChecked).Select(ls => ls?.Value).ToArray();
+        }
+
+        /// <summary>
+        /// Repopulate the list of Languages based on Redump support
+        /// </summary>
+        public void SetRedumpLanguages()
+        {
+            this.Languages = RedumpLanguages.Select(l => new Element<Language>(l)).ToList();
+        }
+
+        /// <summary>
+        /// Repopulate the list of Regions based on Redump support
+        /// </summary>
+        public void SetRedumpRegions()
+        {
+            this.Regions = RedumpRegions.Select(r => new Element<Region>(r)).ToList();
+        }
+
+        #endregion
+    }
+}

MPF.Core/UI/ViewModels/OptionsViewModel.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Threading.Tasks;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Core.UI.ViewModels
+{
+    public class OptionsViewModel : INotifyPropertyChanged
+    {
+        #region Fields
+
+        /// <summary>
+        /// Title for the window
+        /// </summary>
+#if NET48
+        public string Title
+#else
+        public string? Title
+#endif
+        {
+            get => _title;
+            set
+            {
+                _title = value;
+                TriggerPropertyChanged(nameof(Title));
+            }
+        }
+#if NET48
+        private string _title;
+#else
+        private string? _title;
+#endif
+
+        /// <summary>
+        /// Current set of options
+        /// </summary>
+        public Options Options { get; }
+
+        /// <summary>
+        /// Flag for if settings were saved or not
+        /// </summary>
+        public bool SavedSettings { get; set; }
+
+        /// <inheritdoc/>
+#if NET48
+        public event PropertyChangedEventHandler PropertyChanged;
+#else
+        public event PropertyChangedEventHandler? PropertyChanged;
+#endif
+
+#endregion
+
+        #region Lists
+
+        /// <summary>
+        /// List of available internal programs
+        /// </summary>
+        public List<Element<InternalProgram>> InternalPrograms => PopulateInternalPrograms();
+
+        /// <summary>
+        /// Current list of supported system profiles
+        /// </summary>
+        public List<RedumpSystemComboBoxItem> Systems => RedumpSystemComboBoxItem.GenerateElements().ToList();
+
+        #endregion
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public OptionsViewModel(Options baseOptions)
+        {
+            Options = new Options(baseOptions);
+        }
+
+        #region Population
+
+        /// <summary>
+        /// Get a complete list of  supported internal programs
+        /// </summary>
+        private static List<Element<InternalProgram>> PopulateInternalPrograms()
+        {
+            var internalPrograms = new List<InternalProgram> { InternalProgram.DiscImageCreator, InternalProgram.Aaru, InternalProgram.Redumper };
+            return internalPrograms.Select(ip => new Element<InternalProgram>(ip)).ToList();
+        }
+
+        #endregion
+
+        #region UI Commands
+
+        /// <summary>
+        /// Test Redump login credentials
+        /// </summary>
+#if NET48
+        public (bool?, string) TestRedumpLogin(string username, string password)
+#else
+        public async Task<(bool?, string?)> TestRedumpLogin(string username, string password)
+#endif
+        {
+#if NET48
+            return RedumpWebClient.ValidateCredentials(username, password);
+#else
+            return await RedumpHttpClient.ValidateCredentials(username, password);
+#endif
+        }
+
+        #endregion
+
+        #region Property Updates
+
+        /// <summary>
+        /// Trigger a property changed event
+        /// </summary>
+        private void TriggerPropertyChanged(string propertyName)
+        {
+            // If the property change event is initialized
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        #endregion
+    }
+}

MPF.Core/Utilities/BinaryReaderExtensions.cs

@@ -0,0 +1,174 @@
+using System;
+using System.IO;
+
+namespace MPF.Core.Utilities
+{
+    /// <summary>
+    /// Big endian reading overloads for BinaryReader
+    /// </summary>
+    public static class BinaryReaderExtensions
+    {
+        /// <summary>
+        /// Reads the specified number of bytes from the stream, starting from a specified point in the byte array.
+        /// </summary>
+        /// <param name="buffer">The buffer to read data into.</param>
+        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
+        /// <param name="count">The number of bytes to read.</param>
+        /// <returns>The number of bytes read into buffer. This might be less than the number of bytes requested if that many bytes are not available, or it might be zero if the end of the stream is reached.</returns>
+        public static int ReadBigEndian(this BinaryReader reader, byte[] buffer, int index, int count)
+        {
+            int retval = reader.Read(buffer, index, count);
+            Array.Reverse(buffer);
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads the specified number of characters from the stream, starting from a specified point in the character array.
+        /// </summary>
+        /// <param name="buffer">The buffer to read data into.</param>
+        /// <param name="index">The starting point in the buffer at which to begin reading into the buffer.</param>
+        /// <param name="count">The number of characters to read.</param>
+        /// <returns>The total number of characters read into the buffer. This might be less than the number of characters requested if that many characters are not currently available, or it might be zero if the end of the stream is reached.</returns>
+        public static int ReadBigEndian(this BinaryReader reader, char[] buffer, int index, int count)
+        {
+            int retval = reader.Read(buffer, index, count);
+            Array.Reverse(buffer);
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads the specified number of bytes from the current stream into a byte array and advances the current position by that number of bytes.
+        /// </summary>
+        /// <param name="count">The number of bytes to read. This value must be 0 or a non-negative number or an exception will occur.</param>
+        /// <returns>A byte array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
+        public static byte[] ReadBytesBigEndian(this BinaryReader reader, int count)
+        {
+            byte[] retval = reader.ReadBytes(count);
+            Array.Reverse(retval);
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads the specified number of characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream.
+        /// </summary>
+        /// <param name="count">The number of characters to read. This value must be 0 or a non-negative number or an exception will occur.</param>
+        /// <returns>A character array containing data read from the underlying stream. This might be less than the number of bytes requested if the end of the stream is reached.</returns>
+        public static char[] ReadCharsBigEndian(this BinaryReader reader, int count)
+        {
+            char[] retval = reader.ReadChars(count);
+            Array.Reverse(retval);
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes.
+        /// </summary>
+        /// <returns>A decimal value read from the current stream.</returns>
+        public static decimal ReadDecimalBigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(16);
+            Array.Reverse(retval);
+
+            int i1 = BitConverter.ToInt32(retval, 0);
+            int i2 = BitConverter.ToInt32(retval, 4);
+            int i3 = BitConverter.ToInt32(retval, 8);
+            int i4 = BitConverter.ToInt32(retval, 12);
+
+            return new decimal(new int[] { i1, i2, i3, i4 });
+        }
+
+        /// <summary>
+        /// eads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes.
+        /// </summary>
+        /// <returns>An 8-byte floating point value read from the current stream.</returns>
+        public static double ReadDoubleBigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(8);
+            Array.Reverse(retval);
+            return BitConverter.ToDouble(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes.
+        /// </summary>
+        /// <returns>A 2-byte signed integer read from the current stream.</returns>
+        public static short ReadInt16BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(2);
+            Array.Reverse(retval);
+            return BitConverter.ToInt16(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes.
+        /// </summary>
+        /// <returns>A 4-byte signed integer read from the current stream.</returns>
+        public static int ReadInt32BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(4);
+            Array.Reverse(retval);
+            return BitConverter.ToInt32(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes.
+        /// </summary>
+        /// <returns>An 8-byte signed integer read from the current stream.</returns>
+        public static long ReadInt64BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(8);
+            Array.Reverse(retval);
+            return BitConverter.ToInt64(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes.
+        /// </summary>
+        /// <returns>A 4-byte floating point value read from the current stream.</returns>
+        public static float ReadSingleBigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(4);
+            Array.Reverse(retval);
+            return BitConverter.ToSingle(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads a 2-byte unsigned integer from the current stream using little-endian encoding and advances the position of the stream by two bytes.
+        /// 
+        /// This API is not CLS-compliant.
+        /// </summary>
+        /// <returns>A 2-byte unsigned integer read from this stream.</returns>
+        public static ushort ReadUInt16BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(2);
+            Array.Reverse(retval);
+            return BitConverter.ToUInt16(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads a 4-byte unsigned integer from the current stream and advances the position of the stream by four bytes.
+        /// 
+        /// This API is not CLS-compliant.
+        /// </summary>
+        /// <returns>A 4-byte unsigned integer read from this stream.</returns>
+        public static uint ReadUInt32BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(4);
+            Array.Reverse(retval);
+            return BitConverter.ToUInt32(retval, 0);
+        }
+
+        /// <summary>
+        /// Reads an 8-byte unsigned integer from the current stream and advances the position of the stream by eight bytes.
+        /// 
+        /// This API is not CLS-compliant.
+        /// </summary>
+        /// <returns>An 8-byte unsigned integer read from this stream.</returns>
+        public static ulong ReadUInt64BigEndian(this BinaryReader reader)
+        {
+            byte[] retval = reader.ReadBytes(8);
+            Array.Reverse(retval);
+            return BitConverter.ToUInt64(retval, 0);
+        }
+    }
+}

MPF.Core/Utilities/Chime.cs

@@ -0,0 +1,400 @@
+#if FALSE
+
+using System;
+
+namespace MPF.Core.Utilities
+{
+    /// <summary>
+    /// Methods to deal with outputting tones to the PC speaker
+    /// </summary>
+    public class Chime
+    {
+        /// <summary>
+        /// Standard duration to play a single tone
+        /// </summary>
+        private const int standardDurationMs = 200;
+
+        #region Octave 0
+
+        /// <summary>
+        /// Frequency representing C(0)
+        /// </summary>
+        private const int noteC0 = 16; // 16.35
+
+        /// <summary>
+        /// Frequency representing D(0)
+        /// </summary>
+        private const int noteD0 = 18; // 18.35
+
+        /// <summary>
+        /// Frequency representing E(0)
+        /// </summary>
+        private const int noteE0 = 21; // 20.60
+
+        /// <summary>
+        /// Frequency representing F(0)
+        /// </summary>
+        private const int noteF0 = 22; // 21.83
+
+        /// <summary>
+        /// Frequency representing G(0)
+        /// </summary>
+        private const int noteG0 = 25; // 24.50
+
+        /// <summary>
+        /// Frequency representing A(0)
+        /// </summary>
+        private const int noteA0 = 28; // 27.50
+
+        /// <summary>
+        /// Frequency representing B(0)
+        /// </summary>
+        private const int noteB0 = 31; // 30.87
+
+        #endregion
+
+        #region Octave 1
+
+        /// <summary>
+        /// Frequency representing C(1)
+        /// </summary>
+        private const int noteC1 = 33; // 32.70
+
+        /// <summary>
+        /// Frequency representing D(1)
+        /// </summary>
+        private const int noteD1 = 37; // 36.71
+
+        /// <summary>
+        /// Frequency representing E(1)
+        /// </summary>
+        private const int noteE1 = 41; // 41.20
+
+        /// <summary>
+        /// Frequency representing F(1)
+        /// </summary>
+        private const int noteF1 = 44; // 43.65
+
+        /// <summary>
+        /// Frequency representing G(1)
+        /// </summary>
+        private const int noteG1 = 49; // 49.00
+
+        /// <summary>
+        /// Frequency representing A(1)
+        /// </summary>
+        private const int noteA1 = 55; // 55.00
+
+        /// <summary>
+        /// Frequency representing B(1)
+        /// </summary>
+        private const int noteB1 = 62; // 61.74
+
+        #endregion
+
+        #region Octave 2
+
+        /// <summary>
+        /// Frequency representing C(2)
+        /// </summary>
+        private const int noteC2 = 65; // 65.41
+
+        /// <summary>
+        /// Frequency representing D(2)
+        /// </summary>
+        private const int noteD2 = 73; // 73.42
+
+        /// <summary>
+        /// Frequency representing E(2)
+        /// </summary>
+        private const int noteE2 = 82; // 82.41
+
+        /// <summary>
+        /// Frequency representing F(2)
+        /// </summary>
+        private const int noteF2 = 87; // 87.31
+
+        /// <summary>
+        /// Frequency representing G(2)
+        /// </summary>
+        private const int noteG2 = 98; // 98.00
+
+        /// <summary>
+        /// Frequency representing A(2)
+        /// </summary>
+        private const int noteA2 = 110; // 110.00
+
+        /// <summary>
+        /// Frequency representing B(2)
+        /// </summary>
+        private const int noteB2 = 123; // 123.47
+
+        #endregion
+
+        #region Octave 3
+
+        /// <summary>
+        /// Frequency representing C(3)
+        /// </summary>
+        private const int noteC3 = 131; // 130.81
+
+        /// <summary>
+        /// Frequency representing D(3)
+        /// </summary>
+        private const int noteD3 = 147; // 146.83
+
+        /// <summary>
+        /// Frequency representing E(3)
+        /// </summary>
+        private const int noteE3 = 165; // 164.81
+
+        /// <summary>
+        /// Frequency representing F(3)
+        /// </summary>
+        private const int noteF3 = 175; // 174.61
+
+        /// <summary>
+        /// Frequency representing G(3)
+        /// </summary>
+        private const int noteG3 = 196; // 196.00
+
+        /// <summary>
+        /// Frequency representing A(3)
+        /// </summary>
+        private const int noteA3 = 220; // 220.00
+
+        /// <summary>
+        /// Frequency representing B(3)
+        /// </summary>
+        private const int noteB3 = 247; // 246.94
+
+        #endregion
+
+        #region Octave 4
+
+        /// <summary>
+        /// Frequency representing C(4)
+        /// </summary>
+        private const int noteC4 = 262; // 261.63
+
+        /// <summary>
+        /// Frequency representing D(4)
+        /// </summary>
+        private const int noteD4 = 294; // 293.66
+
+        /// <summary>
+        /// Frequency representing E(4)
+        /// </summary>
+        private const int noteE4 = 330; // 329.63
+
+        /// <summary>
+        /// Frequency representing F(4)
+        /// </summary>
+        private const int noteF4 = 349; // 349.23
+
+        /// <summary>
+        /// Frequency representing G(4)
+        /// </summary>
+        private const int noteG4 = 392; // 392.00
+
+        /// <summary>
+        /// Frequency representing A(4)
+        /// </summary>
+        private const int noteA4 = 440; // 440.00
+
+        /// <summary>
+        /// Frequency representing B(4)
+        /// </summary>
+        private const int noteB4 = 494; // 493.88
+
+        #endregion
+
+        #region Octave 5
+
+        /// <summary>
+        /// Frequency representing C(5)
+        /// </summary>
+        private const int noteC5 = 523; // 523.25
+
+        /// <summary>
+        /// Frequency representing D(5)
+        /// </summary>
+        private const int noteD5 = 587; // 587.33
+
+        /// <summary>
+        /// Frequency representing E(5)
+        /// </summary>
+        private const int noteE5 = 659; // 659.25
+
+        /// <summary>
+        /// Frequency representing F(5)
+        /// </summary>
+        private const int noteF5 = 698; // 698.46
+
+        /// <summary>
+        /// Frequency representing G(5)
+        /// </summary>
+        private const int noteG5 = 783; // 783.99
+
+        /// <summary>
+        /// Frequency representing A(5)
+        /// </summary>
+        private const int noteA5 = 880; // 880.00
+
+        /// <summary>
+        /// Frequency representing B(5)
+        /// </summary>
+        private const int noteB5 = 988; // 987.77
+
+        #endregion
+
+        #region Octave 6
+
+        /// <summary>
+        /// Frequency representing C(6)
+        /// </summary>
+        private const int noteC6 = 1047; // 1046.50
+
+        /// <summary>
+        /// Frequency representing D(6)
+        /// </summary>
+        private const int noteD6 = 1175; // 1174.66
+
+        /// <summary>
+        /// Frequency representing E(6)
+        /// </summary>
+        private const int noteE6 = 1319; // 1318.51
+
+        /// <summary>
+        /// Frequency representing F(6)
+        /// </summary>
+        private const int noteF6 = 1397; // 1396.91
+
+        /// <summary>
+        /// Frequency representing G(6)
+        /// </summary>
+        private const int noteG6 = 1568; // 1567.98
+
+        /// <summary>
+        /// Frequency representing A(6)
+        /// </summary>
+        private const int noteA6 = 1760; // 1760.00
+
+        /// <summary>
+        /// Frequency representing B(6)
+        /// </summary>
+        private const int noteB6 = 1976; // 1975.53
+
+        #endregion
+
+        #region Octave 7
+
+        /// <summary>
+        /// Frequency representing C(7)
+        /// </summary>
+        private const int noteC7 = 2093; // 2093.00
+
+        /// <summary>
+        /// Frequency representing D(7)
+        /// </summary>
+        private const int noteD7 = 2349; // 2349.32
+
+        /// <summary>
+        /// Frequency representing E(7)
+        /// </summary>
+        private const int noteE7 = 2637; // 2637.02
+
+        /// <summary>
+        /// Frequency representing F(7)
+        /// </summary>
+        private const int noteF7 = 2794; // 2793.83
+
+        /// <summary>
+        /// Frequency representing G(7)
+        /// </summary>
+        private const int noteG7 = 3136; // 3135.96
+
+        /// <summary>
+        /// Frequency representing A(7)
+        /// </summary>
+        private const int noteA7 = 3520; // 3520.00
+
+        /// <summary>
+        /// Frequency representing B(7)
+        /// </summary>
+        private const int noteB7 = 3951; // 3951.07
+
+        #endregion
+
+        #region Octave 8
+
+        /// <summary>
+        /// Frequency representing C(8)
+        /// </summary>
+        private const int noteC8 = 4186; // 4186.01
+
+        /// <summary>
+        /// Frequency representing D(8)
+        /// </summary>
+        private const int noteD8 = 4699; // 4698.63
+
+        /// <summary>
+        /// Frequency representing E(8)
+        /// </summary>
+        private const int noteE8 = 5274; // 5274.04
+
+        /// <summary>
+        /// Frequency representing F(8)
+        /// </summary>
+        private const int noteF8 = 5588; // 5587.65
+
+        /// <summary>
+        /// Frequency representing G(8)
+        /// </summary>
+        private const int noteG8 = 6272; // 6271.93
+
+        /// <summary>
+        /// Frequency representing A(8)
+        /// </summary>
+        private const int noteA8 = 7040; // 7040.00
+
+        /// <summary>
+        /// Frequency representing B(8)
+        /// </summary>
+        private const int noteB8 = 7902; // 7902.13
+
+        #endregion
+
+        /// <summary>
+        /// Output a series of beeps for completion, similar to DiscImageCreator
+        /// </summary>
+        /// <param name="success">True if the upward series should play, false otherwise</param>
+        public static void StandardCompletion(bool success)
+        {
+            if (success)
+            {
+                Console.Beep(noteC4, standardDurationMs);
+                Console.Beep(noteD4, standardDurationMs);
+                Console.Beep(noteE4, standardDurationMs);
+                Console.Beep(noteF4, standardDurationMs);
+                Console.Beep(noteG4, standardDurationMs);
+                Console.Beep(noteA4, standardDurationMs);
+                Console.Beep(noteB4, standardDurationMs);
+                Console.Beep(noteC5, standardDurationMs);
+            }
+            else
+            {
+                Console.Beep(noteC5, standardDurationMs);
+                Console.Beep(noteB4, standardDurationMs);
+                Console.Beep(noteA4, standardDurationMs);
+                Console.Beep(noteG4, standardDurationMs);
+                Console.Beep(noteF4, standardDurationMs);
+                Console.Beep(noteE4, standardDurationMs);
+                Console.Beep(noteD4, standardDurationMs);
+                Console.Beep(noteC4, standardDurationMs);
+            }
+        }
+    }
+}
+
+#endif

MPF.Core/Utilities/EnumExtensions.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using SabreTools.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:
+                case RedumpSystem.SonyPlayStationPortable:
+                    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.HasbroiONEducationalGamingSystem:
+                case RedumpSystem.HasbroVideoNow:
+                case RedumpSystem.HasbroVideoNowColor:
+                case RedumpSystem.HasbroVideoNowJr:
+                case RedumpSystem.HasbroVideoNowXP:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.PlayStationGameSharkUpdates:
+                case RedumpSystem.SuperAudioCD:
+                    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;
+            }
+        }
+
+        /// <summary>
+        /// List all programs with their short usable names
+        /// </summary>
+        public static List<string> ListPrograms()
+        {
+            var programs = new List<string>();
+
+            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
+            {
+                if (((InternalProgram)val) == InternalProgram.NONE)
+                    continue;
+
+                programs.Add($"{((InternalProgram?)val).LongName()}");
+            }
+
+            return programs;
+        }
+    }
+}

MPF.Core/Utilities/Logging.cs

@@ -0,0 +1,133 @@
+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>
+#if NET48
+        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<string> handler)
+#else
+        public static async Task OutputToLog(TextReader reader, object baseClass, EventHandler<string>? handler)
+#endif
+        {
+            // 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>
+#if NET48
+        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+#else
+        private static void ProcessNewLines(StringBuilder sb, string line, object baseClass, EventHandler<string>? handler)
+#endif
+        {
+            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>
+#if NET48
+        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<string> handler)
+#else
+        private static void ProcessCarriageReturns(StringBuilder sb, string line, object baseClass, EventHandler<string>? handler)
+#endif
+        {
+            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/OptionsLoader.cs

@@ -0,0 +1,301 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using MPF.Core.Converters;
+using MPF.Core.Data;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Utilities
+{
+    public static class OptionsLoader
+    {
+        private const string ConfigurationPath = "config.json";
+
+        #region Arguments
+
+        /// <summary>
+        /// Process any standalone arguments for the program
+        /// </summary>
+        /// <returns>True if one of the arguments was processed, false otherwise</returns>
+        public static bool? ProcessStandaloneArguments(string[] args)
+        {
+            // Help options
+            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?")
+                return false;
+
+            // List options
+            if (args[0] == "-lm" || args[0] == "--listmedia")
+            {
+                Console.WriteLine("Supported Media Types:");
+                foreach (string mediaType in Extensions.ListMediaTypes())
+                {
+                    Console.WriteLine(mediaType);
+                }
+                Console.ReadLine();
+                return true;
+            }
+            else if (args[0] == "-lp" || args[0] == "--listprograms")
+            {
+                Console.WriteLine("Supported Programs:");
+                foreach (string program in EnumExtensions.ListPrograms())
+                {
+                    Console.WriteLine(program);
+                }
+                Console.ReadLine();
+                return true;
+            }
+            else if (args[0] == "-ls" || args[0] == "--listsystems")
+            {
+                Console.WriteLine("Supported Systems:");
+                foreach (string system in Extensions.ListSystems())
+                {
+                    Console.WriteLine(system);
+                }
+                Console.ReadLine();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Process common arguments for all functionality
+        /// </summary>
+        /// <returns>True if all arguments pass, false otherwise</returns>
+#if NET48
+        public static (bool, MediaType, RedumpSystem?, string) ProcessCommonArguments(string[] args)
+#else
+        public static (bool, MediaType, RedumpSystem?, string?) ProcessCommonArguments(string[] args)
+#endif
+        {
+            // All other use requires at least 3 arguments
+            if (args.Length < 3)
+                return (false, MediaType.NONE, null, "Invalid number of arguments");
+
+            // Check the MediaType
+            var mediaType = EnumConverter.ToMediaType(args[0].Trim('"'));
+            if (mediaType == MediaType.NONE)
+                return (false, MediaType.NONE, null, $"{args[0]} is not a recognized media type");
+
+            // Check the RedumpSystem
+            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
+            if (knownSystem == null)
+                return (false, MediaType.NONE, null, $"{args[1]} is not a recognized system");
+
+            return (true, mediaType, knownSystem, null);
+        }
+
+        /// <summary>
+        /// Load the current set of options from application arguments
+        /// </summary>
+#if NET48
+        public static (Options, SubmissionInfo, string, int) LoadFromArguments(string[] args, int startIndex = 0)
+#else
+        public static (Options, SubmissionInfo?, string?, int) LoadFromArguments(string[] args, int startIndex = 0)
+#endif
+        {
+            // Create the output values with defaults
+            var options = new Options()
+            {
+                RedumpUsername = null,
+                RedumpPassword = null,
+                InternalProgram = InternalProgram.NONE,
+                AddFilenameSuffix = false,
+                OutputSubmissionJSON = false,
+                CompressLogFiles = false,
+                DeleteUnnecessaryFiles = false,
+            };
+
+            // Create the submission info to return, if necessary
+#if NET48
+            SubmissionInfo info = null;
+            string parsedPath = null;
+#else
+            SubmissionInfo? info = null;
+            string? parsedPath = null;
+#endif
+
+            // These values require multiple parts to be active
+            bool scan = false, protectFile = false;
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+                return (options, null, null, 0);
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return (options, null, null, startIndex);
+
+            // Loop through the arguments and parse out values
+            for (; startIndex < args.Length; startIndex++)
+            {
+                // Use specific program
+                if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    string internalProgram = args[startIndex].Split('=')[1];
+                    options.InternalProgram = EnumConverter.ToInternalProgram(internalProgram);
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = EnumConverter.ToInternalProgram(internalProgram);
+                    startIndex++;
+                }
+
+                // Redump login
+                else if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--credentials="))
+                {
+                    string[] credentials = args[startIndex].Split('=')[1].Split(';');
+                    options.RedumpUsername = credentials[0];
+                    options.RedumpPassword = credentials[1];
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--credentials")
+                {
+                    options.RedumpUsername = args[startIndex + 1];
+                    options.RedumpPassword = args[startIndex + 2];
+                    startIndex += 2;
+                }
+
+                // Pull all information (requires Redump login)
+                else if (args[startIndex].Equals("-a") || args[startIndex].Equals("--pull-all"))
+                {
+                    options.PullAllInformation = true;
+                }
+
+                // Use a device path for physical checks
+                else if (args[startIndex].StartsWith("-p=") || args[startIndex].StartsWith("--path="))
+                {
+                    parsedPath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-p" || args[startIndex] == "--path")
+                {
+                    parsedPath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Scan for protection (requires device path)
+                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
+                {
+                    scan = true;
+                }
+
+                // Output protection to separate file (requires scan for protection)
+                else if (args[startIndex].Equals("-f") || args[startIndex].Equals("--protect-file"))
+                {
+                    protectFile = true;
+                }
+
+                // Include seed info file
+                else if (args[startIndex].StartsWith("-l=") || args[startIndex].StartsWith("--load-seed="))
+                {
+                    string seedInfo = args[startIndex].Split('=')[1];
+                    info = SubmissionInfoTool.CreateFromFile(seedInfo);
+                }
+                else if (args[startIndex] == "-l" || args[startIndex] == "--load-seed")
+                {
+                    string seedInfo = args[startIndex + 1];
+                    info = SubmissionInfoTool.CreateFromFile(seedInfo);
+                    startIndex++;
+                }
+
+                // Add filename suffix
+                else if (args[startIndex].Equals("-x") || args[startIndex].Equals("--suffix"))
+                {
+                    options.AddFilenameSuffix = true;
+                }
+
+                // Output submission JSON
+                else if (args[startIndex].Equals("-j") || args[startIndex].Equals("--json"))
+                {
+                    options.OutputSubmissionJSON = true;
+                }
+
+                // Compress log and extraneous files
+                else if (args[startIndex].Equals("-z") || args[startIndex].Equals("--zip"))
+                {
+                    options.CompressLogFiles = true;
+                }
+
+                // Delete unnecessary files files
+                else if (args[startIndex].Equals("-d") || args[startIndex].Equals("--delete"))
+                {
+                    options.DeleteUnnecessaryFiles = true;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            // Now deal with the complex options
+            options.ScanForProtection = scan && !string.IsNullOrWhiteSpace(parsedPath);
+            options.OutputSeparateProtectionFile = scan && protectFile && !string.IsNullOrWhiteSpace(parsedPath);
+
+            return (options, info, parsedPath, startIndex);
+        }
+
+        /// <summary>
+        /// Return a list of supported arguments and descriptions
+        /// </summary>
+        public static List<string> PrintSupportedArguments()
+        {
+            var supportedArguments = new List<string>
+            {
+                "-u, --use <program>            Dumping program output type [REQUIRED]",
+                "-c, --credentials <user> <pw>  Redump username and password",
+                "-a, --pull-all                 Pull all information from Redump (requires --credentials)",
+                "-p, --path <drivepath>         Physical drive path for additional checks",
+                "-s, --scan                     Enable copy protection scan (requires --path)",
+                "-f, --protect-file             Output protection to separate file (requires --scan)",
+                "-l, --load-seed <path>         Load a seed submission JSON for user information",
+                "-x, --suffix                   Enable adding filename suffix",
+                "-j, --json                     Enable submission JSON output",
+                "-z, --zip                      Enable log file compression",
+                "-d, --delete                   Enable unnecessary file deletion",
+            };
+
+            return supportedArguments;
+        }
+
+#endregion
+
+        #region Configuration
+
+        /// <summary>
+        /// Load the current set of options from the application configuration
+        /// </summary>
+        public static Options LoadFromConfig()
+        {
+            if (!File.Exists(ConfigurationPath))
+            {
+                _ = File.Create(ConfigurationPath);
+                return new Options();
+            }
+
+            var serializer = JsonSerializer.Create();
+            var reader = new StreamReader(ConfigurationPath);
+#if NET48
+            var settings = serializer.Deserialize(reader, typeof(Dictionary<string, string>)) as Dictionary<string, string>;
+#else
+            var settings = serializer.Deserialize(reader, typeof(Dictionary<string, string?>)) as Dictionary<string, string?>;
+#endif
+            return new Options(settings);
+        }
+
+        /// <summary>
+        /// Save the current set of options to the application configuration
+        /// </summary>
+        public static void SaveToConfig(Options options)
+        {
+            var serializer = JsonSerializer.Create();
+            var sw = new StreamWriter(ConfigurationPath) { AutoFlush = true };
+            var writer = new JsonTextWriter(sw) { Formatting = Formatting.Indented };
+            serializer.Serialize(writer, options.Settings, typeof(Dictionary<string, string>));
+        }
+
+        #endregion
+    }
+}

MPF.Core/Utilities/Tools.cs

@@ -0,0 +1,365 @@
+using System;
+using System.Reflection;
+using MPF.Core.Data;
+using Newtonsoft.Json.Linq;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Core.Utilities
+{
+    public static class Tools
+    {
+        #region Byte Arrays
+
+        /// <summary>
+        /// Search for a byte array in another array
+        /// </summary>
+        public static bool Contains(this byte[] stack, byte[] needle, out int position, int start = 0, int end = -1)
+        {
+            // Initialize the found position to -1
+            position = -1;
+
+            // If either array is null or empty, we can't do anything
+            if (stack == null || stack.Length == 0 || needle == null || needle.Length == 0)
+                return false;
+
+            // If the needle array is larger than the stack array, it can't be contained within
+            if (needle.Length > stack.Length)
+                return false;
+
+            // If start or end are not set properly, set them to defaults
+            if (start < 0)
+                start = 0;
+            if (end < 0)
+                end = stack.Length - needle.Length;
+
+            for (int i = start; i < end; i++)
+            {
+                if (stack.EqualAt(needle, i))
+                {
+                    position = i;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// See if a byte array starts with another
+        /// </summary>
+        public static bool StartsWith(this byte[] stack, byte[] needle)
+        {
+            return stack.Contains(needle, out int _, start: 0, end: 1);
+        }
+
+        /// <summary>
+        /// Get if a stack at a certain index is equal to a needle
+        /// </summary>
+        private static bool EqualAt(this byte[] stack, byte[] needle, int index)
+        {
+            // If we're too close to the end of the stack, return false
+            if (needle.Length >= stack.Length - index)
+                return false;
+
+            for (int i = 0; i < needle.Length; i++)
+            {
+                if (stack[i + index] != needle[i])
+                    return false;
+            }
+
+            return true;
+        }
+
+        #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
+#if NET48
+            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");
+            }
+#else
+            return type switch
+            {
+                // Fully supported types
+                MediaType.BluRay
+                    or MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.FloppyDisk
+                    or MediaType.HardDisk
+                    or MediaType.CompactFlash
+                    or MediaType.SDCard
+                    or MediaType.FlashDrive
+                    or MediaType.HDDVD => Result.Success($"{type.LongName()} ready to dump"),
+
+                // Partially supported types
+                MediaType.GDROM
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => Result.Success($"{type.LongName()} partially supported for dumping"),
+
+                // Special case for other supported tools
+                MediaType.UMD => Result.Failure($"{type.LongName()} supported for submission info parsing"),
+
+                // Specifically unknown type
+                MediaType.NONE => Result.Failure($"Please select a valid media type"),
+
+                // Undumpable but recognized types
+                _ => Result.Failure($"{type.LongName()} media are not supported for dumping"),
+            };
+#endif
+        }
+        
+        /// <summary>
+        /// Returns false if a given InternalProgram does not support a given MediaType
+        /// </summary>
+        public static bool ProgramSupportsMedia(InternalProgram program, MediaType? type)
+        {
+            // If the media type is not set, return false
+            if (type == null || type == MediaType.NONE)
+                return false;
+
+#if NET48
+            switch (program)
+            {
+                case InternalProgram.Redumper:
+                    switch (type)
+                    {
+                        // Formats considered at least partially dumpable by Redumper
+                        case MediaType.BluRay:
+                        case MediaType.CDROM:
+                        case MediaType.DVD:
+                        case MediaType.GDROM:
+                        case MediaType.HDDVD:
+                            return true;
+
+                        // All other formats considered unsupported
+                        default:
+                            return false;
+                    }
+                case InternalProgram.Aaru:
+                case InternalProgram.DiscImageCreator:
+                    switch (type)
+                    {
+                        // Formats considered at least partially supported
+                        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:
+                        case MediaType.NintendoGameCubeGameDisc:
+                        case MediaType.NintendoWiiOpticalDisc:
+                            return true;
+
+                        // All other formats considered unsupported
+                        default:
+                            return false;
+                    }
+                // All other InternalPrograms are not used for dumping
+                default:
+                    return false;
+            }
+#else
+            return (program) switch
+            {
+                // Aaru
+                InternalProgram.Aaru when type == MediaType.BluRay => true,
+                InternalProgram.Aaru when type == MediaType.CDROM => true,
+                InternalProgram.Aaru when type == MediaType.CompactFlash => true,
+                InternalProgram.Aaru when type == MediaType.DVD => true,
+                InternalProgram.Aaru when type == MediaType.GDROM => true,
+                InternalProgram.Aaru when type == MediaType.FlashDrive => true,
+                InternalProgram.Aaru when type == MediaType.FloppyDisk => true,
+                InternalProgram.Aaru when type == MediaType.HardDisk => true,
+                InternalProgram.Aaru when type == MediaType.HDDVD => true,
+                InternalProgram.Aaru when type == MediaType.NintendoGameCubeGameDisc => true,
+                InternalProgram.Aaru when type == MediaType.NintendoWiiOpticalDisc => true,
+                InternalProgram.Aaru when type == MediaType.SDCard => true,
+
+                // DiscImageCreator
+                InternalProgram.DiscImageCreator when type == MediaType.BluRay => true,
+                InternalProgram.DiscImageCreator when type == MediaType.CDROM => true,
+                InternalProgram.DiscImageCreator when type == MediaType.CompactFlash => true,
+                InternalProgram.DiscImageCreator when type == MediaType.DVD => true,
+                InternalProgram.DiscImageCreator when type == MediaType.GDROM => true,
+                InternalProgram.DiscImageCreator when type == MediaType.FlashDrive => true,
+                InternalProgram.DiscImageCreator when type == MediaType.FloppyDisk => true,
+                InternalProgram.DiscImageCreator when type == MediaType.HardDisk => true,
+                InternalProgram.DiscImageCreator when type == MediaType.HDDVD => true,
+                InternalProgram.DiscImageCreator when type == MediaType.NintendoGameCubeGameDisc => true,
+                InternalProgram.DiscImageCreator when type == MediaType.NintendoWiiOpticalDisc => true,
+                InternalProgram.DiscImageCreator when type == MediaType.SDCard => true,
+
+                // Redumper
+                InternalProgram.Redumper when type == MediaType.BluRay => true,
+                InternalProgram.Redumper when type == MediaType.CDROM => true,
+                InternalProgram.Redumper when type == MediaType.DVD => true,
+                InternalProgram.Redumper when type == MediaType.GDROM => true,
+                InternalProgram.Redumper when type == MediaType.HDDVD => true,
+
+                // Default
+                _ => false,
+            };
+#endif
+        }
+
+        #endregion
+
+        #region Versioning
+
+        /// <summary>
+        /// Check for a new MPF version
+        /// </summary>
+        /// <returns>
+        /// Bool representing if the values are different.
+        /// String representing the message to display the the user.
+        /// String representing the new release URL.
+        /// </returns>
+#if NET48
+        public static (bool different, string message, string url) CheckForNewVersion()
+#else
+        public static (bool different, string message, string? url) CheckForNewVersion()
+#endif
+        {
+            try
+            {
+                // Get current assembly version
+                var assemblyVersion = Assembly.GetEntryAssembly()?.GetName()?.Version;
+                if (assemblyVersion == null)
+                    return (false, "Assembly version could not be determined", null);
+
+                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}";
+
+                // Get the latest tag from GitHub
+                var (tag, url) = GetRemoteVersionAndUrl();
+                bool different = version != tag;
+
+                string message = $"Local version: {version}"
+                    + $"{Environment.NewLine}Remote version: {tag}"
+                    + (different
+                        ? $"{Environment.NewLine}The update URL has been added copied to your clipboard"
+                        : $"{Environment.NewLine}You have the newest version!");
+
+                return (different, message, url);
+            }
+            catch (Exception ex)
+            {
+                return (false, ex.ToString(), null);
+            }
+        }
+
+        /// <summary>
+        /// Get the current informational version formatted as a string
+        /// </summary>
+#if NET48
+        public static string GetCurrentVersion()
+#else
+        public static string? GetCurrentVersion()
+#endif
+        {
+            try
+            {
+                var assembly = Assembly.GetEntryAssembly();
+                if (assembly == null)
+                    return null;
+
+                var assemblyVersion = Attribute.GetCustomAttribute(assembly, typeof(AssemblyInformationalVersionAttribute)) as AssemblyInformationalVersionAttribute;
+                return assemblyVersion?.InformationalVersion;
+            }
+            catch (Exception ex)
+            {
+                return ex.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Get the latest version of MPF from GitHub and the release URL
+        /// </summary>
+#if NET48
+        private static (string tag, string url) GetRemoteVersionAndUrl()
+#else
+        private static (string? tag, string? url) GetRemoteVersionAndUrl()
+#endif
+        {
+#if NET48
+            using (var wc = new System.Net.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);
+            }
+#else
+            using (var hc = new System.Net.Http.HttpClient())
+            {
+                // TODO: Figure out a better way than having this hardcoded...
+                string url = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
+                var message = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, url);
+                message.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0");
+                var latestReleaseJsonString = hc.Send(message)?.Content?.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+                if (latestReleaseJsonString == null)
+                    return (null, null);
+
+                var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
+                if (latestReleaseJson == null)
+                    return (null, null);
+
+                var latestTag = latestReleaseJson["tag_name"]?.ToString();
+                var releaseUrl = latestReleaseJson["html_url"]?.ToString();
+
+                return (latestTag, releaseUrl);
+            }
+#endif
+        }
+
+        #endregion
+    }
+}

MPF.Test/Core/Converters/EnumConverterTests.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+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,
+        };
+
+        /// <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);
+        }
+
+        /// <summary>
+        /// Generate a test set of DriveType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DriveType values</returns>
+#if NET48
+        public static List<object[]> GenerateDriveTypeMappingTestData()
+#else
+        public static List<object?[]> GenerateDriveTypeMappingTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (DriveType driveType in Enum.GetValues(typeof(DriveType)))
+            {
+                if (_mappableDriveTypes.Contains(driveType))
+#if NET48
+                    testData.Add(new object[] { driveType, false });
+#else
+                    testData.Add(new object?[] { driveType, false });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { driveType, true });
+#else
+                    testData.Add(new object?[] { driveType, true });
+#endif
+            }
+
+            return testData;
+        }
+
+#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>
+#if NET48
+        public static List<object[]> GenerateInternalProgramTestData()
+#else
+        public static List<object?[]> GenerateInternalProgramTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null } };
+#endif
+            foreach (InternalProgram? internalProgram in Enum.GetValues(typeof(InternalProgram)))
+            {
+#if NET48
+                testData.Add(new object[] { internalProgram });
+#else
+                testData.Add(new object?[] { internalProgram });
+#endif
+            }
+
+            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/Utilities/EnumExtensionsTests.cs

@@ -0,0 +1,312 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core.Utilities;
+using SabreTools.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.HasbroiONEducationalGamingSystem,
+            RedumpSystem.HasbroVideoNow,
+            RedumpSystem.HasbroVideoNowColor,
+            RedumpSystem.HasbroVideoNowJr,
+            RedumpSystem.HasbroVideoNowXP,
+            RedumpSystem.PlayStationGameSharkUpdates,
+            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,
+            RedumpSystem.SonyPlayStationPortable,
+        };
+
+        /// <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>
+#if NET48
+        public static List<object[]> GenerateSupportDriveSpeedsTestData()
+#else
+        public static List<object?[]> GenerateSupportDriveSpeedsTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (MediaType mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                if (_supportDriveSpeeds.Contains(mediaType))
+#if NET48
+                    testData.Add(new object[] { mediaType, true });
+#else
+                    testData.Add(new object?[] { mediaType, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { mediaType, false });
+#else
+                    testData.Add(new object?[] { mediaType, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered Audio
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+#if NET48
+        public static List<object[]> GenerateAudioSystemsTestData()
+#else
+        public static List<object?[]> GenerateAudioSystemsTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_audioSystems.Contains(redumpSystem))
+#if NET48
+                    testData.Add(new object[] { redumpSystem, true });
+#else
+                    testData.Add(new object?[] { redumpSystem, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { redumpSystem, false });
+#else
+                    testData.Add(new object?[] { redumpSystem, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered markers
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+#if NET48
+        public static List<object[]> GenerateMarkerSystemsTestData()
+#else
+        public static List<object?[]> GenerateMarkerSystemsTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_markerSystems.Contains(redumpSystem))
+#if NET48
+                    testData.Add(new object[] { redumpSystem, true });
+#else
+                    testData.Add(new object?[] { redumpSystem, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { redumpSystem, false });
+#else
+                    testData.Add(new object?[] { redumpSystem, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered markers
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+#if NET48
+        public static List<object[]> GenerateReversedRingcodeSystemsTestData()
+#else
+        public static List<object?[]> GenerateReversedRingcodeSystemsTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_reverseRingcodeSystems.Contains(redumpSystem))
+#if NET48
+                    testData.Add(new object[] { redumpSystem, true });
+#else
+                    testData.Add(new object?[] { redumpSystem, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { redumpSystem, false });
+#else
+                    testData.Add(new object?[] { redumpSystem, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values that are considered XGD
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+#if NET48
+        public static List<object[]> GenerateXGDSystemsTestData()
+#else
+        public static List<object?[]> GenerateXGDSystemsTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_xgdSystems.Contains(redumpSystem))
+#if NET48
+                    testData.Add(new object[] { redumpSystem, true });
+#else
+                    testData.Add(new object?[] { redumpSystem, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { redumpSystem, false });
+#else
+                    testData.Add(new object?[] { redumpSystem, false });
+#endif
+            }
+
+            return testData;
+        }
+    }
+}

MPF.Test/Library/DumpEnvironmentTests.cs

@@ -0,0 +1,32 @@
+using MPF.Core;
+using MPF.Core.Data;
+using SabreTools.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 };
+
+            // TODO: This relies on creating real objects for the drive. Can we mock this out instead?
+            var drive = isFloppy
+                ? Drive.Create(InternalDriveType.Floppy, letter.ToString())
+                : Drive.Create(InternalDriveType.Optical, letter.ToString());
+
+            var env = new DumpEnvironment(options, string.Empty, drive, RedumpSystem.IBMPCcompatible, mediaType, null, parameters);
+
+            bool actual = env.ParametersValid();
+            Assert.Equal(expected, actual);
+        }
+    }
+}

MPF.Test/Library/InfoToolTests.cs

@@ -0,0 +1,224 @@
+using System.Collections.Generic;
+using System.IO;
+using MPF.Core;
+using SabreTools.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,
+#if NET48
+            string expected)
+#else
+            string? expected)
+#endif
+        {
+            // TODO: Add tests around BDU
+            var actual = InfoTool.GetFixedMediaType(mediaType, null, size, layerbreak, layerbreak2, layerbreak3);
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(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")]
+#if NET48
+        public void NormalizeOutputPathsTest(string outputPath, string expectedPath)
+#else
+        public void NormalizeOutputPathsTest(string? outputPath, string? expectedPath)
+#endif
+        {
+            if (!string.IsNullOrWhiteSpace(expectedPath))
+                expectedPath = Path.GetFullPath(expectedPath);
+
+            string actualPath = InfoTool.NormalizeOutputPaths(outputPath, true);
+            Assert.Equal(expectedPath, actualPath);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsCompleteTest()
+        {
+            // Create a new SubmissionInfo object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = "This is a comments line\n[T:ISBN] ISBN Value",
+#if NET48
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = "This is a contents line\n[T:GF] Game Footage",
+#if NET48
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [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
+            var 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
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = null,
+#if NET48
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = null,
+#if NET48
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [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
+            var 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,234 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Core;
+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)]
+        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

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net6.0-windows;net7.0-windows</TargetFrameworks>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='net48'">
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF\MPF.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeCoverage" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.1.1" />
+    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit.abstractions" Version="2.0.3" />
+    <PackageReference Include="xunit.analyzers" Version="1.4.0" />
+    <PackageReference Include="xunit.assert" Version="2.5.3" />
+    <PackageReference Include="xunit.core" Version="2.5.3" />
+    <PackageReference Include="xunit.extensibility.core" Version="2.5.3" />
+    <PackageReference Include="xunit.extensibility.execution" Version="2.5.3" />
+    <PackageReference Include="xunit.runner.console" Version="2.5.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

MPF.Test/Modules/DiscImageCreatorTests.cs

@@ -0,0 +1,274 @@
+using System;
+using System.Collections.Generic;
+using MPF.Core.Data;
+using MPF.Core.Modules.DiscImageCreator;
+using SabreTools.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, null)] // Deliberately unsupported
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, new string[] { FlagStrings.Raw })]
+        public void ParametersFromOptionsSpecialDefaultTest(RedumpSystem? knownSystem, MediaType? mediaType,string[] expected)
+        {
+            var options = new Options();
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, 1000, new string[] { FlagStrings.C2Opcode })]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, -1, new string[] { FlagStrings.C2Opcode })]
+        public void ParametersFromOptionsC2RereadTest(RedumpSystem? knownSystem, MediaType? mediaType, int rereadC2, string[] expected)
+        {
+            var options = new Options { DICRereadCount = rereadC2 };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+
+            Assert.Equal(expectedSet, actualSet);
+            if (rereadC2 == -1 || !knownSystem.MediaTypes().Contains(mediaType))
+                Assert.Null(actual.C2OpcodeValue[0]);
+            else
+                Assert.Equal(rereadC2, actual.C2OpcodeValue[0]);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, 1000, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, -1, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.BluRay, 1000, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.BluRay, -1, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsDVDRereadTest(RedumpSystem? knownSystem, MediaType? mediaType, int rereadDVDBD, string[] expected)
+        {
+            var options = new Options { DICDVDRereadCount = rereadDVDBD };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+
+            Assert.Equal(expectedSet, actualSet);
+            if (rereadDVDBD == -1 || !knownSystem.MediaTypes().Contains(mediaType))
+                Assert.Null(actual.DVDRereadValue);
+            else
+                Assert.Equal(rereadDVDBD, actual.DVDRereadValue);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.MultiSectorRead, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, false, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsMultiSectorReadTest(RedumpSystem? knownSystem, MediaType? mediaType, bool multiSectorRead, string[] expected)
+        {
+            var options = new Options { DICMultiSectorRead = multiSectorRead };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+            if (expectedSet.Count != 1 && multiSectorRead)
+                Assert.Equal(0, actual.MultiSectorReadValue);
+        }
+
+        [Theory]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, true, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, false, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, true, new string[] { FlagStrings.DVDReread, FlagStrings.ScanFileProtect })]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, false, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, true, new string[] { FlagStrings.DVDReread })]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, false, new string[] { FlagStrings.DVDReread })]
+        public void ParametersFromOptionsParanoidModeTest(RedumpSystem? knownSystem, MediaType? mediaType, bool paranoidMode, string[] expected)
+        {
+            var options = new Options { DICParanoidMode = paranoidMode };
+            var actual = new Parameters(knownSystem, mediaType, "D:\\", "disc.bin", 16, options);
+
+            var expectedSet = new HashSet<string>(expected ?? Array.Empty<string>());
+            HashSet<string> actualSet = GenerateUsedKeys(actual);
+            Assert.Equal(expectedSet, actualSet);
+            if (paranoidMode)
+            {
+                if (actualSet.Contains(FlagStrings.ScanSectorProtect))
+                    Assert.True(actual[FlagStrings.ScanSectorProtect]);
+
+                if (actualSet.Contains(FlagStrings.SubchannelReadLevel))
+                {
+                    Assert.True(actual[FlagStrings.SubchannelReadLevel]);
+                    Assert.Equal(2, actual.SubchannelReadLevelValue);
+                }
+            }
+            else
+            {
+                if (actualSet.Contains(FlagStrings.ScanSectorProtect))
+                    Assert.False(actual[FlagStrings.ScanSectorProtect]);
+
+                if (actualSet.Contains(FlagStrings.SubchannelReadLevel))
+                    Assert.False(actual[FlagStrings.SubchannelReadLevel]);
+
+                Assert.Null(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)]
+#if NET48
+        public void MediaTypeToExtensionTest(MediaType? mediaType, string expected)
+#else
+        public void MediaTypeToExtensionTest(MediaType? mediaType, string? expected)
+#endif
+        {
+            var actual = 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 = 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 = 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
+            var 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
+            var newParameters = parametersObject.GenerateParameters();
+            Assert.NotNull(newParameters);
+            Assert.Equal(originalParameters, newParameters);
+        }
+
+        /// <summary>
+        /// Generate a HashSet of keys that are considered to be set
+        /// </summary>
+        /// <param name="parameters">Parameters object to get keys from</param>
+        /// <returns>HashSet representing the strings</returns>
+        private static HashSet<string> GenerateUsedKeys(Parameters parameters)
+        {
+            var usedKeys = new HashSet<string>();
+            if (parameters?.Keys == null)
+                return usedKeys;
+
+            foreach (string key in parameters.Keys)
+            {
+                if (parameters[key] == true)
+                    usedKeys.Add(key);
+            }
+
+            return usedKeys;
+        }
+    }
+}

MPF.Test/RedumpLib/ExtensionsTests.cs

@@ -0,0 +1,889 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using SabreTools.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.BD33,
+            DiscType.BD50,
+            DiscType.BD66,
+            DiscType.BD100,
+            DiscType.BD128,
+            DiscType.CD,
+            DiscType.DVD5,
+            DiscType.DVD9,
+            DiscType.GDROM,
+            DiscType.HDDVDSL,
+            DiscType.HDDVDDL,
+            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>
+#if NET48
+        public static List<object[]> GenerateDiscTypeMappingTestData()
+#else
+        public static List<object?[]> GenerateDiscTypeMappingTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
+            {
+                if (_mappableDiscTypes.Contains(discType))
+#if NET48
+                    testData.Add(new object[] { discType, false });
+#else
+                    testData.Add(new object?[] { discType, false });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { discType, true });
+#else
+                    testData.Add(new object?[] { discType, true });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of RedumpSystem values
+        /// </summary>
+        /// <returns>MemberData-compatible list of RedumpSystem values</returns>
+#if NET48
+        public static List<object[]> GenerateRedumpSystemMappingTestData()
+#else
+        public static List<object?[]> GenerateRedumpSystemMappingTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null } };
+#endif
+            foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+#if NET48
+                testData.Add(new object[] { redumpSystem });
+#else
+                testData.Add(new object?[] { redumpSystem });
+#endif
+            }
+
+            return testData;
+        }
+
+        /// <summary>
+        /// Generate a test set of mappable media types
+        /// </summary>
+        /// <returns>MemberData-compatible list of MediaTypes</returns>
+#if NET48
+        public static List<object[]> GenerateMediaTypeMappingTestData()
+#else
+        public static List<object?[]> GenerateMediaTypeMappingTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+
+            foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+                if (_mappableMediaTypes.Contains(mediaType))
+#if NET48
+                    testData.Add(new object[] { mediaType, false });
+#else
+                    testData.Add(new object?[] { mediaType, false });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { mediaType, true });
+#else
+                    testData.Add(new object?[] { mediaType, true });
+#endif
+            }
+
+            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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateDiscCategoryTestData()
+#else
+        public static List<object?[]> GenerateDiscCategoryTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (DiscCategory? discCategory in Enum.GetValues(typeof(DiscCategory)))
+            {
+#if NET48
+                testData.Add(new object[] { discCategory, false });
+#else
+                testData.Add(new object?[] { discCategory, false });
+#endif
+            }
+
+            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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateDiscTypeTestData()
+#else
+        public static List<object?[]> GenerateDiscTypeTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (DiscType? discType in Enum.GetValues(typeof(DiscType)))
+            {
+                if (discType == DiscType.NONE)
+#if NET48
+                    testData.Add(new object[] { discType, true });
+#else
+                    testData.Add(new object?[] { discType, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { discType, false });
+#else
+                    testData.Add(new object?[] { discType, false });
+#endif
+            }
+
+            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)
+        {
+            var 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)
+        {
+            var 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)
+            {
+                var 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)
+            {
+                var 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)
+            {
+                var 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>
+#if NET48
+        public static List<object[]> GenerateLanguageTestData()
+#else
+        public static List<object?[]> GenerateLanguageTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (Language? language in Enum.GetValues(typeof(Language)))
+            {
+#if NET48
+                testData.Add(new object[] { language, false });
+#else
+                testData.Add(new object?[] { language, false });
+#endif
+            }
+
+            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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateLanguageSelectionTestData()
+#else
+        public static List<object?[]> GenerateLanguageSelectionTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (LanguageSelection? languageSelection in Enum.GetValues(typeof(LanguageSelection)))
+            {
+#if NET48
+                testData.Add(new object[] { languageSelection, false });
+#else
+                testData.Add(new object?[] { languageSelection, false });
+#endif
+            }
+
+            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)
+        {
+            var 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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateMediaTypeTestData()
+#else
+        public static List<object?[]> GenerateMediaTypeTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (MediaType? mediaType in Enum.GetValues(typeof(MediaType)))
+            {
+#if NET48
+                testData.Add(new object[] { mediaType, false });
+#else
+                testData.Add(new object?[] { mediaType, false });
+#endif
+            }
+
+            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)
+        {
+            var 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)
+        {
+            var 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)
+            {
+                var 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>
+#if NET48
+        public static List<object[]> GenerateRegionTestData()
+#else
+        public static List<object?[]> GenerateRegionTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (Region? region in Enum.GetValues(typeof(Region)))
+            {
+#if NET48
+                testData.Add(new object[] { region, false });
+#else
+                testData.Add(new object?[] { region, false });
+#endif
+            }
+
+            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)
+        {
+            var 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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateSiteCodeTestData()
+#else
+        public static List<object?[]> GenerateSiteCodeTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (SiteCode? siteCode in Enum.GetValues(typeof(SiteCode)))
+            {
+#if NET48
+                testData.Add(new object[] { siteCode, false });
+#else
+                testData.Add(new object?[] { siteCode, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        #endregion
+
+        #region System
+
+        /// <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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateRedumpSystemTestData()
+#else
+        public static List<object?[]> GenerateRedumpSystemTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (RedumpSystem? redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                // We want to skip all markers for this
+                if (redumpSystem.IsMarker())
+                    continue;
+
+#if NET48
+                testData.Add(new object[] { redumpSystem, false });
+#else
+                testData.Add(new object?[] { redumpSystem, false });
+#endif
+            }
+
+            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)
+        {
+            var 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>
+#if NET48
+        public static List<object[]> GenerateSystemCategoryTestData()
+#else
+        public static List<object?[]> GenerateSystemCategoryTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, true } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+#endif
+            foreach (SystemCategory? systemCategory in Enum.GetValues(typeof(SystemCategory)))
+            {
+                if (systemCategory == SystemCategory.NONE)
+#if NET48
+                    testData.Add(new object[] { systemCategory, true });
+#else
+                    testData.Add(new object?[] { systemCategory, true });
+#endif
+                else
+#if NET48
+                    testData.Add(new object[] { systemCategory, false });
+#else
+                    testData.Add(new object?[] { systemCategory, false });
+#endif
+            }
+
+            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>
+#if NET48
+        public static List<object[]> GenerateYesNoTestData()
+#else
+        public static List<object?[]> GenerateYesNoTestData()
+#endif
+        {
+#if NET48
+            var testData = new List<object[]>() { new object[] { null, false } };
+#else
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+#endif
+            foreach (YesNo? yesNo in Enum.GetValues(typeof(YesNo)))
+            {
+#if NET48
+                testData.Add(new object[] { yesNo, false });
+#else
+                testData.Add(new object?[] { yesNo, false });
+#endif
+            }
+
+            return testData;
+        }
+
+        #endregion
+    }
+}

MPF.Test/RedumpLib/SubmissionInfoTests.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using SabreTools.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,
+                FullyMatchedID = 3,
+                PartiallyMatchedIDs = 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",
+#if NET48
+                    CommentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [SiteCode.ISBN] = "ISBN",
+                    },
+                    Contents = "Special contents 1\r\nSpecial contents 2",
+#if NET48
+                    ContentsSpecialFields = new Dictionary<SiteCode?, string>()
+#else
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
+#endif
+                    {
+                        [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.TwoOrMoreGreen,
+                    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",
+                },
+
+                DumpingInfo = new DumpingInfoSection()
+                {
+                    DumpingProgram = "DiscImageCreator 20500101",
+                    DumpingDate = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"),
+                    Manufacturer = "ATAPI",
+                    Model = "Optical Drive",
+                    Firmware = "1.23",
+                    ReportedDiscType = "CD-R",
+                },
+
+                Artifacts = new Dictionary<string, string>()
+                {
+                    ["Sample Artifact"] = "Sample Data",
+                },
+            };
+
+            string json = JsonConvert.SerializeObject(submissionInfo, Formatting.Indented);
+            Assert.NotNull(json);
+        }
+    }
+}

MPF.Test/UI/AllowedSpeedsTest.cs

@@ -0,0 +1,22 @@
+using System.Linq;
+using MPF.Core.Data;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Test.Data
+{
+    public class UIElementsTest
+    {
+        [Theory]
+        [InlineData(MediaType.CDROM, 72)]
+        [InlineData(MediaType.DVD, 24)]
+        [InlineData(MediaType.BluRay, 16)]
+        [InlineData(MediaType.LaserDisc, 1)]
+        [InlineData(null, 1)]
+        public void GetAllowedDriveSpeedForMediaTypeTest(MediaType? mediaType, int maxExpected)
+        {
+            var actual = Interface.GetSpeedsForMediaType(mediaType);
+            Assert.Equal(maxExpected, actual.Last());
+        }
+    }
+}

MPF.UI.Core/Constants.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Media;
+using static MPF.Core.Data.Interface;
+
+namespace MPF.UI.Core
+{
+    /// <summary>
+    /// Variables for UI elements
+    /// </summary>
+    public static class Constants
+    {
+        // 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 SpeedsForHDDVDAsCollection { get; } = GetDoubleCollectionFromIntList(HDDVD);
+        public static DoubleCollection SpeedsForBDAsCollection { get; } = GetDoubleCollectionFromIntList(BD);
+        private static DoubleCollection GetDoubleCollectionFromIntList(IReadOnlyList<int> list)
+            => new DoubleCollection(list.Select(i => Convert.ToDouble(i)).ToList());
+    }
+}

MPF.UI.Core/ElementConverter.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using MPF.Core.Data;
+using MPF.Core.UI.ComboBoxItems;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.UI.Core
+{
+    internal class ElementConverter: IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            switch (value)
+            {
+                case DiscCategory discCategory:
+                    return new Element<DiscCategory>(discCategory);
+                case InternalProgram internalProgram:
+                    return new Element<InternalProgram>(internalProgram);
+                case MediaType mediaType:
+                    return new Element<MediaType>(mediaType);
+                case RedumpSystem redumpSystem:
+                    return new RedumpSystemComboBoxItem(redumpSystem);
+                case Region region:
+                    return new Element<Region>(region);
+
+                // Null values are treated as a system value
+                default:
+                    return new RedumpSystemComboBoxItem((RedumpSystem?)null);
+            }
+        }
+
+#if NET48
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+#else
+        public object? ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+#endif
+        {
+            // If it's an IElement but ends up null
+#if NET48
+            if (!(value is IElement element))
+#else
+            if (value is not IElement element)
+#endif
+                return null;
+
+            switch (element)
+            {
+                case Element<DiscCategory> dcElement:
+                    return dcElement.Value;
+                case Element<InternalProgram> ipElement:
+                    return ipElement.Value;
+                case Element<MediaType> mtElement:
+                    return mtElement.Value;
+                case RedumpSystemComboBoxItem rsElement:
+                    return rsElement.Value;
+                case Element<Region> reValue:
+                    return reValue.Value;
+
+                default: return null;
+            }
+        }
+    }
+}

MPF.UI.Core/External/WPFCustomMessageBox/CustomMessageBox.cs

@@ -0,0 +1,608 @@
+// -----------------------------------------------------------------------
+// <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>
+        private static readonly 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>
+#if NET48
+        public static MessageBoxResult Show(Window owner, string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+#else
+        public static MessageBoxResult Show(Window owner, string? messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+#endif
+        {
+            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>
+#if NET48
+        private static MessageBoxResult ShowOKMessage(Window owner, string messageBoxText, string caption, string okButtonText, string cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+#else
+        private static MessageBoxResult ShowOKMessage(Window? owner, string? messageBoxText, string caption, string? okButtonText, string? cancelButtonText, MessageBoxImage? icon, int? timeout = null, MessageBoxResult timeoutResult = MessageBoxResult.None)
+#endif
+        {
+            MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.OK : MessageBoxButton.OKCancel;
+
+            var 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>
+#if NET48
+        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)
+#else
+        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)
+#endif
+        {
+            MessageBoxButton buttonLayout = string.IsNullOrEmpty(cancelButtonText) ? MessageBoxButton.YesNo : MessageBoxButton.YesNoCancel;
+
+            var 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(nameof(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);
+                var 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.UI.Core/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml

@@ -0,0 +1,83 @@
+<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"
+        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.UI.Core/External/WPFCustomMessageBox/CustomMessageBoxWindow.xaml.cs

@@ -0,0 +1,254 @@
+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 readonly bool _removeTitleBarIcon = true;
+
+#if NET48
+        public string Caption
+#else
+        public string? Caption
+#endif
+        {
+            get
+            {
+                return Title;
+            }
+            set
+            {
+                Title = value;
+            }
+        }
+
+#if NET48
+        public string Message
+#else
+        public string? Message
+#endif
+        {
+            get
+            {
+                return TextBlock_Message.Text;
+            }
+            set
+            {
+                TextBlock_Message.Text = value;
+            }
+        }
+
+#if NET48
+        public string OkButtonText
+#else
+        public string? OkButtonText
+#endif
+        {
+            get
+            {
+                return Label_Ok.Content.ToString();
+            }
+            set
+            {
+                Label_Ok.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+#if NET48
+        public string CancelButtonText
+#else
+        public string? CancelButtonText
+#endif
+        {
+            get
+            {
+                return Label_Cancel.Content.ToString();
+            }
+            set
+            {
+                Label_Cancel.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+#if NET48
+        public string YesButtonText
+#else
+        public string? YesButtonText
+#endif
+        {
+            get
+            {
+                return Label_Yes.Content.ToString();
+            }
+            set
+            {
+                Label_Yes.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+#if NET48
+        public string NoButtonText
+#else
+        public string? NoButtonText
+#endif
+        {
+            get
+            {
+                return Label_No.Content.ToString();
+            }
+            set
+            {
+                Label_No.Content = value.TryAddKeyboardAccellerator();
+            }
+        }
+
+        public MessageBoxResult Result { get; set; }
+
+#if NET48
+        internal CustomMessageBoxWindow(Window owner, string message, string caption = null, MessageBoxButton? button = null, MessageBoxImage? image = null, bool removeTitleBarIcon = true)
+#else
+        internal CustomMessageBoxWindow(Window? owner, string? message, string? caption = null, MessageBoxButton? button = null, MessageBoxImage? image = null, bool removeTitleBarIcon = true)
+#endif
+        {
+            InitializeComponent();
+
+            _removeTitleBarIcon = removeTitleBarIcon;
+            Focusable = true;
+            ShowActivated = true;
+            ShowInTaskbar = true;
+
+            if (owner != null && owner.IsLoaded)
+            {
+                Owner = owner;
+                WindowStartupLocation = WindowStartupLocation.CenterOwner;
+            }
+
+            Message = message;
+            Caption = caption;
+
+            DisplayButtons(button ?? MessageBoxButton.OK);
+
+            if (image.HasValue)
+                DisplayImage(image.Value);
+            else
+                Image_MessageBox.Visibility = 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 = Visibility.Visible;
+                    Button_OK.Focus();
+                    Button_Cancel.Visibility = Visibility.Visible;
+
+                    Button_Yes.Visibility = Visibility.Collapsed;
+                    Button_No.Visibility = Visibility.Collapsed;
+                    break;
+                case MessageBoxButton.YesNo:
+                    // Hide all but Yes, No
+                    Button_Yes.Visibility = Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = Visibility.Visible;
+
+                    Button_OK.Visibility = Visibility.Collapsed;
+                    Button_Cancel.Visibility = Visibility.Collapsed;
+                    break;
+                case MessageBoxButton.YesNoCancel:
+                    // Hide only OK
+                    Button_Yes.Visibility = Visibility.Visible;
+                    Button_Yes.Focus();
+                    Button_No.Visibility = Visibility.Visible;
+                    Button_Cancel.Visibility = Visibility.Visible;
+
+                    Button_OK.Visibility = Visibility.Collapsed;
+                    break;
+                default:
+                    // Hide all but OK
+                    Button_OK.Visibility = Visibility.Visible;
+                    Button_OK.Focus();
+
+                    Button_Yes.Visibility = Visibility.Collapsed;
+                    Button_No.Visibility = Visibility.Collapsed;
+                    Button_Cancel.Visibility = 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 = 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.UI.Core/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.UI.Core/External/WPFCustomMessageBox/Util.cs

@@ -0,0 +1,96 @@
+// -----------------------------------------------------------------------
+// <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>
+#if NET48
+        internal static string TryAddKeyboardAccellerator(this string input)
+#else
+        internal static string? TryAddKeyboardAccellerator(this string? input)
+#endif
+        {
+            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.UI.Core/MPF.UI.Core.csproj

@@ -0,0 +1,45 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
+  <PropertyGroup>
+    <TargetFrameworks>net48;net6.0-windows;net7.0-windows</TargetFrameworks>
+    <RuntimeIdentifiers>win-x64</RuntimeIdentifiers>
+    <UseWindowsForms>true</UseWindowsForms>
+    <UseWPF>true</UseWPF>
+    <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+    <Copyright>Copyright (c)2019-2023</Copyright>
+    <VersionPrefix>2.7.5</VersionPrefix>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='net48'">
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Resource Include="Images\ring-code-guide-1-layer.png" />
+    <Resource Include="Images\ring-code-guide-2-layer.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MPF.Core\MPF.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net48'">
+    <Reference Include="PresentationFramework.Aero" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SabreTools.RedumpLib" Version="1.1.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Page Update="UserControls\UserInput.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+    <Page Update="Windows\DiscInformationWindow.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+    <Page Update="Windows\RingCodeGuideWindow.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+  </ItemGroup>
+</Project>

MPF.UI.Core/Theme.cs

@@ -0,0 +1,524 @@
+using System.Windows;
+using System.Windows.Media;
+
+namespace MPF.UI.Core
+{
+    /// <summary>
+    /// Represents all required mapping values for the UI
+    /// </summary>
+    public abstract class Theme
+    {
+        #region Application-Wide
+
+        /// <summary>
+        /// SolidColorBrush used to paint the active window's border.
+        /// </summary>
+#if NET48
+        public SolidColorBrush ActiveBorderBrush { get; protected set; }
+#else
+        public SolidColorBrush? ActiveBorderBrush { get; protected set; }
+#endif
+
+        /// <summary>
+        /// SolidColorBrush that paints the face of a three-dimensional display element.
+        /// </summary>
+#if NET48
+        public SolidColorBrush ControlBrush { get; protected set; }
+#else
+        public SolidColorBrush? ControlBrush { get; protected set; }
+#endif
+
+        /// <summary>
+        /// SolidColorBrush that paints text in a three-dimensional display element.
+        /// </summary>
+#if NET48
+        public SolidColorBrush ControlTextBrush { get; protected set; }
+#else
+        public SolidColorBrush? ControlTextBrush { get; protected set; }
+#endif
+
+        /// <summary>
+        /// SolidColorBrush that paints disabled text.
+        /// </summary>
+#if NET48
+        public SolidColorBrush GrayTextBrush { get; protected set; }
+#else
+        public SolidColorBrush? GrayTextBrush { get; protected set; }
+#endif
+
+        /// <summary>
+        /// SolidColorBrush that paints the background of a window's client area.
+        /// </summary>
+#if NET48
+        public SolidColorBrush WindowBrush { get; protected set; }
+#else
+        public SolidColorBrush? WindowBrush { get; protected set; }
+#endif
+
+        /// <summary>
+        /// SolidColorBrush that paints the text in the client area of a window.
+        /// </summary>
+#if NET48
+        public SolidColorBrush WindowTextBrush { get; protected set; }
+#else
+        public SolidColorBrush? WindowTextBrush { get; protected set; }
+#endif
+
+        #endregion
+
+        #region Button
+
+        /// <summary>
+        /// Brush for the Button.Disabled.Background resource
+        /// </summary>
+#if NET48
+        public Brush Button_Disabled_Background { get; protected set; }
+#else
+        public Brush? Button_Disabled_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the Button.MouseOver.Background resource
+        /// </summary>
+#if NET48
+        public Brush Button_MouseOver_Background { get; protected set; }
+#else
+        public Brush? Button_MouseOver_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the Button.Pressed.Background resource
+        /// </summary>
+#if NET48
+        public Brush Button_Pressed_Background { get; protected set; }
+#else
+        public Brush? Button_Pressed_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the Button.Static.Background resource
+        /// </summary>
+#if NET48
+        public Brush Button_Static_Background { get; protected set; }
+#else
+        public Brush? Button_Static_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        #region ComboBox
+
+        /// <summary>
+        /// Brush for the ComboBox.Disabled.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Disabled_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Disabled_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Disabled.Editable.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Disabled_Editable_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Disabled_Editable_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Disabled.Editable.Button.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Disabled_Editable_Button_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Disabled_Editable_Button_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.MouseOver.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_MouseOver_Background { get; protected set; }
+#else
+        public Brush? ComboBox_MouseOver_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.MouseOver.Editable.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_MouseOver_Editable_Background { get; protected set; }
+#else
+        public Brush? ComboBox_MouseOver_Editable_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.MouseOver.Editable.Button.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_MouseOver_Editable_Button_Background { get; protected set; }
+#else
+        public Brush? ComboBox_MouseOver_Editable_Button_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Pressed.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Pressed_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Pressed_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Pressed.Editable.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Pressed_Editable_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Pressed_Editable_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Pressed.Editable.Button.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Pressed_Editable_Button_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Pressed_Editable_Button_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Static.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Static_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Static_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Static.Editable.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Static_Editable_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Static_Editable_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the ComboBox.Static.Editable.Button.Background resource
+        /// </summary>
+#if NET48
+        public Brush ComboBox_Static_Editable_Button_Background { get; protected set; }
+#else
+        public Brush? ComboBox_Static_Editable_Button_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        #region CustomMessageBox
+
+        /// <summary>
+        /// Brush for the CustomMessageBox.Static.Background resource
+        /// </summary>
+#if NET48
+        public Brush CustomMessageBox_Static_Background { get; protected set; }
+#else
+        public Brush? CustomMessageBox_Static_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        #region MenuItem
+
+        /// <summary>
+        /// Brush for the MenuItem.SubMenu.Background resource
+        /// </summary>
+#if NET48
+        public Brush MenuItem_SubMenu_Background { get; protected set; }
+#else
+        public Brush? MenuItem_SubMenu_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the MenuItem.SubMenu.Border resource
+        /// </summary>
+#if NET48
+        public Brush MenuItem_SubMenu_Border { get; protected set; }
+#else
+        public Brush? MenuItem_SubMenu_Border { get; protected set; }
+#endif
+
+        #endregion
+
+        #region ProgressBar
+
+        /// <summary>
+        /// Brush for the ProgressBar.Background resource
+        /// </summary>
+#if NET48
+        public Brush ProgressBar_Background { get; protected set; }
+#else
+        public Brush? ProgressBar_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        #region ScrollViewer
+
+        /// <summary>
+        /// Brush for the ScrollViewer.ScrollBar.Background resource
+        /// </summary>
+#if NET48
+        public Brush ScrollViewer_ScrollBar_Background { get; protected set; }
+#else
+        public Brush? ScrollViewer_ScrollBar_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        #region TabItem
+
+        /// <summary>
+        /// Brush for the TabItem.Selected.Background resource
+        /// </summary>
+#if NET48
+        public Brush TabItem_Selected_Background { get; protected set; }
+#else
+        public Brush? TabItem_Selected_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the TabItem.Static.Background resource
+        /// </summary>
+#if NET48
+        public Brush TabItem_Static_Background { get; protected set; }
+#else
+        public Brush? TabItem_Static_Background { get; protected set; }
+#endif
+
+        /// <summary>
+        /// Brush for the TabItem.Static.Border resource
+        /// </summary>
+#if NET48
+        public Brush TabItem_Static_Border { get; protected set; }
+#else
+        public Brush? TabItem_Static_Border { get; protected set; }
+#endif
+
+        #endregion
+
+        #region TextBox
+
+        /// <summary>
+        /// Brush for the TextBox.Static.Background resource
+        /// </summary>
+#if NET48
+        public Brush TextBox_Static_Background { get; protected set; }
+#else
+        public Brush? TextBox_Static_Background { get; protected set; }
+#endif
+
+        #endregion
+
+        /// <summary>
+        /// Apply the theme to the current application
+        /// </summary>
+        public void Apply()
+        {
+            // Handle application-wide resources
+            Application.Current.Resources[SystemColors.ActiveBorderBrushKey] = this.ActiveBorderBrush;
+            Application.Current.Resources[SystemColors.ControlBrushKey] = this.ControlBrush;
+            Application.Current.Resources[SystemColors.ControlTextBrushKey] = this.ControlTextBrush;
+            Application.Current.Resources[SystemColors.GrayTextBrushKey] = this.GrayTextBrush;
+            Application.Current.Resources[SystemColors.WindowBrushKey] = this.WindowBrush;
+            Application.Current.Resources[SystemColors.WindowTextBrushKey] = this.WindowTextBrush;
+
+            // Handle Button-specific resources
+            Application.Current.Resources["Button.Disabled.Background"] = this.Button_Disabled_Background;
+            Application.Current.Resources["Button.MouseOver.Background"] = this.Button_MouseOver_Background;
+            Application.Current.Resources["Button.Pressed.Background"] = this.Button_Pressed_Background;
+            Application.Current.Resources["Button.Static.Background"] = this.Button_Static_Background;
+
+            // Handle ComboBox-specific resources
+            Application.Current.Resources["ComboBox.Disabled.Background"] = this.ComboBox_Disabled_Background;
+            Application.Current.Resources["ComboBox.Disabled.Editable.Background"] = this.ComboBox_Disabled_Editable_Background;
+            Application.Current.Resources["ComboBox.Disabled.Editable.Button.Background"] = this.ComboBox_Disabled_Editable_Button_Background;
+            Application.Current.Resources["ComboBox.MouseOver.Background"] = this.ComboBox_MouseOver_Background;
+            Application.Current.Resources["ComboBox.MouseOver.Editable.Background"] = this.ComboBox_MouseOver_Editable_Background;
+            Application.Current.Resources["ComboBox.MouseOver.Editable.Button.Background"] = this.ComboBox_MouseOver_Editable_Button_Background;
+            Application.Current.Resources["ComboBox.Pressed.Background"] = this.ComboBox_Pressed_Background;
+            Application.Current.Resources["ComboBox.Pressed.Editable.Background"] = this.ComboBox_Pressed_Editable_Background;
+            Application.Current.Resources["ComboBox.Pressed.Editable.Button.Background"] = this.ComboBox_Pressed_Editable_Button_Background;
+            Application.Current.Resources["ComboBox.Static.Background"] = this.ComboBox_Static_Background;
+            Application.Current.Resources["ComboBox.Static.Editable.Background"] = this.ComboBox_Static_Editable_Background;
+            Application.Current.Resources["ComboBox.Static.Editable.Button.Background"] = this.ComboBox_Static_Editable_Button_Background;
+
+            // Handle CustomMessageBox-specific resources
+            Application.Current.Resources["CustomMessageBox.Static.Background"] = this.CustomMessageBox_Static_Background;
+
+            // Handle MenuItem-specific resources
+            Application.Current.Resources["MenuItem.SubMenu.Background"] = this.MenuItem_SubMenu_Background;
+            Application.Current.Resources["MenuItem.SubMenu.Border"] = this.MenuItem_SubMenu_Border;
+
+            // Handle ProgressBar-specific resources
+            Application.Current.Resources["ProgressBar.Background"] = this.ProgressBar_Background;
+
+            // Handle ScrollViewer-specific resources
+            Application.Current.Resources["ScrollViewer.ScrollBar.Background"] = this.ScrollViewer_ScrollBar_Background;
+
+            // Handle TabItem-specific resources
+            Application.Current.Resources["TabItem.Selected.Background"] = this.TabItem_Selected_Background;
+            Application.Current.Resources["TabItem.Static.Background"] = this.TabItem_Static_Background;
+            Application.Current.Resources["TabItem.Static.Border"] = this.TabItem_Static_Border;
+
+            // Handle TextBox-specific resources
+            Application.Current.Resources["TextBox.Static.Background"] = this.TextBox_Static_Background;
+        }
+    }
+
+    /// <summary>
+    /// Default light-mode theme
+    /// </summary>
+    public class LightModeTheme : Theme
+    {
+        public LightModeTheme()
+        {
+            // Handle application-wide resources
+            this.ActiveBorderBrush = null;
+            this.ControlBrush = null;
+            this.ControlTextBrush = null;
+            this.GrayTextBrush = null;
+            this.WindowBrush = null;
+            this.WindowTextBrush = null;
+
+            // Handle Button-specific resources
+            this.Button_Disabled_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xF4, 0xF4, 0xF4));
+            this.Button_MouseOver_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xBE, 0xE6, 0xFD));
+            this.Button_Pressed_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xC4, 0xE5, 0xF6));
+            this.Button_Static_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xDD, 0xDD, 0xDD));
+
+            // Handle ComboBox-specific resources
+            this.ComboBox_Disabled_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0));
+            this.ComboBox_Disabled_Editable_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+            this.ComboBox_Disabled_Editable_Button_Background = Brushes.Transparent;
+            this.ComboBox_MouseOver_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xEC, 0xF4, 0xFC),
+                Color.FromArgb(0xFF, 0xDC, 0xEC, 0xFC),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.ComboBox_MouseOver_Editable_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+            this.ComboBox_MouseOver_Editable_Button_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xEB, 0xF4, 0xFC),
+                Color.FromArgb(0xFF, 0xDC, 0xEC, 0xFC),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.ComboBox_Pressed_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xDA, 0xEC, 0xFC),
+                Color.FromArgb(0xFF, 0xC4, 0xE0, 0xFC),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.ComboBox_Pressed_Editable_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+            this.ComboBox_Pressed_Editable_Button_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xDA, 0xEB, 0xFC),
+                Color.FromArgb(0xFF, 0xC4, 0xE0, 0xFC),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.ComboBox_Static_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0),
+                Color.FromArgb(0xFF, 0xE5, 0xE5, 0xE5),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.ComboBox_Static_Editable_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+            this.ComboBox_Static_Editable_Button_Background = Brushes.Transparent;
+
+            // Handle CustomMessageBox-specific resources
+            this.CustomMessageBox_Static_Background = null;
+
+            // Handle MenuItem-specific resources
+            this.MenuItem_SubMenu_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0));
+            this.MenuItem_SubMenu_Border = Brushes.DarkGray;
+
+            // Handle ProgressBar-specific resources
+            this.ProgressBar_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xE6, 0xE6, 0xE6));
+
+            // Handle ScrollViewer-specific resources
+            this.ScrollViewer_ScrollBar_Background = Brushes.LightGray;
+
+            // Handle TabItem-specific resources
+            this.TabItem_Selected_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+            this.TabItem_Static_Background = new LinearGradientBrush(
+                Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0),
+                Color.FromArgb(0xFF, 0xE5, 0xE5, 0xE5),
+                new Point(0, 0),
+                new Point(0, 1));
+            this.TabItem_Static_Border = Brushes.DarkGray;
+
+            // Handle TextBox-specific resources
+            this.TextBox_Static_Background = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
+        }
+    }
+
+    /// <summary>
+    /// Default dark-mode theme
+    /// </summary>
+    public class DarkModeTheme : Theme
+    {
+        public DarkModeTheme()
+        {
+            // Setup needed brushes
+            var darkModeBrush = new SolidColorBrush { Color = Color.FromArgb(0xff, 0x20, 0x20, 0x20) };
+
+            // Handle application-wide resources
+            this.ActiveBorderBrush = Brushes.Black;
+            this.ControlBrush = darkModeBrush;
+            this.ControlTextBrush = Brushes.White;
+            this.GrayTextBrush = Brushes.DarkGray;
+            this.WindowBrush = darkModeBrush;
+            this.WindowTextBrush = Brushes.White;
+
+            // Handle Button-specific resources
+            this.Button_Disabled_Background = darkModeBrush;
+            this.Button_MouseOver_Background = darkModeBrush;
+            this.Button_Pressed_Background = darkModeBrush;
+            this.Button_Static_Background = darkModeBrush;
+
+            // Handle ComboBox-specific resources
+            this.ComboBox_Disabled_Background = darkModeBrush;
+            this.ComboBox_Disabled_Editable_Background = darkModeBrush;
+            this.ComboBox_Disabled_Editable_Button_Background = darkModeBrush;
+            this.ComboBox_MouseOver_Background = darkModeBrush;
+            this.ComboBox_MouseOver_Editable_Background = darkModeBrush;
+            this.ComboBox_MouseOver_Editable_Button_Background = darkModeBrush;
+            this.ComboBox_Pressed_Background = darkModeBrush;
+            this.ComboBox_Pressed_Editable_Background = darkModeBrush;
+            this.ComboBox_Pressed_Editable_Button_Background = darkModeBrush;
+            this.ComboBox_Static_Background = darkModeBrush;
+            this.ComboBox_Static_Editable_Background = darkModeBrush;
+            this.ComboBox_Static_Editable_Button_Background = darkModeBrush;
+
+            // Handle CustomMessageBox-specific resources
+            this.CustomMessageBox_Static_Background = darkModeBrush;
+
+            // Handle MenuItem-specific resources
+            this.MenuItem_SubMenu_Background = darkModeBrush;
+            this.MenuItem_SubMenu_Border = Brushes.DarkGray;
+
+            // Handle ProgressBar-specific resources
+            this.ProgressBar_Background = darkModeBrush;
+
+            // Handle ScrollViewer-specific resources
+            this.ScrollViewer_ScrollBar_Background = darkModeBrush;
+
+            // Handle TabItem-specific resources
+            this.TabItem_Selected_Background = darkModeBrush;
+            this.TabItem_Static_Background = darkModeBrush;
+            this.TabItem_Static_Border = Brushes.DarkGray;
+
+            // Handle TextBox-specific resources
+            this.TextBox_Static_Background = darkModeBrush;
+        }
+    }
+}

MPF.UI.Core/UserControls/LogOutput.xaml

@@ -0,0 +1,31 @@
+<UserControl x:Class="MPF.UI.Core.UserControls.LogOutput"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid>
+        <StackPanel Orientation="Vertical">
+            <Grid Height="22" Margin="10 10 10 0">
+                <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" 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" Style="{DynamicResource CustomButtonStyle}" />
+                    <Button Name="SaveButton" Height="25" Width="80" Content="Save" Style="{DynamicResource CustomButtonStyle}" />
+                    <Label/> <!-- Empty label for padding -->
+                </UniformGrid>
+            </GroupBox>
+        </StackPanel>
+    </Grid>
+</UserControl>

MPF.UI.Core/UserControls/LogOutput.xaml.cs

@@ -0,0 +1,228 @@
+using System;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Media;
+using System.Windows.Threading;
+using MPF.Core.Data;
+
+namespace MPF.UI.Core.UserControls
+{
+    public partial class LogOutput : UserControl
+    {
+        /// <summary>
+        /// Document representing the text
+        /// </summary>
+        internal FlowDocument Document { get; private set; }
+
+        /// <summary>
+        /// Queue of items that need to be logged
+        /// </summary>
+        internal ProcessingQueue<LogLine> LogQueue { get; private set; }
+
+        /// <summary>
+        /// Paragraph backing the log
+        /// </summary>
+        private readonly Paragraph _paragraph;
+
+        /// <summary>
+        /// Cached value of the last line written
+        /// </summary>
+#if NET48
+        private Run lastLine = null;
+#else
+        private Run? lastLine = null;
+#endif
+
+        public LogOutput()
+        {
+            InitializeComponent();
+
+            // Update the internal state
+            Document = new FlowDocument()
+            {
+                Background = new SolidColorBrush(Color.FromArgb(0xFF, 0x20, 0x20, 0x20))
+            };
+            _paragraph = new Paragraph();
+            Document.Blocks.Add(_paragraph);
+
+            // Setup the processing queue
+            LogQueue = new ProcessingQueue<LogLine>(ProcessLogLine);
+
+            // Add handlers
+            OutputViewer.SizeChanged += OutputViewerSizeChanged;
+            Output.TextChanged += OnTextChanged;
+            ClearButton.Click += OnClearButton;
+            SaveButton.Click += OnSaveButton;
+
+            // Update the internal state
+            Output.Document = Document;
+        }
+
+        #region Logging
+
+        /// <summary>
+        /// Enqueue text to the log with formatting
+        /// </summary>
+        /// <param name="logLevel">LogLevel for the log</param>
+        /// <param name="text">Text to write to the log</param>
+        public void EnqueueLog(LogLevel logLevel, string text)
+        {
+            // Null text gets ignored
+            if (text == null)
+                return;
+
+            // Enqueue the text
+            LogQueue.Enqueue(new LogLine(text, logLevel));
+        }
+
+        /// <summary>
+        /// Log line wrapper
+        /// </summary>
+        internal readonly 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>
+        /// Process the log lines in the queue
+        /// </summary>
+        /// <param name="nextLogLine">LogLine item to process</param>
+        internal void ProcessLogLine(LogLine nextLogLine)
+        {
+            // Null text gets ignored
+            string nextText = nextLogLine.Text;
+            if (nextText == null)
+                return;
+
+            try
+            {
+                if (nextText.StartsWith("\r"))
+                    ReplaceLastLine(nextLogLine);
+                else
+                    AppendToTextBox(nextLogLine);
+            }
+            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>
+        /// 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(() =>
+            {
+#if NET48
+                if (lastLine == null) lastLine = new Run();
+#else
+                lastLine ??= new Run();
+#endif
+                lastLine.Text = logLine.Text;
+                lastLine.Foreground = logLine.GetForegroundColor();
+            });
+        }
+
+#endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Clear all inlines of the paragraph
+        /// </summary>
+        private void ClearInlines() => _paragraph.Inlines.Clear();
+
+        /// <summary>
+        /// Save all inlines to console.log
+        /// </summary>
+        private void SaveInlines()
+        {
+            using (var sw = new StreamWriter(File.OpenWrite("console.log")))
+            {
+                foreach (var inline in _paragraph.Inlines)
+                {
+                    if (inline is Run run)
+                        sw.Write(run.Text);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Scroll the current view to the bottom
+        /// </summary>
+        public void ScrollToBottom() => OutputViewer.ScrollToBottom();
+
+        #endregion
+
+        #region EventHandlers
+
+        private void OnClearButton(object sender, EventArgs e)
+            => ClearInlines();
+
+        private void OnSaveButton(object sender, EventArgs e)
+            => SaveInlines();
+
+        private void OnTextChanged(object sender, TextChangedEventArgs e)
+            => ScrollToBottom();
+
+        private void OutputViewerSizeChanged(object sender, SizeChangedEventArgs e)
+            => ScrollToBottom();
+
+        #endregion
+    }
+}

MPF.UI.Core/UserControls/UserInput.xaml

@@ -0,0 +1,30 @@
+<UserControl x:Class="MPF.UI.Core.UserControls.UserInput"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800" x:Name="userInput">
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="0.75*" />
+            <ColumnDefinition Width="1.25*" />
+        </Grid.ColumnDefinitions>
+
+        <Label Grid.Row="0" Grid.Column="0"
+               VerticalAlignment="Center"
+               HorizontalAlignment="Right"
+               Content="{Binding ElementName=userInput, Path=Label}" />
+        
+        <TextBox Grid.Row="0" Grid.Column="1"
+                 Height="{Binding ElementName=userInput, Path=TextHeight}"
+                 HorizontalAlignment="Stretch"
+                 Text="{Binding ElementName=userInput, Path=Text}"
+                 AcceptsTab="{Binding ElementName=userInput, Path=Tab}"
+                 AcceptsReturn="{Binding ElementName=userInput, Path=Enter}"
+                 TextWrapping="{Binding ElementName=userInput, Path=TextWrapping}"
+                 IsReadOnly="{Binding ElementName=userInput, Path=IsReadOnly}"
+                 VerticalContentAlignment="{Binding ElementName=userInput, Path=VerticalContentAlignmentValue}"
+                 HorizontalScrollBarVisibility="{Binding ElementName=userInput, Path=HorizontalScrollBarVisibility}"
+                 VerticalScrollBarVisibility="{Binding ElementName=userInput, Path=VerticalScrollBarVisibility}"/>
+    </Grid>
+</UserControl>

MPF.UI.Core/UserControls/UserInput.xaml.cs

@@ -0,0 +1,124 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace MPF.UI.Core.UserControls
+{
+    /// <summary>
+    /// Interaction logic for UserInput.xaml
+    /// </summary>
+    public partial class UserInput : UserControl
+    {
+        #region Dependency Properties
+
+        public static readonly DependencyProperty LabelProperty =
+            DependencyProperty.Register("Label", typeof(string), typeof(UserInput));
+
+        public static readonly DependencyProperty TextProperty =
+            DependencyProperty.Register("Text", typeof(string), typeof(UserInput));
+
+        public static readonly DependencyProperty TextHeightProperty =
+            DependencyProperty.Register("TextHeight", typeof(string), typeof(UserInput));
+
+        public static readonly DependencyProperty TabProperty =
+            DependencyProperty.Register("Tab", typeof(bool), typeof(UserInput));
+
+        public static readonly DependencyProperty EnterProperty =
+            DependencyProperty.Register("Enter", typeof(bool), typeof(UserInput));
+
+        public static readonly DependencyProperty TextWrappingProperty =
+            DependencyProperty.Register("TextWrapping", typeof(TextWrapping), typeof(UserInput));
+
+        public static readonly DependencyProperty IsReadOnlyProperty =
+            DependencyProperty.Register("IsReadOnly", typeof(bool), typeof(UserInput));
+
+        public static readonly DependencyProperty VerticalContentAlignmentValueProperty =
+            DependencyProperty.Register("VerticalContentAlignmentValue", typeof(VerticalAlignment), typeof(UserInput));
+
+        public static readonly DependencyProperty HorizontalScrollBarVisibilityProperty =
+            DependencyProperty.Register("HorizontalScrollBarVisibility", typeof(ScrollBarVisibility), typeof(UserInput));
+
+        public static readonly DependencyProperty VerticalScrollBarVisibilityProperty =
+            DependencyProperty.Register("VerticalScrollBarVisibility", typeof(ScrollBarVisibility), typeof(UserInput));
+        
+        #endregion
+
+        #region Properties
+
+        public string Label
+        {
+            get => (string)GetValue(LabelProperty);
+            set => SetValue(LabelProperty, value);
+        }
+
+        public string Text
+        {
+            get => (string)GetValue(TextProperty);
+            set => SetValue(TextProperty, value);
+        }
+
+        public string TextHeight
+        {
+            get => (string)GetValue(TextHeightProperty);
+            set => SetValue(TextHeightProperty, value);
+        }
+
+        public bool Tab
+        {
+            get => (bool)GetValue(TabProperty);
+            set => SetValue(TabProperty, value);
+        }
+
+        public bool Enter
+        {
+            get => (bool)GetValue(EnterProperty);
+            set => SetValue(EnterProperty, value);
+        }
+
+        public TextWrapping TextWrapping
+        {
+            get => (TextWrapping)GetValue(TextWrappingProperty);
+            set => SetValue(TextWrappingProperty, value);
+        }
+
+        public bool IsReadOnly
+        {
+            get => (bool)GetValue(IsReadOnlyProperty);
+            set => SetValue(IsReadOnlyProperty, value);
+        }
+
+        public VerticalAlignment VerticalContentAlignmentValue
+        {
+            get => (VerticalAlignment)GetValue(VerticalContentAlignmentValueProperty);
+            set => SetValue(VerticalContentAlignmentValueProperty, value);
+        }
+
+        public ScrollBarVisibility HorizontalScrollBarVisibility
+        {
+            get => (ScrollBarVisibility)GetValue(HorizontalScrollBarVisibilityProperty);
+            set => SetValue(HorizontalScrollBarVisibilityProperty, value);
+        }
+
+        public ScrollBarVisibility VerticalScrollBarVisibility
+        {
+            get => (ScrollBarVisibility)GetValue(VerticalScrollBarVisibilityProperty);
+            set => SetValue(VerticalScrollBarVisibilityProperty, value);
+        }
+
+        #endregion
+
+        public UserInput()
+        {
+            // Set default values
+            TextHeight = "22";
+            Tab = false;
+            Enter = false;
+            TextWrapping = TextWrapping.NoWrap;
+            IsReadOnly = false;
+            VerticalContentAlignmentValue = VerticalAlignment.Center;
+            HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden;
+            VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
+
+            InitializeComponent();
+        }
+    }
+}

MPF.UI.Core/Windows/DiscInformationWindow.xaml

@@ -0,0 +1,480 @@
+<windows:WindowBase x:Class="MPF.UI.Core.Windows.DiscInformationWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:controls="clr-namespace:MPF.UI.Core.UserControls"
+        xmlns:core="clr-namespace:MPF.UI.Core"
+        xmlns:redump="clr-namespace:SabreTools.RedumpLib.Data;assembly=SabreTools.RedumpLib"
+        xmlns:windows="clr-namespace:MPF.UI.Core.Windows"
+        mc:Ignorable="d"
+        Title="Disc Information" Width="515" WindowStyle="None"
+        WindowStartupLocation="CenterOwner" ResizeMode="CanMinimize" SizeToContent="Height"
+        BorderBrush="DarkGray" BorderThickness="2">
+
+    <Window.Resources>
+        <core:ElementConverter x:Key="ElementConverter" />
+    </Window.Resources>
+    <WindowChrome.WindowChrome>
+        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
+    </WindowChrome.WindowChrome>
+    
+    <Grid>
+        <StackPanel Orientation="Vertical" Width="500" MaxHeight="650">
+            <Grid 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">
+                    <Label.Content>
+                        <TextBlock TextAlignment="Center"><Bold>Disc Information</Bold></TextBlock>
+                    </Label.Content>
+                    <Label.ContextMenu>
+                        <ContextMenu Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                     Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                     Style="{DynamicResource CustomContextMenuStyle}">
+                            <MenuItem Header="Minimize" Click="MinimizeButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      BorderBrush="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                            <MenuItem Header="Close" Click="CloseButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      BorderBrush="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                        </ContextMenu>
+                    </Label.ContextMenu>
+                </Label>
+                <Grid Grid.Column="5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                    </Grid.ColumnDefinitions>
+
+                    <Button x:Name="MinimizeButton" Grid.Column="0" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="MinimizeButtonClick">
+                        <Path Data="M 0,0 L 10,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                    <Button x:Name="CloseButton" Grid.Column="1" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="CloseButtonClick">
+                        <Path Data="M 0,0 L 12,12 M 0,12 L 12,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                </Grid>
+            </Grid>
+
+            <TabControl Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                        Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                        Style="{DynamicResource CustomTabControlStyle}">
+                <TabItem x:Name="CommonInfo" Header="Common Info" Style="{DynamicResource CustomTabItemStyle}">
+                    <ScrollViewer CanContentScroll="False" VerticalScrollBarVisibility="Auto" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" MaxHeight="500">
+                        <StackPanel Orientation="Vertical">
+                            <GroupBox Header="Common Disc Information" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                  HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput Label="Title"
+                                                    Text="{Binding SubmissionInfo.CommonDiscInfo.Title, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="AlternativeTitleTextBox" Label="Alternative Title"
+                                                    Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)AlternativeTitle], Mode=TwoWay}"/>
+                                    <controls:UserInput Label="Foreign Title (Non-Latin)" 
+                                                    Text="{Binding SubmissionInfo.CommonDiscInfo.ForeignTitleNonLatin, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="AlternativeForeignTitleTextBox" Label="Alternative Foreign Title"
+                                                    Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)AlternativeForeignTitle], Mode=TwoWay}"/>
+                                    <controls:UserInput Label="Disc Number / Letter"
+                                                    Text="{Binding SubmissionInfo.CommonDiscInfo.DiscNumberLetter, Mode=TwoWay}"/>
+                                    <controls:UserInput Label="Disc Title"
+                                                    Text="{Binding SubmissionInfo.CommonDiscInfo.DiscTitle, Mode=TwoWay}"/>
+
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label x:Name="CategoryLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Category" />
+                                        <ComboBox x:Name="CategoryComboBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                                  ItemsSource="{Binding Categories}" SelectedItem="{Binding SubmissionInfo.CommonDiscInfo.Category, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                                  Style="{DynamicResource CustomComboBoxStyle}" />
+                                    </Grid>
+
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label x:Name="RegionLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Region" />
+                                        <ComboBox x:Name="RegionComboBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                                  ItemsSource="{Binding Regions}" SelectedItem="{Binding SubmissionInfo.CommonDiscInfo.Region, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                                  Style="{DynamicResource CustomComboBoxStyle}" />
+                                    </Grid>
+
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label x:Name="LanguagesLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Languages" />
+                                        <ComboBox x:Name="LanguagesComboBox" Grid.Row="0" Grid.Column="1" Height="24" HorizontalAlignment="Stretch"
+                                                  ItemsSource="{Binding Languages}"
+                                          SelectedIndex="0" Style="{DynamicResource CustomComboBoxStyle}">
+                                            <ComboBox.ItemTemplate>
+                                                <DataTemplate>
+                                                    <CheckBox Content="{Binding Name}" IsChecked="{Binding IsChecked}" />
+                                                </DataTemplate>
+                                            </ComboBox.ItemTemplate>
+                                        </ComboBox>
+                                    </Grid>
+
+                                    <Grid x:Name="LanguageSelectionGrid" Visibility="Collapsed">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label x:Name="LanguageSelectionLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Language Selection Via" />
+                                        <ComboBox x:Name="LanguageSelectionComboBox" Grid.Row="0" Grid.Column="1" Height="24" HorizontalAlignment="Stretch"
+                                                  ItemsSource="{Binding LanguageSelections}"
+                                          SelectedIndex="0" Style="{DynamicResource CustomComboBoxStyle}">
+                                            <ComboBox.ItemTemplate>
+                                                <DataTemplate>
+                                                    <CheckBox Content="{Binding Name}" IsChecked="{Binding IsChecked}" />
+                                                </DataTemplate>
+                                            </ComboBox.ItemTemplate>
+                                        </ComboBox>
+                                    </Grid>
+
+                                    <controls:UserInput Label="Serial" Text="{Binding SubmissionInfo.CommonDiscInfo.Serial, Mode=TwoWay}"/>
+                                    <controls:UserInput Label="Barcode" Text="{Binding SubmissionInfo.CommonDiscInfo.Barcode, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox Header="Version and Editions" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                  HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput Label="Version" Text="{Binding SubmissionInfo.VersionAndEditions.Version, Mode=TwoWay}"/>
+                                    <controls:UserInput Label="Edition" Text="{Binding SubmissionInfo.VersionAndEditions.OtherEditions, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+                        </StackPanel>
+                    </ScrollViewer>
+                </TabItem>
+
+                <TabItem Header="Additional Info" Style="{DynamicResource CustomTabItemStyle}">
+                    <ScrollViewer CanContentScroll="False" VerticalScrollBarVisibility="Auto" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" MaxHeight="500">
+                        <StackPanel Orientation="Vertical">
+                            <GroupBox Header="Extras" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="CommentsTextBox" Label="Comments"
+                                                        Text="{Binding SubmissionInfo.CommonDiscInfo.Comments, Mode=TwoWay}" TextHeight="50"
+                                                        Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top" />
+                                    <controls:UserInput x:Name="GenreTextBox" Label="Genre"
+                                                    Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)Genre], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ProtectionTextBox" Label="Protection" ToolTip="CAUTION: Only edit if you know what you are doing!"
+                                                        Text="{Binding SubmissionInfo.CopyProtection.Protection, Mode=TwoWay}" TextHeight="75" TextWrapping="Wrap"
+                                                        VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label/>
+                                        <CheckBox Grid.Column="1" x:Name="PostgapTypeCheckBox" Content="Postgap type (Form 2)" Margin="0,4"
+                                                  IsChecked="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)PostgapType], Mode=TwoWay}"/>
+                                    </Grid>
+                                    <controls:UserInput x:Name="SeriesTextBox" Label="Series"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)Series], Mode=TwoWay}"/>
+                                    <Grid>
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.75*" />
+                                            <ColumnDefinition Width="1.25*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <Label/>
+                                        <CheckBox Grid.Column="1" x:Name="VCDCheckBox" Content="V-CD" Margin="0,4"
+                                                  IsChecked="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)VCD], Mode=TwoWay}"/>
+                                    </Grid>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox Header="Physical Identifiers" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="BBFCRegistrationNumberTextBox" Label="BBFC Reg. No."
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)BBFCRegistrationNumber], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="DiscHologramIDTextBox" Label="Disc Hologram ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)DiscHologramID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="DNASDiscIDTextBox" Label="DNAS Disc ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)DNASDiscID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ISBNTextBox" Label="ISBN"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ISBN], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ISSNTextBox" Label="ISSN"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ISSN], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="PPNTextBox" Label="PPN"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)PPN], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="VFCCodeTextBox" Label="VFC code"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)VFCCode], Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox Header="Publisher Identifiers" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                              HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="AcclaimIDTextBox" Label="Acclaim ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)AcclaimID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ActivisionIDTextBox" Label="Activision ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ActivisionID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="BandaiIDTextBox" Label="Bandai ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)BandaiID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="CDProjektIDTextBox" Label="CD Projekt ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)CDProjektID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ElectronicArtsIDTextBox" Label="Electronic Arts ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ElectronicArtsID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="FoxInteractiveIDTextBox" Label="Fox Interactive ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)FoxInteractiveID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="GTInteractiveIDTextBox" Label="GT Interactive ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)GTInteractiveID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="JASRACIDTextBox" Label="JASRAC ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)JASRACID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="KingRecordsIDTextBox" Label="King Records ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)KingRecordsID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="KoeiIDTextBox" Label="Koei ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)KoeiID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="KonamiIDTextBox" Label="Konami ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)KonamiID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="LucasArtsIDTextBox" Label="LucasArts ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)LucasArtsID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="MicrosoftIDTextBox" Label="Microsoft ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)MicrosoftID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="NaganoIDTextBox" Label="Nagano ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)NaganoID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="NamcoIDTextBox" Label="Namco ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)NamcoID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="NipponIchiSoftwareIDTextBox" Label="Nippon Ichi Software ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)NipponIchiSoftwareID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="OriginIDTextBox" Label="Origin ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)OriginID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="PonyCanyonIDTextBox" Label="Pony Canyon ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)PonyCanyonID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="SegaIDTextBox" Label="Sega ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)SegaID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="SelenIDTextBox" Label="Selen ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)SelenID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="SierraIDTextBox" Label="Sierra ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)SierraID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="TaitoIDTextBox" Label="Taito ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)TaitoID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="UbisoftIDTextBox" Label="Ubisoft ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)UbisoftID], Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="ValveIDTextBox" Label="Valve ID"
+                                                        Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)ValveID], Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+                        </StackPanel>
+                    </ScrollViewer>
+                </TabItem>
+
+                <TabItem Header="Contents" Style="{DynamicResource CustomTabItemStyle}">
+                    <ScrollViewer CanContentScroll="False" VerticalScrollBarVisibility="Auto" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" MaxHeight="500">
+                        <StackPanel Orientation="Vertical">
+                            <controls:UserInput x:Name="GeneralContent" Label="General"
+                                                Text="{Binding SubmissionInfo.CommonDiscInfo.Contents, Mode=TwoWay}" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"/>
+                            
+                            <!-- Games -->
+                            <controls:UserInput x:Name="GamesTextBox" Label="Games" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Games], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="NetYarozeGamesTextBox" Label="Net Yaroze Games" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)NetYarozeGames], Mode=TwoWay}"/>
+                            
+                            <!-- Demos -->
+                            <controls:UserInput x:Name="PlayableDemosTextBox" Label="Playable Demos" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)PlayableDemos], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="RollingDemosTextBox" Label="Rolling Demos" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)RollingDemos], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="TechDemosTextBox" Label="Tech Demos" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)TechDemos], Mode=TwoWay}"/>
+
+                            <!-- Video -->
+                            <controls:UserInput x:Name="GameFootageTextBox" Label="Game Footage" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)GameFootage], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="VideosTextBox" Label="Videos" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Videos], Mode=TwoWay}"/>
+
+                            <!-- Miscellaneous -->
+                            <controls:UserInput x:Name="PatchesTextBox" Label="Patches" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Patches], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="SavegamesTextBox" Label="Savegames" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Savegames], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="ExtrasTextBox" Label="Extras" TextHeight="50"
+                                                Enter="True" TextWrapping="Wrap" VerticalContentAlignmentValue="Top"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.ContentsSpecialFields[(redump:SiteCode)Extras], Mode=TwoWay}"/>
+                        </StackPanel>
+                    </ScrollViewer>
+                </TabItem>
+
+                <TabItem Header="Ringcodes" Style="{DynamicResource CustomTabItemStyle}">
+                    <ScrollViewer CanContentScroll="False" VerticalScrollBarVisibility="Auto" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" MaxHeight="500">
+                        <StackPanel Orientation="Vertical">
+                            <GroupBox x:Name="L0Info" Header="Data/L0 Info" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="L0MasteringRing" Label="Data/L0 Mastering Ring"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer0MasteringRing, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L0MasteringSID" Label="Data/L0 Mastering SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer0MasteringSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L0Toolstamp" Label="Data/L0 Toolstamp/Mastering Code"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer0ToolstampMasteringCode, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L0MouldSID" Label="Data/L0 Mould SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer0MouldSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L0AdditionalMould" Label="Data/L0 Additional Mould"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer0AdditionalMould, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox x:Name="L1Info" Header="Label/L1 Info" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="L1MasteringRing" Label="Label/L1 Mastering Ring"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer1MasteringRing, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L1MasteringSID" Label="Label/L1 Mastering SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer1MasteringSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L1Toolstamp" Label="Label/L1 Toolstamp/Mastering Code"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer1ToolstampMasteringCode, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L1MouldSID" Label="Label/L1 Mould SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer1MouldSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L1AdditionalMould" Label="Label/L1 Additional Mould"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer1AdditionalMould, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox x:Name="L2Info" Header="L2 Info" Visibility="Collapsed" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="L2MasteringRing" Label="L2 Mastering Ring"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer2MasteringRing, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L2MasteringSID" Label="L2 Mastering SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer2MasteringSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L2Toolstamp" Label="L2 Toolstamp/Mastering Code"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer2ToolstampMasteringCode, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+
+                            <GroupBox x:Name="L3Info" Header="L3 Info" Visibility="Collapsed" Margin="5" Padding="5" BorderThickness="1" BorderBrush="LightGray"
+                                      HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                                <StackPanel Orientation="Vertical">
+                                    <controls:UserInput x:Name="L3MasteringRing" Label="L3 Mastering Ring"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer3MasteringRing, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L3MasteringSID" Label="L3 Mastering SID"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer3MasteringSID, Mode=TwoWay}"/>
+                                    <controls:UserInput x:Name="L3Toolstamp" Label="L3 Toolstamp/Mastering Code"
+                                            Text="{Binding SubmissionInfo.CommonDiscInfo.Layer3ToolstampMasteringCode, Mode=TwoWay}"/>
+                                </StackPanel>
+                            </GroupBox>
+                        </StackPanel>
+                    </ScrollViewer>
+                </TabItem>
+
+                <TabItem Header="Read-Only Info" Style="{DynamicResource CustomTabItemStyle}">
+                    <ScrollViewer CanContentScroll="False" VerticalScrollBarVisibility="Auto" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" MaxHeight="500">
+                        <StackPanel Orientation="Vertical">
+                            <controls:UserInput x:Name="FullyMatchedID" Label="Fully Matched ID" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.FullyMatchedID, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="PartiallyMatchedIDs" Label="Partially Matched ID(s)" IsReadOnly="True"/>
+                            <controls:UserInput x:Name="AntiModchip" Label="Anti-Modchip" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CopyProtection.AntiModchip, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="DiscOffset" Label="Disc Offset" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.TracksAndWriteOffsets.OtherWriteOffsets, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="DMIHash" Label="DMI Hash" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)DMIHash], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="EDC" Label="EDC" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.EDC.EDC, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="ErrorsCount" Label="Error(s) Count" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CommonDiscInfo.ErrorsCount, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="EXEDateBuildDate" Label="EXE/Build Date" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CommonDiscInfo.EXEDateBuildDate, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="Filename" Label="Filename" IsReadOnly="True"
+                                                TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)Filename], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="Header" Label="Header" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.Extras.Header, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="InternalName" Label="Internal Names" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)InternalName], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="InternalSerialName" Label="Internal Serial" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)InternalSerialName], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="Multisession" Label="Multisession" IsReadOnly="True" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)Multisession], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="LibCrypt" Label="LibCrypt" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CopyProtection.LibCrypt, Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="LibCryptData" Label="LibCrypt Data" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CopyProtection.LibCryptData, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="PFIHash" Label="PFI Hash" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)PFIHash], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="PIC" Label="PIC" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.Extras.PIC, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="PVD" Label="PVD" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.Extras.PVD, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="RingNonZeroDataStart" Label="Ring Non-Zero Data Start" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)RingNonZeroDataStart], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="SecuROMData" Label="SecuROM Data" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.CopyProtection.SecuROMData, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="SSHash" Label="Security Sector Hash" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)SSHash], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="SecuritySectorRanges" Label="Security Sector Ranges" IsReadOnly="True"
+                                                Text="{Binding SubmissionInfo.Extras.SecuritySectorRanges, Mode=TwoWay}" TextHeight="75" TextWrapping="NoWrap"
+                                                VerticalContentAlignmentValue="Top" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto"/>
+                            <controls:UserInput x:Name="SSVersion" Label="Security Sector Version" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)SSVersion], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="UniversalHash" Label="Universal Hash (SHA-1)" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)UniversalHash], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="VolumeLabel" Label="Volume Label" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)VolumeLabel], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="XeMID" Label="XeMID" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)XeMID], Mode=TwoWay}"/>
+                            <controls:UserInput x:Name="XMID" Label="XMID" IsReadOnly="True"
+                                                Text="{Binding Path=SubmissionInfo.CommonDiscInfo.CommentsSpecialFields[(redump:SiteCode)XMID], Mode=TwoWay}"/>
+
+                            <!-- TODO: Add track/checksum data once there's a reasonable way to do so -->
+                        </StackPanel>
+                    </ScrollViewer>
+                </TabItem>
+            </TabControl>
+
+            <!-- Accept / Cancel -->
+            <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
+                <UniformGrid Columns="3" Margin="5,5,5,5" Height="28">
+                    <Button Name="AcceptButton" Height="25" Width="80" Content="Accept"
+                            Style="{DynamicResource CustomButtonStyle}" />
+                    <Button Name="CancelButton" Height="25" Width="80" Content="Cancel"
+                            Style="{DynamicResource CustomButtonStyle}" />
+                    <Button Name="RingCodeGuideButton" Grid.Column="2" Height="25" Width="120" Content="Ring Code Guide"
+                            Style="{DynamicResource CustomButtonStyle}" />
+                </UniformGrid>
+            </GroupBox>
+        </StackPanel>
+    </Grid>
+</windows:WindowBase>

MPF.UI.Core/Windows/DiscInformationWindow.xaml.cs

@@ -0,0 +1,402 @@
+using System.Linq;
+using System.Windows;
+using MPF.Core.Data;
+using MPF.Core.UI.ViewModels;
+using MPF.Core.Utilities;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.UI.Core.Windows
+{
+    /// <summary>
+    /// Interaction logic for DiscInformationWindow.xaml
+    /// </summary>
+    public partial class DiscInformationWindow : WindowBase
+    {
+        /// <summary>
+        /// Read-only access to the current disc information view model
+        /// </summary>
+        public DiscInformationViewModel DiscInformationViewModel => DataContext as DiscInformationViewModel ?? new DiscInformationViewModel(new Options(), new SubmissionInfo());
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+#if NET48
+        public DiscInformationWindow(Options options, SubmissionInfo submissionInfo)
+#else
+        public DiscInformationWindow(Options options, SubmissionInfo? submissionInfo)
+#endif
+        {
+            InitializeComponent();
+            DataContext = new DiscInformationViewModel(options, submissionInfo);
+            DiscInformationViewModel.Load();
+
+            // Limit lists, if necessary
+            if (options.EnableRedumpCompatibility)
+            {
+                DiscInformationViewModel.SetRedumpRegions();
+                DiscInformationViewModel.SetRedumpLanguages();
+            }
+
+            // Add handlers
+            AcceptButton.Click += OnAcceptClick;
+            CancelButton.Click += OnCancelClick;
+            RingCodeGuideButton.Click += OnRingCodeGuideClick;
+
+            // Update UI with new values
+            ManipulateFields(options, submissionInfo);
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Manipulate fields based on the current disc
+        /// </summary>
+#if NET48
+        private void ManipulateFields(Options options, SubmissionInfo submissionInfo)
+#else
+        private void ManipulateFields(Options options, SubmissionInfo? submissionInfo)
+#endif
+        {
+            // Enable tabs in all fields, if required
+            if (options.EnableTabsInInputFields)
+                EnableTabsInInputFields();
+
+            // Hide read-only fields that don't have values set
+            HideReadOnlyFields(submissionInfo);
+
+            // Different media types mean different fields available
+            UpdateFromDiscType(submissionInfo);
+
+            // Different systems mean different fields available
+            UpdateFromSystemType(submissionInfo);
+        }
+
+        /// <summary>
+        /// Enable tab entry on supported fields
+        /// </summary>
+        /// TODO: See if these can be done by binding
+        private void EnableTabsInInputFields()
+        {
+            // Additional Information
+            CommentsTextBox.Tab = true;
+
+            // Contents
+            GeneralContent.Tab = true;
+            GamesTextBox.Tab = true;
+            NetYarozeGamesTextBox.Tab = true;
+            PlayableDemosTextBox.Tab = true;
+            RollingDemosTextBox.Tab = true;
+            TechDemosTextBox.Tab = true;
+            GameFootageTextBox.Tab = true;
+            VideosTextBox.Tab = true;
+            PatchesTextBox.Tab = true;
+            SavegamesTextBox.Tab = true;
+            ExtrasTextBox.Tab = true;
+
+            // L0
+            L0MasteringRing.Tab = true;
+            L0MasteringSID.Tab = true;
+            L0Toolstamp.Tab = true;
+            L0MouldSID.Tab = true;
+            L0AdditionalMould.Tab = true;
+
+            // L1
+            L1MasteringRing.Tab = true;
+            L1MasteringSID.Tab = true;
+            L1Toolstamp.Tab = true;
+            L1MouldSID.Tab = true;
+            L1AdditionalMould.Tab = true;
+
+            // L2
+            L2MasteringRing.Tab = true;
+            L2MasteringSID.Tab = true;
+            L2Toolstamp.Tab = true;
+
+            // L3
+            L3MasteringRing.Tab = true;
+            L3MasteringSID.Tab = true;
+            L3Toolstamp.Tab = true;
+        }
+
+        /// <summary>
+        /// Hide any optional, read-only fields if they don't have a value
+        /// </summary>
+        /// TODO: Figure out how to bind the PartiallyMatchedIDs array to a text box
+        /// TODO: Convert visibility to a binding
+#if NET48
+        private void HideReadOnlyFields(SubmissionInfo submissionInfo)
+#else
+        private void HideReadOnlyFields(SubmissionInfo? submissionInfo)
+#endif
+        {
+            // If there's no submission information
+            if (submissionInfo == null)
+                return;
+
+            if (submissionInfo.FullyMatchedID == null)
+                FullyMatchedID.Visibility = Visibility.Collapsed;
+            if (submissionInfo.PartiallyMatchedIDs == null)
+                PartiallyMatchedIDs.Visibility = Visibility.Collapsed;
+            else
+                PartiallyMatchedIDs.Text = string.Join(", ", submissionInfo.PartiallyMatchedIDs);
+            if (submissionInfo.CopyProtection?.AntiModchip == null)
+                AntiModchip.Visibility = Visibility.Collapsed;
+            if (submissionInfo.TracksAndWriteOffsets?.OtherWriteOffsets == null)
+                DiscOffset.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.Keys?.Contains(SiteCode.DMIHash) != true)
+                DMIHash.Visibility = Visibility.Collapsed;
+            if (submissionInfo.EDC?.EDC == null)
+                EDC.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.CommonDiscInfo?.ErrorsCount))
+                ErrorsCount.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.CommonDiscInfo?.EXEDateBuildDate))
+                EXEDateBuildDate.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.Filename) != true)
+                Filename.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.Extras?.Header))
+                Header.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.InternalName) != true)
+                InternalName.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.InternalSerialName) != true)
+                InternalSerialName.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.Multisession) != true)
+                Multisession.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CopyProtection?.LibCrypt == null)
+                LibCrypt.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.CopyProtection?.LibCryptData))
+                LibCryptData.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.PFIHash) != true)
+                PFIHash.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.Extras?.PIC))
+                PIC.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.Extras?.PVD))
+                PVD.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.RingNonZeroDataStart) != true)
+                RingNonZeroDataStart.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.CopyProtection?.SecuROMData))
+                SecuROMData.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.SSHash) != true)
+                SSHash.Visibility = Visibility.Collapsed;
+            if (string.IsNullOrWhiteSpace(submissionInfo.Extras?.SecuritySectorRanges))
+                SecuritySectorRanges.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.SSVersion) != true)
+                SSVersion.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.UniversalHash) != true)
+                UniversalHash.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.VolumeLabel) != true)
+                VolumeLabel.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.XeMID) != true)
+                XeMID.Visibility = Visibility.Collapsed;
+            if (submissionInfo.CommonDiscInfo?.CommentsSpecialFields?.ContainsKey(SiteCode.XMID) != true)
+                XMID.Visibility = Visibility.Collapsed;
+        }
+
+        /// <summary>
+        /// Update visible fields and sections based on the media type
+        /// </summary>
+        /// TODO: See if these can be done by binding
+#if NET48
+        private void UpdateFromDiscType(SubmissionInfo submissionInfo)
+#else
+        private void UpdateFromDiscType(SubmissionInfo? submissionInfo)
+#endif
+        {
+            // Sony-printed discs have layers in the opposite order
+            var system = submissionInfo?.CommonDiscInfo?.System;
+            bool reverseOrder = system.HasReversedRingcodes();
+
+            switch (submissionInfo?.CommonDiscInfo?.Media)
+            {
+                case DiscType.CD:
+                case DiscType.GDROM:
+                    L0Info.Header = "Data Side";
+                    L0MasteringRing.Label = "Mastering Ring";
+                    L0MasteringSID.Label = "Mastering SID";
+                    L0Toolstamp.Label = "Toolstamp/Mastering Code";
+                    L0MouldSID.Label = "Mould SID";
+                    L0AdditionalMould.Label = "Additional Mould";
+
+                    L1Info.Header = "Label Side";
+                    L1MasteringRing.Visibility = Visibility.Collapsed;
+                    L1MasteringSID.Visibility = Visibility.Collapsed;
+                    L1Toolstamp.Visibility = Visibility.Collapsed;
+                    L1MouldSID.Label = "Mould SID";
+                    L1AdditionalMould.Label = "Additional Mould";
+                    break;
+
+                case DiscType.DVD5:
+                case DiscType.DVD9:
+                case DiscType.HDDVDSL:
+                case DiscType.HDDVDDL:
+                case DiscType.BD25:
+                case DiscType.BD33:
+                case DiscType.BD50:
+                case DiscType.BD66:
+                case DiscType.BD100:
+                case DiscType.BD128:
+                case DiscType.NintendoGameCubeGameDisc:
+                case DiscType.NintendoWiiOpticalDiscSL:
+                case DiscType.NintendoWiiOpticalDiscDL:
+                case DiscType.NintendoWiiUOpticalDiscSL:
+                    // Quad-layer discs
+                    if (submissionInfo?.SizeAndChecksums?.Layerbreak3 != default(long))
+                    {
+                        L2Info.Visibility = Visibility.Visible;
+                        L3Info.Visibility = Visibility.Visible;
+
+                        L0Info.Header = reverseOrder ? "Layer 0 (Outer)" : "Layer 0 (Inner)";
+                        L0MasteringRing.Label = "Mastering Ring";
+                        L0MasteringSID.Label = "Mastering SID";
+                        L0Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L0MouldSID.Label = "Data Side Mould SID";
+                        L0AdditionalMould.Label = "Data Side Additional Mould";
+
+                        L1Info.Header = "Layer 1";
+                        L1MasteringRing.Label = "Mastering Ring";
+                        L1MasteringSID.Label = "Mastering SID";
+                        L1Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L1MouldSID.Label = "Label Side Mould SID";
+                        L1AdditionalMould.Label = "Label Side Additional Mould";
+
+                        L2Info.Header = "Layer 2";
+                        L2MasteringRing.Label = "Mastering Ring";
+                        L2MasteringSID.Label = "Mastering SID";
+                        L2Toolstamp.Label = "Toolstamp/Mastering Code";
+
+                        L3Info.Header = reverseOrder ? "Layer 3 (Inner)" : "Layer 3 (Outer)";
+                        L3MasteringRing.Label = "Mastering Ring";
+                        L3MasteringSID.Label = "Mastering SID";
+                        L3Toolstamp.Label = "Toolstamp/Mastering Code";
+                    }
+
+                    // Triple-layer discs
+                    else if (submissionInfo?.SizeAndChecksums?.Layerbreak2 != default(long))
+                    {
+                        L2Info.Visibility = Visibility.Visible;
+
+                        L0Info.Header = reverseOrder ? "Layer 0 (Outer)" : "Layer 0 (Inner)";
+                        L0MasteringRing.Label = "Mastering Ring";
+                        L0MasteringSID.Label = "Mastering SID";
+                        L0Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L0MouldSID.Label = "Data Side Mould SID";
+                        L0AdditionalMould.Label = "Data Side Additional Mould";
+
+                        L1Info.Header = "Layer 1";
+                        L1MasteringRing.Label = "Mastering Ring";
+                        L1MasteringSID.Label = "Mastering SID";
+                        L1Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L1MouldSID.Label = "Label Side Mould SID";
+                        L1AdditionalMould.Label = "Label Side Additional Mould";
+
+                        L2Info.Header = reverseOrder ? "Layer 2 (Inner)" : "Layer 2 (Outer)";
+                        L2MasteringRing.Label = "Mastering Ring";
+                        L2MasteringSID.Label = "Mastering SID";
+                        L2Toolstamp.Label = "Toolstamp/Mastering Code";
+                    }
+
+                    // Double-layer discs
+                    else if (submissionInfo?.SizeAndChecksums?.Layerbreak != default(long))
+                    {
+                        L0Info.Header = reverseOrder ? "Layer 0 (Outer)" : "Layer 0 (Inner)";
+                        L0MasteringRing.Label = "Mastering Ring";
+                        L0MasteringSID.Label = "Mastering SID";
+                        L0Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L0MouldSID.Label = "Data Side Mould SID";
+                        L0AdditionalMould.Label = "Data Side Additional Mould";
+
+                        L1Info.Header = reverseOrder ? "Layer 1 (Inner)" : "Layer 1 (Outer)";
+                        L1MasteringRing.Label = "Mastering Ring";
+                        L1MasteringSID.Label = "Mastering SID";
+                        L1Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L1MouldSID.Label = "Label Side Mould SID";
+                        L1AdditionalMould.Label = "Label Side Additional Mould";
+                    }
+
+                    // Single-layer discs
+                    else
+                    {
+                        L0Info.Header = "Data Side";
+                        L0MasteringRing.Label = "Mastering Ring";
+                        L0MasteringSID.Label = "Mastering SID";
+                        L0Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L0MouldSID.Label = "Mould SID";
+                        L0AdditionalMould.Label = "Additional Mould";
+
+                        L1Info.Header = "Label Side";
+                        L1MasteringRing.Label = "Mastering Ring";
+                        L1MasteringSID.Label = "Mastering SID";
+                        L1Toolstamp.Label = "Toolstamp/Mastering Code";
+                        L1MouldSID.Label = "Mould SID";
+                        L1AdditionalMould.Label = "Additional Mould";
+                    }
+
+                    break;
+
+                // All other media we assume to have no rings
+                default:
+                    L0Info.Visibility = Visibility.Collapsed;
+                    L1Info.Visibility = Visibility.Collapsed;
+                    L2Info.Visibility = Visibility.Collapsed;
+                    L3Info.Visibility = Visibility.Collapsed;
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Update visible fields and sections based on the system type
+        /// </summary>
+        /// TODO: See if these can be done by binding
+#if NET48
+        private void UpdateFromSystemType(SubmissionInfo submissionInfo)
+#else
+        private void UpdateFromSystemType(SubmissionInfo? submissionInfo)
+#endif
+        {
+            var system = submissionInfo?.CommonDiscInfo?.System;
+            switch (system)
+            {
+                case RedumpSystem.SonyPlayStation2:
+                    LanguageSelectionGrid.Visibility = Visibility.Visible;
+                    break;
+            }
+        }
+
+#endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Handler for AcceptButton Click event
+        /// </summary>
+        private void OnAcceptClick(object sender, RoutedEventArgs e)
+        {
+            DiscInformationViewModel.Save();
+            DialogResult = true;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for CancelButton Click event
+        /// </summary>
+        private void OnCancelClick(object sender, RoutedEventArgs e)
+        {
+            DialogResult = false;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for RingCodeGuideButton Click event
+        /// </summary>
+        private void OnRingCodeGuideClick(object sender, RoutedEventArgs e)
+        {
+            var ringCodeGuideWindow = new RingCodeGuideWindow()
+            {
+                Owner = this,
+                WindowStartupLocation = WindowStartupLocation.CenterOwner,
+            };
+            ringCodeGuideWindow.Show();
+        }
+
+        #endregion
+    }
+}

MPF.UI.Core/Windows/MainWindow.xaml

@@ -0,0 +1,212 @@
+<coreWindows:WindowBase x:Class="MPF.UI.Core.Windows.MainWindow"
+                        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                        xmlns:controls="clr-namespace:MPF.UI.Core.UserControls"
+                        xmlns:core="clr-namespace:MPF.UI.Core"
+                        xmlns:coreWindows="clr-namespace:MPF.UI.Core.Windows"
+                        xmlns:viewModels="clr-namespace:MPF.Core.UI.ViewModels;assembly=MPF.Core"
+                        mc:Ignorable="d"
+                        Title="Media Preservation Frontend" Width="600" WindowStyle="None"
+                        WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize" SizeToContent="Height"
+                        BorderBrush="DarkGray" BorderThickness="2">
+
+    <Window.DataContext>
+        <viewModels:MainViewModel/>
+    </Window.DataContext>
+    <Window.Resources>
+        <core:ElementConverter x:Key="ElementConverter" />
+    </Window.Resources>
+    <WindowChrome.WindowChrome>
+        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
+    </WindowChrome.WindowChrome>
+
+    <Grid>
+        <StackPanel Orientation="Vertical">
+            <Grid Margin="0,2,0,0">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="25"/>
+                    <ColumnDefinition/>
+                    <ColumnDefinition/>
+                    <ColumnDefinition/>
+                    <ColumnDefinition/>
+                    <ColumnDefinition Width="50"/>
+                </Grid.ColumnDefinitions>
+
+                <Image Grid.Column="0" Source="/Images/Icon.ico" Height="20" Width="20" Margin="1" />
+                <StackPanel Panel.ZIndex="1" Grid.Column="1" VerticalAlignment="Center" Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}">
+                    <Menu x:Name="TopMenuBar" Width="Auto" Height="20"
+                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}">
+                        <MenuItem x:Name="FileMenuItem" Header="_File"
+                              Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                              Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                              Template="{DynamicResource CustomMenuItemTemplate}">
+                            <MenuItem x:Name="AppExitMenuItem" Header="E_xit" HorizontalAlignment="Left" Width="185"
+                                  Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                  Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                  Template="{DynamicResource CustomMenuItemTemplate}" />
+                        </MenuItem>
+                        <MenuItem x:Name="ToolsMenuItem" Header="_Tools"
+                              Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                              Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                              Template="{DynamicResource CustomMenuItemTemplate}">
+                            <MenuItem x:Name="OptionsMenuItem" Header="_Options" HorizontalAlignment="Left" Width="185"
+                                  Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                  Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                  Template="{DynamicResource CustomMenuItemTemplate}"
+                                  IsEnabled="{Binding OptionsMenuItemEnabled}"/>
+                            <MenuItem x:Name="DebugViewMenuItem" Header="_Debug Info Window" HorizontalAlignment="Left" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}" Visibility="Collapsed" />
+                        </MenuItem>
+                        <MenuItem x:Name="HelpMenuItem" Header="_Help"
+                              Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                              Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                              Template="{DynamicResource CustomMenuItemTemplate}">
+                            <MenuItem x:Name="AboutMenuItem" Header="_About" HorizontalAlignment="Left" Width="185"
+                                  Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                  Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                  Template="{DynamicResource CustomMenuItemTemplate}" />
+                            <MenuItem x:Name="CheckForUpdatesMenuItem" Header="_Check for Updates" HorizontalAlignment="Left" Width="185"
+                                  Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                  Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                  Template="{DynamicResource CustomMenuItemTemplate}" />
+                        </MenuItem>
+                    </Menu>
+                </StackPanel>
+                <Label Panel.ZIndex="0" Grid.Column="1" Grid.ColumnSpan="4" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" MouseDown="TitleMouseDown">
+                    <Label.Content>
+                        <TextBlock TextAlignment="Center"><Bold>Media Preservation Frontend</Bold></TextBlock>
+                    </Label.Content>
+                    <Label.ContextMenu>
+                        <ContextMenu Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                     Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                     Style="{DynamicResource CustomContextMenuStyle}">
+                            <MenuItem Header="Minimize" Click="MinimizeButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                            <MenuItem Header="Close" Click="CloseButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                        </ContextMenu>
+                    </Label.ContextMenu>
+                </Label>
+                <Grid Grid.Column="5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                    </Grid.ColumnDefinitions>
+
+                    <Button x:Name="MinimizeButton" Grid.Column="0" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="MinimizeButtonClick">
+                        <Path Data="M 0,0 L 10,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                    <Button x:Name="CloseButton" Grid.Column="1" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="CloseButtonClick">
+                        <Path Data="M 0,0 L 12,12 M 0,12 L 12,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                </Grid>
+            </Grid>
+
+            <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" Header="Settings">
+                <Grid Margin="5,5,5,5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="1*"/>
+                        <ColumnDefinition Width="2.5*"/>
+                    </Grid.ColumnDefinitions>
+                    <Grid.RowDefinitions>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                        <RowDefinition/>
+                    </Grid.RowDefinitions>
+
+                    <Label x:Name="SystemMediaTypeLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Content="System/Media Type" />
+                    <ComboBox x:Name="SystemTypeComboBox" Grid.Row="0" Grid.Column="1" Height="22" Width="250" HorizontalAlignment="Left"
+                              ItemsSource="{Binding Systems}" SelectedItem="{Binding Path=CurrentSystem, Converter={StaticResource ElementConverter}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                              IsEnabled="{Binding SystemTypeComboBoxEnabled}" Style="{DynamicResource CustomComboBoxStyle}">
+                        <ComboBox.ItemContainerStyle>
+                            <Style TargetType="{x:Type ComboBoxItem}">
+                                <Style.Triggers>
+                                    <DataTrigger Binding="{Binding IsHeader}" Value="True">
+                                        <Setter Property="IsEnabled" Value="False"/>
+                                    </DataTrigger>
+                                </Style.Triggers>
+                            </Style>
+                        </ComboBox.ItemContainerStyle>
+                    </ComboBox>
+                    <ComboBox x:Name="MediaTypeComboBox" Grid.Row="0" Grid.Column="1" Height="22" Width="140" HorizontalAlignment="Right"
+                              ItemsSource="{Binding MediaTypes}" SelectedItem="{Binding Path=CurrentMediaType, Converter={StaticResource ElementConverter}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                              IsEnabled="{Binding MediaTypeComboBoxEnabled}" Style="{DynamicResource CustomComboBoxStyle}" />
+
+                    <Label x:Name="OutputPathLabel" Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Content="Output Path"/>
+                    <TextBox x:Name="OutputPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" Width="345" HorizontalAlignment="Left" VerticalContentAlignment="Center"
+                             Text="{Binding OutputPath, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                             IsEnabled="{Binding OutputPathTextBoxEnabled}" />
+                    <Button x:Name="OutputPathBrowseButton" Grid.Row="1" Grid.Column="1" Height="22" Width="50" HorizontalAlignment="Right" Content="Browse"
+                            IsEnabled="{Binding OutputPathBrowseButtonEnabled}" Style="{DynamicResource CustomButtonStyle}"/>
+
+                    <Label x:Name="DriveLetterLabel" Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Content="Drive Letter"/>
+                    <ComboBox x:Name="DriveLetterComboBox" Grid.Row="2" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="Left"
+                              ItemsSource="{Binding Drives}" SelectedItem="{Binding Path=CurrentDrive, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                              IsEnabled="{Binding DriveLetterComboBoxEnabled}" Style="{DynamicResource CustomComboBoxStyle}">
+                        <ComboBox.ItemTemplate>
+                            <DataTemplate>
+                                <TextBlock Text="{Binding Letter}" />
+                            </DataTemplate>
+                        </ComboBox.ItemTemplate>
+                    </ComboBox>
+
+                    <Label x:Name="DriveSpeedLabel" Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" Content="Drive Speed"/>
+                    <ComboBox x:Name="DriveSpeedComboBox" Grid.Row="3" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="Left"
+                              ItemsSource="{Binding DriveSpeeds}" SelectedItem="{Binding Path=DriveSpeed, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                              IsEnabled="{Binding DriveSpeedComboBoxEnabled}" Style="{DynamicResource CustomComboBoxStyle}" />
+
+                    <Label x:Name="DumpingProgramLabel" Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" Content="Dumping Program"/>
+                    <ComboBox x:Name="DumpingProgramComboBox" Grid.Row="4" Grid.Column="1" Height="22" Width="250" HorizontalAlignment="Left"
+                              ItemsSource="{Binding InternalPrograms}" SelectedItem="{Binding Path=CurrentProgram, Converter={StaticResource ElementConverter}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                              IsEnabled="{Binding DumpingProgramComboBoxEnabled}" Style="{DynamicResource CustomComboBoxStyle}" />
+
+                    <Label x:Name="ParametersLabel" Grid.Row="5" Grid.Column="0" VerticalAlignment="Center" Content="Parameters"/>
+                    <TextBox x:Name="ParametersTextBox" Grid.Row="5" Grid.Column="1" Height="22" Width="370" HorizontalAlignment="Left" VerticalContentAlignment="Center"
+                             Text="{Binding Parameters, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                             IsEnabled="{Binding ParametersCheckBoxEnabled}"/>
+                    <CheckBox x:Name="EnableParametersCheckBox" Grid.Row="5" Grid.Column="1" Height="22" HorizontalAlignment="Right"
+                             IsChecked="{Binding ParametersCheckBoxEnabled, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                             IsEnabled="{Binding EnableParametersCheckBoxEnabled}"/>
+                </Grid>
+            </GroupBox>
+
+            <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" Header="Controls">
+                <UniformGrid Columns="4" Margin="5,5,5,5">
+                    <Button x:Name="StartStopButton" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" IsDefault="True"
+                            Content="{Binding StartStopButtonText, Mode=OneWay, UpdateSourceTrigger=PropertyChanged}"
+                            IsEnabled="{Binding StartStopButtonEnabled}" Style="{DynamicResource CustomButtonStyle}" />
+                    <Button x:Name="MediaScanButton" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Scan for discs"
+                            IsEnabled="{Binding MediaScanButtonEnabled}" Style="{DynamicResource CustomButtonStyle}" />
+                    <Button x:Name="UpdateVolumeLabel" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Update Label"
+                            IsEnabled="{Binding UpdateVolumeLabelEnabled}" Style="{DynamicResource CustomButtonStyle}" />
+                    <Button x:Name="CopyProtectScanButton" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Scan for protection"
+                            IsEnabled="{Binding CopyProtectScanButtonEnabled}" Style="{DynamicResource CustomButtonStyle}" />
+                </UniformGrid>
+            </GroupBox>
+
+            <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" Header="Status">
+                <UniformGrid Margin="5,5,5,5" Grid.ColumnSpan="2">
+                    <TextBlock x:Name="StatusLabel" VerticalAlignment="Center" HorizontalAlignment="Center"
+                               Text="{Binding Status, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
+                </UniformGrid>
+            </GroupBox>
+
+            <Expander Margin="5,5 5 5" MaxHeight="300" HorizontalAlignment="Stretch" Header="Log Output" x:Name="LogPanel"
+                      IsExpanded="{Binding LogPanelExpanded}">
+                <controls:LogOutput x:Name="LogOutput"/>
+            </Expander>
+        </StackPanel>
+    </Grid>
+</coreWindows:WindowBase>

MPF.UI.Core/Windows/MainWindow.xaml.cs

@@ -0,0 +1,470 @@
+using System;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using MPF.Core;
+using MPF.Core.UI.ViewModels;
+using SabreTools.RedumpLib.Data;
+using WPFCustomMessageBox;
+using WinForms = System.Windows.Forms;
+
+namespace MPF.UI.Core.Windows
+{
+    public partial class MainWindow : WindowBase
+    {
+        /// <summary>
+        /// Read-only access to the current main view model
+        /// </summary>
+        public MainViewModel MainViewModel => DataContext as MainViewModel ?? new MainViewModel();
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MainWindow() => InitializeComponent();
+
+        /// <summary>
+        /// Handler for MainWindow OnContentRendered event
+        /// </summary>
+        protected override void OnContentRendered(EventArgs e)
+        {
+            base.OnContentRendered(e);
+
+            // Disable buttons until we load fully
+            MainViewModel.StartStopButtonEnabled = false;
+            MainViewModel.MediaScanButtonEnabled = false;
+            MainViewModel.UpdateVolumeLabelEnabled = false;
+            MainViewModel.CopyProtectScanButtonEnabled = false;
+
+            // Add the click handlers to the UI
+            AddEventHandlers();
+
+            // Display the debug option in the menu, if necessary
+            if (MainViewModel.Options.ShowDebugViewMenuItem)
+                DebugViewMenuItem.Visibility = Visibility.Visible;
+
+            MainViewModel.Init(LogOutput.EnqueueLog, DisplayUserMessage, ShowDiscInformationWindow);
+
+            // Set the UI color scheme according to the options
+            ApplyTheme();
+
+            // Check for updates, if necessary
+            if (MainViewModel.Options.CheckForUpdatesOnStartup)
+                CheckForUpdates(showIfSame: false);
+
+            // Handle first-run, if necessary
+            if (MainViewModel.Options.FirstRun)
+            {
+                // Show the options window
+                ShowOptionsWindow("Welcome to MPF, Explore the Options");
+            }
+        }
+
+        #region UI Functionality
+
+        /// <summary>
+        /// Add all event handlers
+        /// </summary>
+        public void AddEventHandlers()
+        {
+            // Menu Bar Click
+            AboutMenuItem.Click += AboutClick;
+            AppExitMenuItem.Click += AppExitClick;
+            CheckForUpdatesMenuItem.Click += CheckForUpdatesClick;
+            DebugViewMenuItem.Click += DebugViewClick;
+            OptionsMenuItem.Click += OptionsMenuItemClick;
+
+            // User Area Click
+            CopyProtectScanButton.Click += CopyProtectScanButtonClick;
+            EnableParametersCheckBox.Click += EnableParametersCheckBoxClick;
+            MediaScanButton.Click += MediaScanButtonClick;
+            UpdateVolumeLabel.Click += UpdateVolumeLabelClick;
+            OutputPathBrowseButton.Click += OutputPathBrowseButtonClick;
+            StartStopButton.Click += StartStopButtonClick;
+
+            // User Area SelectionChanged
+            SystemTypeComboBox.SelectionChanged += SystemTypeComboBoxSelectionChanged;
+            MediaTypeComboBox.SelectionChanged += MediaTypeComboBoxSelectionChanged;
+            DriveLetterComboBox.SelectionChanged += DriveLetterComboBoxSelectionChanged;
+            DriveSpeedComboBox.SelectionChanged += DriveSpeedComboBoxSelectionChanged;
+            DumpingProgramComboBox.SelectionChanged += DumpingProgramComboBoxSelectionChanged;
+
+            // User Area TextChanged
+            OutputPathTextBox.TextChanged += OutputPathTextBoxTextChanged;
+        }
+
+        /// <summary>
+        /// Browse for an output file path
+        /// </summary>
+        public void BrowseFile()
+        {
+            // Get the current path, if possible
+            string currentPath = MainViewModel.OutputPath;
+            if (string.IsNullOrWhiteSpace(currentPath) && !string.IsNullOrWhiteSpace(MainViewModel.Options.DefaultOutputPath))
+                currentPath = Path.Combine(MainViewModel.Options.DefaultOutputPath, "track.bin");
+            else if (string.IsNullOrWhiteSpace(currentPath))
+                currentPath = "track.bin";
+            if (string.IsNullOrWhiteSpace(currentPath))
+                currentPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "track.bin");
+
+            // Get the full path
+            currentPath = Path.GetFullPath(currentPath);
+
+            // Get the directory
+            var directory = Path.GetDirectoryName(currentPath);
+
+            // Get the filename
+            string filename = Path.GetFileName(currentPath);
+
+            WinForms.FileDialog fileDialog = new WinForms.SaveFileDialog
+            {
+                FileName = filename,
+                InitialDirectory = directory,
+            };
+            WinForms.DialogResult result = fileDialog.ShowDialog();
+
+            if (result == WinForms.DialogResult.OK)
+            {
+                MainViewModel.OutputPath = fileDialog.FileName;
+            }
+        }
+
+        /// <summary>
+        /// Check for available updates
+        /// </summary>
+        /// <param name="showIfSame">True to show the box even if it's the same, false to only show if it's different</param>
+        public void CheckForUpdates(bool showIfSame)
+        {
+            (bool different, string message, var url) = MainViewModel.CheckForUpdates();
+
+            // If we have a new version, put it in the clipboard
+            if (different)
+                Clipboard.SetText(url);
+
+            if (showIfSame || different)
+                CustomMessageBox.Show(this, message, "Version Update Check", MessageBoxButton.OK, different ? MessageBoxImage.Exclamation : MessageBoxImage.Information);
+        }
+
+        /// <summary>
+        /// Display a user message using a CustomMessageBox
+        /// </summary>
+        /// <param name="title">Title to display to the user</param>
+        /// <param name="message">Message to display to the user</param>
+        /// <param name="optionCount">Number of options to display</param>
+        /// <param name="flag">true for inquiry, false otherwise</param>
+        /// <returns>true for positive, false for negative, null for neutral</returns>
+        public bool? DisplayUserMessage(string title, string message, int optionCount, bool flag)
+        {
+            // Set the correct button style
+            MessageBoxButton button;
+            switch (optionCount)
+            {
+                case 1:
+                    button = MessageBoxButton.OK;
+                    break;
+                case 2:
+                    button = MessageBoxButton.YesNo;
+                    break;
+                case 3:
+                    button = MessageBoxButton.YesNoCancel;
+                    break;
+
+                // This should not happen, but default to "OK"
+                default:
+                    button = MessageBoxButton.OK;
+                    break;
+            }
+
+            // Set the correct icon
+            MessageBoxImage image = flag ? MessageBoxImage.Question : MessageBoxImage.Exclamation;
+
+            // Display and get the result
+            MessageBoxResult result = CustomMessageBox.Show(this, message, title, button, image);
+            switch (result)
+            {
+                case MessageBoxResult.OK:
+                case MessageBoxResult.Yes:
+                    return true;
+
+                case MessageBoxResult.No:
+                    return false;
+
+                case MessageBoxResult.Cancel:
+                case MessageBoxResult.None:
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>
+        /// Build a dummy SubmissionInfo and display it for testing
+        /// </summary>
+        public void ShowDebugDiscInfoWindow()
+        {
+            var submissionInfo = MainViewModel.CreateDebugSubmissionInfo();
+            var result = ShowDiscInformationWindow(submissionInfo);
+            InfoTool.ProcessSpecialFields(result.Item2);
+        }
+
+        /// <summary>
+        /// Show the disc information window
+        /// </summary>
+        /// <param name="submissionInfo">SubmissionInfo object to display and possibly change</param>
+        /// <returns>Dialog open result</returns>
+#if NET48
+        public (bool?, SubmissionInfo) ShowDiscInformationWindow(SubmissionInfo submissionInfo)
+#else
+        public (bool?, SubmissionInfo?) ShowDiscInformationWindow(SubmissionInfo? submissionInfo)
+#endif
+        {
+            if (MainViewModel.Options.ShowDiscEjectReminder)
+                CustomMessageBox.Show(this, "It is now safe to eject the disc", "Eject", MessageBoxButton.OK, MessageBoxImage.Information);
+
+            var discInformationWindow = new DiscInformationWindow(MainViewModel.Options, submissionInfo)
+            {
+                Focusable = true,
+                Owner = this,
+                ShowActivated = true,
+                ShowInTaskbar = true,
+                WindowStartupLocation = WindowStartupLocation.CenterOwner,
+            };
+
+            discInformationWindow.Closed += delegate { this.Activate(); };
+            bool? result = discInformationWindow.ShowDialog();
+
+            // Copy back the submission info changes, if necessary
+            if (result == true)
+#if NET48
+                submissionInfo = discInformationWindow.DiscInformationViewModel.SubmissionInfo.Clone() as SubmissionInfo;
+#else
+                submissionInfo = (discInformationWindow.DiscInformationViewModel.SubmissionInfo.Clone() as SubmissionInfo)!;
+#endif
+
+#if NET48
+            return (result, submissionInfo);
+#else
+            return (result, submissionInfo!);
+#endif
+        }
+
+        /// <summary>
+        /// Show the Options window
+        /// </summary>
+#if NET48
+        public void ShowOptionsWindow(string title = null)
+#else
+        public void ShowOptionsWindow(string? title = null)
+#endif
+        {
+            var optionsWindow = new OptionsWindow(MainViewModel.Options)
+            {
+                Focusable = true,
+                Owner = this,
+                ShowActivated = true,
+                ShowInTaskbar = true,
+                Title = title ?? "Options",
+                WindowStartupLocation = WindowStartupLocation.CenterOwner,
+            };
+
+            optionsWindow.Closed += delegate { this.Activate(); };
+            optionsWindow.Closed += OnOptionsUpdated;
+            optionsWindow.Show();
+        }
+
+        /// <summary>
+        /// Set the UI color scheme according to the options
+        /// </summary>
+        private void ApplyTheme()
+        {
+            Theme theme;
+            if (MainViewModel.Options.EnableDarkMode)
+                theme = new DarkModeTheme();
+            else
+                theme = new LightModeTheme();
+
+            theme.Apply();
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Handler for OptionsWindow OnUpdated event
+        /// </summary>
+#if NET48
+        public void OnOptionsUpdated(object sender, EventArgs e)
+#else
+        public void OnOptionsUpdated(object? sender, EventArgs e)
+#endif
+        {
+            // Get the options window
+            var optionsWindow = (sender as OptionsWindow);
+            if (optionsWindow?.OptionsViewModel == null)
+                return;
+
+            bool savedSettings = optionsWindow.OptionsViewModel.SavedSettings;
+            var options = optionsWindow.OptionsViewModel.Options;
+            MainViewModel.UpdateOptions(savedSettings, options);
+
+            // Set the UI color scheme according to the options
+            ApplyTheme();
+        }
+
+        #region Menu Bar
+
+        /// <summary>
+        /// Handler for AboutMenuItem Click event
+        /// </summary>
+        public void AboutClick(object sender, RoutedEventArgs e)
+        {
+            string aboutText = MainViewModel.CreateAboutText();
+            CustomMessageBox.Show(this, aboutText, "About", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+
+        /// <summary>
+        /// Handler for AppExitMenuItem Click event
+        /// </summary>
+        public void AppExitClick(object sender, RoutedEventArgs e) =>
+            Application.Current.Shutdown();
+
+        /// <summary>
+        /// Handler for CheckForUpdatesMenuItem Click event
+        /// </summary>
+        public void CheckForUpdatesClick(object sender, RoutedEventArgs e)
+            => CheckForUpdates(showIfSame: true);
+
+        /// <summary>
+        /// Handler for DebugViewMenuItem Click event
+        /// </summary>
+        public void DebugViewClick(object sender, RoutedEventArgs e) =>
+            ShowDebugDiscInfoWindow();
+
+        /// <summary>
+        /// Handler for OptionsMenuItem Click event
+        /// </summary>
+        public void OptionsMenuItemClick(object sender, RoutedEventArgs e) =>
+            ShowOptionsWindow();
+
+        #endregion
+
+        #region User Area
+
+        /// <summary>
+        /// Handler for CopyProtectScanButton Click event
+        /// </summary>
+        public async void CopyProtectScanButtonClick(object sender, RoutedEventArgs e)
+        {
+            var (output, error) = await MainViewModel.ScanAndShowProtection();
+
+            if (!MainViewModel.LogPanelExpanded)
+            {
+                if (!string.IsNullOrEmpty(output) && string.IsNullOrEmpty(error))
+                    CustomMessageBox.Show(this, output, "Detected Protection(s)", MessageBoxButton.OK, MessageBoxImage.Information);
+                else
+                    CustomMessageBox.Show(this, "An exception occurred, see the log for details", "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
+        /// <summary>
+        /// Handler for DriveLetterComboBox SelectionChanged event
+        /// </summary>
+        public void DriveLetterComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.InitializeUIValues(removeEventHandlers: true, rescanDrives: false);
+        }
+
+        /// <summary>
+        /// Handler for DriveSpeedComboBox SelectionChanged event
+        /// </summary>
+        public void DriveSpeedComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.EnsureDiscInformation();
+        }
+
+        /// <summary>
+        /// Handler for DumpingProgramComboBox SelectionChanged event
+        /// </summary>
+        public void DumpingProgramComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.ChangeDumpingProgram();
+        }
+
+        /// <summary>
+        /// Handler for EnableParametersCheckBox Click event
+        /// </summary>
+        public void EnableParametersCheckBoxClick(object sender, RoutedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.ToggleParameters();
+        }
+
+        /// <summary>
+        /// Handler for MediaScanButton Click event
+        /// </summary>
+        public void MediaScanButtonClick(object sender, RoutedEventArgs e) =>
+            MainViewModel.InitializeUIValues(removeEventHandlers: true, rescanDrives: true);
+
+        /// <summary>
+        /// Handler for MediaTypeComboBox SelectionChanged event
+        /// </summary>
+        public void MediaTypeComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.ChangeMediaType(e.RemovedItems, e.AddedItems);
+        }
+
+        /// <summary>
+        /// Handler for OutputPathBrowseButton Click event
+        /// </summary>
+        public void OutputPathBrowseButtonClick(object sender, RoutedEventArgs e)
+        {
+            BrowseFile();
+            MainViewModel.EnsureDiscInformation();
+        }
+
+        /// <summary>
+        /// Handler for OutputPathTextBox TextChanged event
+        /// </summary>
+        public void OutputPathTextBoxTextChanged(object sender, TextChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.EnsureDiscInformation();
+        }
+
+        /// <summary>
+        /// Handler for StartStopButton Click event
+        /// </summary>
+        public void StartStopButtonClick(object sender, RoutedEventArgs e) =>
+            MainViewModel.ToggleStartStop();
+
+        /// <summary>
+        /// Handler for SystemTypeComboBox SelectionChanged event
+        /// </summary>
+        public void SystemTypeComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+                MainViewModel.ChangeSystem();
+        }
+
+        /// <summary>
+        /// Handler for UpdateVolumeLabel Click event
+        /// </summary>
+        public void UpdateVolumeLabelClick(object sender, RoutedEventArgs e)
+        {
+            if (MainViewModel.CanExecuteSelectionChanged)
+            {
+                if (MainViewModel.Options.FastUpdateLabel)
+                    MainViewModel.FastUpdateLabel(removeEventHandlers: true);
+                else
+                    MainViewModel.InitializeUIValues(removeEventHandlers: true, rescanDrives: false);
+            }
+        }
+
+        #endregion
+
+        #endregion // Event Handlers
+    }
+}

MPF.UI.Core/Windows/OptionsWindow.xaml

@@ -0,0 +1,494 @@
+<coreWindows:WindowBase x:Class="MPF.UI.Core.Windows.OptionsWindow"
+                        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                        xmlns:core="clr-namespace:MPF.UI.Core"
+                        xmlns:coreWindows="clr-namespace:MPF.UI.Core.Windows"
+                        mc:Ignorable="d"
+                        Width="515.132" WindowStyle="None"
+                        WindowStartupLocation="CenterOwner" ResizeMode="CanMinimize" SizeToContent="Height"
+                        BorderBrush="DarkGray" BorderThickness="2">
+
+    <Window.Resources>
+        <core:ElementConverter x:Key="ElementConverter" />
+    </Window.Resources>
+    <WindowChrome.WindowChrome>
+        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
+    </WindowChrome.WindowChrome>
+
+    <Grid>
+        <StackPanel Orientation="Vertical">
+            <Grid 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">
+                    <Label.Content>
+                        <TextBlock>
+                            <TextBlock.Inlines>
+                                <Run FontWeight="Bold" Text="{Binding Title, Mode=OneWay}"/>
+                            </TextBlock.Inlines>
+                        </TextBlock>
+                    </Label.Content>
+                    <Label.ContextMenu>
+                        <ContextMenu Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                     Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                     Style="{DynamicResource CustomContextMenuStyle}">
+                            <MenuItem Header="Minimize" Click="MinimizeButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                            <MenuItem Header="Close" Click="CloseButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                        </ContextMenu>
+                    </Label.ContextMenu>
+                </Label>
+                <Grid Grid.Column="5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                    </Grid.ColumnDefinitions>
+
+                    <Button x:Name="MinimizeButton" Grid.Column="0" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="MinimizeButtonClick">
+                        <Path Data="M 0,0 L 10,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                    <Button x:Name="CloseButton" Grid.Column="1" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="CloseButtonClick">
+                        <Path Data="M 0,0 L 12,12 M 0,12 L 12,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                </Grid>
+            </Grid>
+
+            <TabControl Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
+                        Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                        Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                        Style="{DynamicResource CustomTabControlStyle}">
+                <TabItem Header="General" Style="{DynamicResource CustomTabItemStyle}">
+                    <StackPanel>
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="User Interface">
+                            <UniformGrid Columns="2" Rows="2">
+                                <CheckBox VerticalAlignment="Center" Content="Enable Dark Mode"
+                                          IsChecked="{Binding Options.EnableDarkMode}"
+                                          ToolTip="(Experimental) Enable dark mode across the entire application" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Check for Updates on Startup"
+                                          IsChecked="{Binding Options.CheckForUpdatesOnStartup}"
+                                          ToolTip="Check for updates when the application starts" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Fast Update Label"
+                                          IsChecked="{Binding Options.FastUpdateLabel}"
+                                          ToolTip="Bypasses disc checks to quickly update the output path. Use with caution!" Margin="0,4"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Detection">
+                            <UniformGrid Columns="2" Rows="3">
+                                <CheckBox x:Name="SkipMediaTypeDetectionCheckBox" VerticalAlignment="Center" Content="Skip Type Detect"
+                                          IsChecked="{Binding Options.SkipMediaTypeDetection}"
+                                          ToolTip="Disable trying to guess media type inserted (may improve performance at startup)" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Skip System Detect"
+                                          IsChecked="{Binding Options.SkipSystemDetection}"
+                                          ToolTip="Disable trying to guess system (may improve performance at startup)" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="No Fixed Drives"
+                                        IsChecked="{Binding Options.IgnoreFixedDrives}"
+                                        ToolTip="Ignore hard drives and other fixed drives" Margin="0,4"
+                                />
+                                <Label/>
+                                <!-- Empty label for padding -->
+
+                                <Label VerticalAlignment="Center" Content="Default System:" HorizontalAlignment="Right" />
+                                <ComboBox x:Name="DefaultSystemComboBox" Height="22" Width="200" HorizontalAlignment="Left"
+                                          ItemsSource="{Binding Systems}" SelectedItem="{Binding Options.DefaultSystem, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                          SelectedIndex="0" Style="{DynamicResource CustomComboBoxStyle}">
+                                    <ComboBox.ItemContainerStyle>
+                                        <Style TargetType="{x:Type ComboBoxItem}">
+                                            <Style.Triggers>
+                                                <DataTrigger Binding="{Binding IsHeader}" Value="True">
+                                                    <Setter Property="IsEnabled" Value="False"/>
+                                                </DataTrigger>
+                                            </Style.Triggers>
+                                        </Style>
+                                    </ComboBox.ItemContainerStyle>
+                                </ComboBox>
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Logging">
+                            <UniformGrid Columns="2" Rows="1">
+                                <CheckBox VerticalAlignment="Center" Content="Verbose Logging"
+                                          IsChecked="{Binding Options.VerboseLogging}"
+                                          ToolTip="Display all logging statements" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Auto-Open Log"
+                                          IsChecked="{Binding Options.OpenLogWindowAtStartup}"
+                                          ToolTip="Open the log panel when the program launches" Margin="0,4"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+                    </StackPanel>
+                </TabItem>
+
+                <TabItem Header="Paths" Style="{DynamicResource CustomTabItemStyle}">
+                    <Grid Margin="5,5,5,5">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="1*" />
+                            <ColumnDefinition Width="2.0*" />
+                            <ColumnDefinition Width="0.2*" />
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                        </Grid.RowDefinitions>
+
+                        <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Aaru Path" />
+                        <TextBox x:Name="AaruPathTextBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                 Text="{Binding Options.AaruPath}" VerticalContentAlignment="Center" />
+                        <Button x:Name="AaruPathButton" Grid.Row="0" Grid.Column="2" Height="22" Width="22" Content="..."
+                                Style="{DynamicResource CustomButtonStyle}" />
+
+                        <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="DiscImageCreator Path" />
+                        <TextBox x:Name="DiscImageCreatorPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                 Text="{Binding Options.DiscImageCreatorPath}" VerticalContentAlignment="Center" />
+                        <Button x:Name="DiscImageCreatorPathButton" Grid.Row="1" Grid.Column="2" Height="22" Width="22" Content="..."
+                                Style="{DynamicResource CustomButtonStyle}" />
+
+                        <Label Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Redumper Path" />
+                        <TextBox x:Name="RedumperPathTextBox" Grid.Row="2" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                 Text="{Binding Options.RedumperPath}" VerticalContentAlignment="Center" />
+                        <Button x:Name="RedumperPathButton" Grid.Row="2" Grid.Column="2" Height="22" Width="22" Content="..."
+                                Style="{DynamicResource CustomButtonStyle}" />
+
+                        <Label Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Default Dumping Program" />
+                        <ComboBox x:Name="InternalProgramComboBox" Grid.Row="3" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                  ItemsSource="{Binding InternalPrograms}" SelectedItem="{Binding Options.InternalProgram, Converter={StaticResource ElementConverter}, Mode=TwoWay}"
+                                  Style="{DynamicResource CustomComboBoxStyle}" />
+
+                        <Label Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Default Output Path" />
+                        <TextBox x:Name="DefaultOutputPathTextBox" Grid.Row="4" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                                 Text="{Binding Options.DefaultOutputPath}" VerticalContentAlignment="Center" />
+                        <Button x:Name="DefaultOutputPathButton" Grid.Row="4" Grid.Column="2" Height="22" Width="22" Content="..."
+                                Style="{DynamicResource CustomButtonStyle}" />
+                    </Grid>
+                </TabItem>
+
+                <TabItem Header="Dumping" Style="{DynamicResource CustomTabItemStyle}">
+                    <StackPanel>
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Dumping">
+                            <UniformGrid Columns="2" Rows="7">
+                                <CheckBox VerticalAlignment="Center" Content="Show Separate Window"
+                                     IsChecked="{Binding Options.ToolsInSeparateWindow}"
+                                     ToolTip="Show program output in separate command window instead of in the log. Enable this if you have a weaker system as there is an increased processing load otherwise." Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Output Protection File"
+                                    IsChecked="{Binding Options.OutputSeparateProtectionFile}" IsEnabled="{Binding Options.ScanForProtection}"
+                                    ToolTip="Output protection information to a separate file" Margin="0,4,0,0"
+                                    />
+
+                                <CheckBox VerticalAlignment="Center" Content="Eject After Dump"
+                                    IsChecked="{Binding Options.EjectAfterDump}"
+                                    ToolTip="Eject the disc from the drive after dumping has completed" Margin="0,4"
+                                    />
+
+                                <CheckBox VerticalAlignment="Center" Content="Show Disc Info"
+                                     IsChecked="{Binding Options.PromptForDiscInformation}"
+                                     ToolTip="Enable showing the disc information output after dumping" Margin="0,4"
+                                      />
+
+                                <CheckBox VerticalAlignment="Center" Content="Pull All Information"
+                                     IsChecked="{Binding Options.PullAllInformation}"
+                                     ToolTip="Enable pulling all comment and content data after dumping" Margin="0,4"
+                                      />
+
+                                <CheckBox VerticalAlignment="Center" Content="Enable Tab Input"
+                                     IsChecked="{Binding Options.EnableTabsInInputFields}"
+                                     ToolTip="Enable entering tabs in supported input fields instead of tab navigation" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Enable Redump Compatibility"
+                                     IsChecked="{Binding Options.EnableRedumpCompatibility}"
+                                     ToolTip="Enable limiting outputs to only those supported by Redump" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Show Eject Reminder"
+                                     IsChecked="{Binding Options.ShowDiscEjectReminder}"
+                                     ToolTip="Enable showing the disc eject reminder after information is gathered" Margin="0,4"
+                                      />
+
+                                <CheckBox VerticalAlignment="Center" Content="Add Placeholders"
+                                     IsChecked="{Binding Options.AddPlaceholders}"
+                                     ToolTip="Enable adding placeholder text in the output for required and optional fields" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Add Filename Suffix"
+                                     IsChecked="{Binding Options.AddFilenameSuffix}"
+                                     ToolTip="Enable appending the output filename to the generated files" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Output Submission JSON"
+                                     IsChecked="{Binding Options.OutputSubmissionJSON}"
+                                     ToolTip="Enable outputting a compressed JSON version of the submission info" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Include Artifacts"
+                                     IsChecked="{Binding Options.IncludeArtifacts}" IsEnabled="{Binding Options.OutputSubmissionJSON}"
+                                     ToolTip="Include log files in serialized JSON data" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Compress Log Files"
+                                     IsChecked="{Binding Options.CompressLogFiles}"
+                                     ToolTip="Compress output log files to reduce space" Margin="0,4"
+                                     />
+
+                                <CheckBox VerticalAlignment="Center" Content="Delete Unnecessary Files"
+                                     IsChecked="{Binding Options.DeleteUnnecessaryFiles}"
+                                     ToolTip="Delete unnecesary output files to reduce space" Margin="0,4"
+                                     />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Protection">
+                            <UniformGrid Columns="2" Rows="2">
+                                <CheckBox VerticalAlignment="Center" Content="Enable Protection Scan"
+                                          IsChecked="{Binding Options.ScanForProtection}"
+                                          ToolTip="Enable automatic checking for copy protection on dumped media" Margin="0,4,0,0"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Scan Archive Contents"
+                                          IsChecked="{Binding Options.ScanArchivesForProtection}"
+                                          ToolTip="Enable scanning archive contents during protection scanning (may drastically increase scanning time but is more accurate)" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Include Executable Packers"
+                                          IsChecked="{Binding Options.ScanPackersForProtection}"
+                                          ToolTip="Include executable packers in outputted protections" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Include Debug Information"
+                                          IsChecked="{Binding Options.IncludeDebugProtectionInformation}"
+                                          ToolTip="Include debug information during protection scans" Margin="0,4"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Default Speeds" Grid.ColumnSpan="2">
+                            <Grid>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="80"/>
+                                    <ColumnDefinition Width="2.0*"/>
+                                    <ColumnDefinition Width="40"/>
+                                </Grid.ColumnDefinitions>
+
+                                <Grid.RowDefinitions>
+                                    <RowDefinition />
+                                    <RowDefinition />
+                                    <RowDefinition />
+                                    <RowDefinition />
+                                </Grid.RowDefinitions>
+
+                                <Label Grid.Row="0" Grid.Column="0" Content="CD" />
+                                <Slider x:Name="DumpSpeedCDSlider" Grid.Row="0" Grid.Column="1" Minimum="1" Maximum="72" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                                    Ticks="{Binding Source={x:Static core:Constants.SpeedsForCDAsCollection}}"
+                                    Value="{Binding Options.PreferredDumpSpeedCD}" />
+                                <TextBox x:Name="DumpSpeedCDTextBox" Grid.Row="0" Grid.Column="2" Width="22" Height="22" TextAlignment="Center" IsReadOnly="True" IsReadOnlyCaretVisible="False" VerticalAlignment="Center"
+                                    Text="{Binding ElementName=DumpSpeedCDSlider, Path=Value, UpdateSourceTrigger=PropertyChanged}" Background="LightGray" Foreground="Gray"/>
+
+                                <Label Grid.Row="1" Grid.Column="0" Content="DVD" />
+                                <Slider x:Name="DumpSpeedDVDSlider" Grid.Row="1" Grid.Column="1" Minimum="1" Maximum="24" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                                    Ticks="{Binding Source={x:Static core:Constants.SpeedsForDVDAsCollection}}"
+                                    Value="{Binding Options.PreferredDumpSpeedDVD}"  />
+                                <TextBox x:Name="DumpSpeedDVDTextBox" Grid.Row="1" Grid.Column="2" Width="22" Height="22" TextAlignment="Center" IsReadOnly="True" IsReadOnlyCaretVisible="False" VerticalAlignment="Center"
+                                   Text="{Binding ElementName=DumpSpeedDVDSlider, Path=Value, UpdateSourceTrigger=PropertyChanged}" Background="LightGray" Foreground="Gray"/>
+
+                                <Label Grid.Row="2" Grid.Column="0" Content="HD-DVD" />
+                                <Slider x:Name="DumpSpeedHDDVDSlider" Grid.Row="2" Grid.Column="1" Minimum="1" Maximum="24" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                                    Ticks="{Binding Source={x:Static core:Constants.SpeedsForHDDVDAsCollection}}"
+                                    Value="{Binding Options.PreferredDumpSpeedHDDVD}"  />
+                                <TextBox x:Name="DumpSpeedHDDVDTextBox" Grid.Row="2" Grid.Column="2" Width="22" Height="22" TextAlignment="Center" IsReadOnly="True" IsReadOnlyCaretVisible="False" VerticalAlignment="Center"
+                                   Text="{Binding ElementName=DumpSpeedHDDVDSlider, Path=Value, UpdateSourceTrigger=PropertyChanged}" Background="LightGray" Foreground="Gray"/>
+
+                                <Label Grid.Row="3" Grid.Column="0" Content="BD" />
+                                <Slider x:Name="DumpSpeedBDSlider" Grid.Row="3" Grid.Column="1" Minimum="1" Maximum="16" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                                    Ticks="{Binding Source={x:Static core:Constants.SpeedsForBDAsCollection}}"
+                                    Value="{Binding Options.PreferredDumpSpeedBD}"  />
+                                <TextBox x:Name="DumpSpeedBDTextBox" Grid.Row="3" Grid.Column="2" Width="22" Height="22" TextAlignment="Center" IsReadOnly="True" IsReadOnlyCaretVisible="False" VerticalAlignment="Center"
+                                   Text="{Binding ElementName=DumpSpeedBDSlider, Path=Value, UpdateSourceTrigger=PropertyChanged}" Background="LightGray" Foreground="Gray"/>
+                            </Grid>
+                        </GroupBox>
+                    </StackPanel>
+                </TabItem>
+
+                <TabItem Header="Programs" Style="{DynamicResource CustomTabItemStyle}">
+                    <StackPanel>
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Aaru">
+                            <UniformGrid Columns="2" Rows="3">
+                                <CheckBox VerticalAlignment="Center" Content="Enable Debug Output"
+                                          IsChecked="{Binding Options.AaruEnableDebug}"
+                                          ToolTip="Enable debug output in logs" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Enable Verbose Output"
+                                          IsChecked="{Binding Options.AaruEnableVerbose}"
+                                          ToolTip="Enable verbose output in logs" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Force Dumping"
+                                          IsChecked="{Binding Options.AaruForceDumping}"
+                                          ToolTip="Enable forcing dump even if there are issues" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Strip Personal Data"
+                                          IsChecked="{Binding Options.AaruStripPersonalData}"
+                                          ToolTip="Enable stripping of personally identifiable information from metadata" Margin="0,4,0,0"
+                                />
+
+                                <Label Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                         Text="{Binding Options.AaruRereadCount}"
+                                         ToolTip="Specifies how many rereads are attempted for sector and subchannel errors"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="DiscImageCreator">
+                            <UniformGrid Columns="2" Rows="6">
+                                <CheckBox VerticalAlignment="Center" Content="Quiet Mode"
+                                          IsChecked="{Binding Options.DICQuietMode}"
+                                          ToolTip="Disable sounds (beeps) during and after operations" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Paranoid Mode"
+                                          IsChecked="{Binding Options.DICParanoidMode}"
+                                          ToolTip="Enable pedantic and super-safe flags" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Use CMI Flag"
+                                          IsChecked="{Binding Options.DICUseCMIFlag}"
+                                          ToolTip="Enable the CMI flag for supported disc types (DVD/HD-DVD only)" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Reset After Dump"
+                                          IsChecked="{Binding Options.DICResetDriveAfterDump}"
+                                          ToolTip="Reset disc drives after dumping; useful for some older machines" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Multi-Sector Read"
+                                          IsChecked="{Binding Options.DICMultiSectorRead}"
+                                          ToolTip="Enable the /mr flag for BD drive dumping" Margin="0,4"
+                                />
+                                <Label/>  <!-- Empty label for padding -->
+
+                                <Label Content="Multi-Sector Read Value:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                          Text="{Binding Options.DICMultiSectorReadValue}" IsEnabled="{Binding Options.DICMultiSectorRead}"
+                                          ToolTip="Set the default value for the /mr flag"
+                                />
+
+                                <Label Content="CD Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                          Text="{Binding Options.DICRereadCount}"
+                                          ToolTip="Specifies how many rereads are attempted on C2 error [CD only]"
+                                />
+
+                                <Label Content="DVD/HD-DVD/BD Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                          Text="{Binding Options.DICDVDRereadCount}"
+                                          ToolTip="Specifies how many rereads are attempted on read error [DVD/HD-DVD/BD only]"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Redumper">
+                            <UniformGrid Columns="2" Rows="3">
+                                <CheckBox VerticalAlignment="Center" Content="Enable Debug Output"
+                                          IsChecked="{Binding Options.RedumperEnableDebug}"
+                                          ToolTip="Enable debug output in logs" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Enable Verbose Output"
+                                          IsChecked="{Binding Options.RedumperEnableVerbose}"
+                                          ToolTip="Enable verbose output in logs" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Enable BE Drive Reading"
+                                          IsChecked="{Binding Options.RedumperUseBEReading}"
+                                          ToolTip="Enable setting drive read method to BE_CDDA by default" Margin="0,4"
+                                />
+
+                                <CheckBox VerticalAlignment="Center" Content="Set Generic Drive Type"
+                                          IsChecked="{Binding Options.RedumperUseGenericDriveType}"
+                                          ToolTip="Enable setting drive type to Generic by default" Margin="0,4"
+                                />
+
+                                <Label Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                                <TextBox VerticalAlignment="Center" VerticalContentAlignment="Center"
+                                         Text="{Binding Options.RedumperRereadCount}"
+                                          ToolTip="Specifies how many rereads are attempted on read error"
+                                />
+                            </UniformGrid>
+                        </GroupBox>
+                    </StackPanel>
+                </TabItem>
+
+                <TabItem Header="Login Info" Style="{DynamicResource CustomTabItemStyle}">
+                    <StackPanel>
+                        <GroupBox Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Redump">
+                            <UniformGrid Columns="5">
+                                <Label VerticalAlignment="Center" HorizontalAlignment="Right" Content="Username" />
+                                <TextBox x:Name="RedumpUsernameTextBox" Height="22" HorizontalAlignment="Stretch"
+                                    Text="{Binding Options.RedumpUsername}" />
+
+                                <Label VerticalAlignment="Center" HorizontalAlignment="Right" Content="Password" />
+                                <PasswordBox x:Name="RedumpPasswordBox" Height="22" HorizontalAlignment="Stretch" PasswordChar="*" />
+
+                                <Button x:Name="RedumpLoginTestButton" Height="22" Width="80" Content="Test Login"
+                                        Style="{DynamicResource CustomButtonStyle}" />
+                            </UniformGrid>
+                        </GroupBox>
+
+                        <Label>
+                            <Label.Content>
+                                <TextBlock TextWrapping="Wrap"><Bold Foreground="Red">WARNING:</Bold> If you choose to enable validation and information retrieval, you are responsible for ensuring that all data populated matches your actual media. Some information may be marked to check for validity as a reminder, but all information should be subject to the same scrutiny.</TextBlock>
+                            </Label.Content>
+                        </Label>
+                    </StackPanel>
+                </TabItem>
+            </TabControl>
+
+            <!-- Accept / Cancel -->
+            <GroupBox 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="AcceptButton" Height="25" Width="80" IsDefault="True" Content="Accept"
+                            Style="{DynamicResource CustomButtonStyle}" />
+                    <Button Name="CancelButton" Height="25" Width="80" IsCancel="True" Content="Cancel"
+                            Style="{DynamicResource CustomButtonStyle}" />
+                    <Label/>
+                    <!-- Empty label for padding -->
+                </UniformGrid>
+            </GroupBox>
+        </StackPanel>
+    </Grid>
+</coreWindows:WindowBase>

MPF.UI.Core/Windows/OptionsWindow.xaml.cs

@@ -0,0 +1,237 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Forms;
+using MPF.Core.Data;
+using MPF.Core.UI.ViewModels;
+using WPFCustomMessageBox;
+
+namespace MPF.UI.Core.Windows
+{
+    /// <summary>
+    /// Interaction logic for OptionsWindow.xaml
+    /// </summary>
+    public partial class OptionsWindow : WindowBase
+    {
+        /// <summary>
+        /// Read-only access to the current options view model
+        /// </summary>
+        public OptionsViewModel OptionsViewModel => DataContext as OptionsViewModel ?? new OptionsViewModel(new Options());
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public OptionsWindow(Options options)
+        {
+            InitializeComponent();
+            DataContext = new OptionsViewModel(options);
+
+            // Set initial value for binding
+            RedumpPasswordBox.Password = options.RedumpPassword;
+
+            // Add handlers
+            AaruPathButton.Click += BrowseForPathClick;
+            DiscImageCreatorPathButton.Click += BrowseForPathClick;
+            RedumperPathButton.Click += BrowseForPathClick;
+            DefaultOutputPathButton.Click += BrowseForPathClick;
+
+            AcceptButton.Click += OnAcceptClick;
+            CancelButton.Click += OnCancelClick;
+            RedumpPasswordBox.PasswordChanged += OnPasswordChanged;
+            RedumpLoginTestButton.Click += OnRedumpTestClick;
+        }
+
+        /// <summary>
+        /// Handler for OptionsWindow OnContentRendered event
+        /// </summary>
+        protected override void OnContentRendered(EventArgs e)
+        {
+            base.OnContentRendered(e);
+
+            // Set the window title
+            OptionsViewModel.Title = this.Title;
+        }
+
+        #region UI Commands
+
+        /// <summary>
+        /// Browse and set a path based on the invoking button
+        /// </summary>
+#if NET48
+        private void BrowseForPath(Window parent, System.Windows.Controls.Button button)
+#else
+        private void BrowseForPath(Window parent, System.Windows.Controls.Button? button)
+#endif
+        {
+            // If the button is null, we can't do anything
+            if (button == null)
+                return;
+
+            // Strips button prefix to obtain the setting name
+#if NET48
+            string pathSettingName = button.Name.Substring(0, button.Name.IndexOf("Button"));
+#else
+            string pathSettingName = button.Name[..button.Name.IndexOf("Button")];
+#endif
+
+            // TODO: hack for now, then we'll see
+            bool shouldBrowseForPath = pathSettingName == "DefaultOutputPath";
+
+            var currentPath = TextBoxForPathSetting(parent, pathSettingName)?.Text;
+            var initialDirectory = AppDomain.CurrentDomain.BaseDirectory;
+            if (!shouldBrowseForPath && !string.IsNullOrEmpty(currentPath))
+                initialDirectory = Path.GetDirectoryName(Path.GetFullPath(currentPath));
+
+            CommonDialog dialog = shouldBrowseForPath
+                ? (CommonDialog)CreateFolderBrowserDialog()
+                : CreateOpenFileDialog(initialDirectory);
+            using (dialog)
+            {
+                DialogResult result = dialog.ShowDialog();
+                if (result == System.Windows.Forms.DialogResult.OK)
+                {
+                    string path = string.Empty;
+                    bool exists = false;
+
+                    if (shouldBrowseForPath && dialog is FolderBrowserDialog folderBrowserDialog)
+                    {
+                        path = folderBrowserDialog.SelectedPath;
+                        exists = Directory.Exists(path);
+                    }
+                    else if (dialog is OpenFileDialog openFileDialog)
+                    {
+                        path = openFileDialog.FileName;
+                        exists = File.Exists(path);
+                    }
+
+                    if (exists)
+                    {
+                        OptionsViewModel.Options[pathSettingName] = path;
+                        var textBox = TextBoxForPathSetting(parent, pathSettingName);
+                        if (textBox != null)
+                            textBox.Text = path;
+                    }
+                    else
+                    {
+                        CustomMessageBox.Show(
+                            "Specified path doesn't exist!",
+                            "Error",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Error
+                        );
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Find a TextBox by setting name
+        /// </summary>
+        /// <param name="name">Setting name to find</param>
+        /// <returns>TextBox for that setting</returns>
+#if NET48
+        private static System.Windows.Controls.TextBox TextBoxForPathSetting(Window parent, string name) =>
+#else
+        private static System.Windows.Controls.TextBox? TextBoxForPathSetting(Window parent, string name) =>
+#endif
+            parent.FindName(name + "TextBox") as System.Windows.Controls.TextBox;
+
+        /// <summary>
+        /// Create an open folder dialog box
+        /// </summary>
+#if NET48
+        private static FolderBrowserDialog CreateFolderBrowserDialog() => new FolderBrowserDialog();
+#else
+        private static FolderBrowserDialog CreateFolderBrowserDialog() => new();
+#endif
+
+        /// <summary>
+        /// Create an open file dialog box
+        /// </summary>
+#if NET48
+        private static OpenFileDialog CreateOpenFileDialog(string initialDirectory)
+#else
+        private static OpenFileDialog CreateOpenFileDialog(string? initialDirectory)
+#endif
+        {
+            return new OpenFileDialog()
+            {
+                InitialDirectory = initialDirectory,
+                Filter = "Executables (*.exe)|*.exe",
+                FilterIndex = 0,
+                RestoreDirectory = true,
+            };
+        }
+
+        /// <summary>
+        /// Test Redump credentials for validity
+        /// </summary>
+#if NET48
+        private void ValidateRedumpCredentials()
+#else
+        private async Task ValidateRedumpCredentials()
+#endif
+        {
+#if NET48
+            (bool? success, string message) = OptionsViewModel.TestRedumpLogin(RedumpUsernameTextBox.Text, RedumpPasswordBox.Password);
+#else
+            (bool? success, string? message) = await OptionsViewModel.TestRedumpLogin(RedumpUsernameTextBox.Text, RedumpPasswordBox.Password);
+#endif
+
+            if (success == true)
+                CustomMessageBox.Show(this, message, "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+            else if (success == false)
+                CustomMessageBox.Show(this, message, "Failure", MessageBoxButton.OK, MessageBoxImage.Error);
+            else
+                CustomMessageBox.Show(this, message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+
+#endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Handler for generic Click event
+        /// </summary>
+        private void BrowseForPathClick(object sender, EventArgs e) =>
+            BrowseForPath(this, sender as System.Windows.Controls.Button);
+
+        /// <summary>
+        /// Handler for AcceptButton Click event
+        /// </summary>
+        private void OnAcceptClick(object sender, EventArgs e)
+        {
+            OptionsViewModel.SavedSettings = true;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for CancelButtom Click event
+        /// </summary>
+        private void OnCancelClick(object sender, EventArgs e)
+        {
+            OptionsViewModel.SavedSettings = false;
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for RedumpPasswordBox PasswordChanged event
+        /// </summary>
+        private void OnPasswordChanged(object sender, EventArgs e)
+        {
+            OptionsViewModel.Options.RedumpPassword = RedumpPasswordBox.Password;
+        }
+
+        /// <summary>
+        /// Test Redump credentials for validity
+        /// </summary>
+#if NET48
+        private void OnRedumpTestClick(object sender, EventArgs e) => ValidateRedumpCredentials();
+#else
+        private async void OnRedumpTestClick(object sender, EventArgs e) => await ValidateRedumpCredentials();
+#endif
+
+        #endregion
+    }
+}

MPF.UI.Core/Windows/RingCodeGuideWindow.xaml

@@ -0,0 +1,157 @@
+<windows:WindowBase x:Class="MPF.UI.Core.Windows.RingCodeGuideWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:controls="clr-namespace:MPF.UI.Core.UserControls"
+        xmlns:windows="clr-namespace:MPF.UI.Core.Windows"
+        mc:Ignorable="d"
+        Title="Ring Code Guide" Width="500" WindowStyle="None"
+        WindowStartupLocation="CenterOwner" ResizeMode="CanMinimize" SizeToContent="Height"
+        BorderBrush="DarkGray" BorderThickness="2">
+
+    <WindowChrome.WindowChrome>
+        <WindowChrome CaptionHeight="0" ResizeBorderThickness="0" />
+    </WindowChrome.WindowChrome>
+    
+    <Grid>
+        <StackPanel Orientation="Vertical">
+            <Grid 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">
+                    <Label.Content>
+                        <TextBlock TextAlignment="Center"><Bold>Ring Code Guide</Bold></TextBlock>
+                    </Label.Content>
+                    <Label.ContextMenu>
+                        <ContextMenu Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                     Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                     Style="{DynamicResource CustomContextMenuStyle}">
+                            <MenuItem Header="Minimize" Click="MinimizeButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      BorderBrush="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                            <MenuItem Header="Close" Click="CloseButtonClick" Width="185"
+                                      Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                                      BorderBrush="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                                      Template="{DynamicResource CustomMenuItemTemplate}"/>
+                        </ContextMenu>
+                    </Label.ContextMenu>
+                </Label>
+                <Grid Grid.Column="5">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition/>
+                        <ColumnDefinition/>
+                    </Grid.ColumnDefinitions>
+
+                    <Button x:Name="MinimizeButton" Grid.Column="0" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="MinimizeButtonClick">
+                        <Path Data="M 0,0 L 10,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                    <Button x:Name="CloseButton" Grid.Column="1" BorderThickness="0" Background="Transparent" Style="{DynamicResource CustomButtonStyle}" Click="CloseButtonClick">
+                        <Path Data="M 0,0 L 12,12 M 0,12 L 12,0" Stroke="{Binding Path=Foreground,RelativeSource={RelativeSource AncestorType={x:Type Button}}}" StrokeThickness="1"/>
+                    </Button>
+                </Grid>
+            </Grid>
+
+            <TabControl Background="{DynamicResource {x:Static SystemColors.WindowBrushKey}}"
+                        Foreground="{DynamicResource {x:Static SystemColors.WindowTextBrushKey}}"
+                        Style="{DynamicResource CustomTabControlStyle}">
+                <TabItem  Header="1-Layer Ringcode" Style="{DynamicResource CustomTabItemStyle}">
+                    <Grid Margin="5,5,5,5">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+
+                        <Grid.RowDefinitions>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                        </Grid.RowDefinitions>
+
+                        <Image Grid.Row="0" Source="../Images/ring-code-guide-1-layer.png"
+                               HorizontalAlignment="Center" Stretch="Fill" Width="500" Height="500"
+                               RenderOptions.BitmapScalingMode="HighQuality" />
+                        <Label Grid.Row="1">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Red">1. Mastering Ring:</Bold> Sony DADC&lt;tab&gt;A0100368905-0101&lt;tab&gt;13</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="2">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Green">2. Mastering SID:</Bold> IFPI L553</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="3">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Purple">3. Toolstamp/Mastering Code:</Bold> A2</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="4">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="LightBlue">4. Mould SID:</Bold> IFPI 94V1</TextBlock>
+                            </Label.Content>
+                        </Label>
+                    </Grid>
+                </TabItem>
+
+                <TabItem  Header="2-Layer Ringcode" Style="{DynamicResource CustomTabItemStyle}">
+                    <Grid Margin="5,5,5,5">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition/>
+                        </Grid.ColumnDefinitions>
+
+                        <Grid.RowDefinitions>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                            <RowDefinition/>
+                        </Grid.RowDefinitions>
+
+                        <Image Grid.Row="0" Source="../Images/ring-code-guide-2-layer.png"
+                               HorizontalAlignment="Center" Stretch="Fill" Width="475" Height="500"
+                               RenderOptions.BitmapScalingMode="HighQuality" />
+                        <Label Grid.Row="1">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Red">1. Outer Mastering Ring:</Bold> IM01501A-L1&lt;tab&gt;03 +&lt;tab&gt;+</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="2">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Green">2. Inner Mastering Ring:</Bold> IM01501A-L0&lt;tab&gt;01 +&lt;tab&gt;+</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="3">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="Purple">3. Outer Mastering SID:</Bold> IFPI LB48</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="4">
+                            <Label.Content>
+                                <TextBlock><Bold Foreground="LightBlue">4. Inner Mastering SID:</Bold> IFPI LB48</TextBlock>
+                            </Label.Content>
+                        </Label>
+                        <Label Grid.Row="5">
+                            <Label.Content>
+                                <TextBlock><Bold>Note:</Bold> See the 1-Layer guide for more details on additional fields</TextBlock>
+                            </Label.Content>
+                        </Label>
+                    </Grid>
+                </TabItem>
+            </TabControl>
+        </StackPanel>
+    </Grid>
+</windows:WindowBase>

MPF.UI.Core/Windows/RingCodeGuideWindow.xaml.cs

@@ -0,0 +1,10 @@
+namespace MPF.UI.Core.Windows
+{
+    /// <summary>
+    /// Interaction logic for RingCodeGuideWindow.xaml
+    /// </summary>
+    public partial class RingCodeGuideWindow : WindowBase
+    {
+        public RingCodeGuideWindow() => InitializeComponent();
+    }
+}

MPF.UI.Core/Windows/WindowBase.cs

@@ -0,0 +1,43 @@
+using System.Windows;
+using System.Windows.Input;
+
+namespace MPF.UI.Core.Windows
+{
+    public class WindowBase : Window
+    {
+        #region Event Handlers
+
+        /// <summary>
+        /// Handler for CloseButton Click event
+        /// </summary>
+        public void CloseButtonClick(object sender, RoutedEventArgs e)
+        {
+            try
+            {
+                this.DialogResult = false;
+            }
+            catch { }
+            
+            Close();
+        }
+
+        /// <summary>
+        /// Handler for MinimizeButton Click event
+        /// </summary>
+        public void MinimizeButtonClick(object sender, RoutedEventArgs e)
+        {
+            this.WindowState = WindowState.Minimized;
+        }
+
+        /// <summary>
+        /// Handler for Title MouseDown event
+        /// </summary>
+        public void TitleMouseDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+                this.DragMove();
+        }
+
+        #endregion
+    }
+}

MPF.sln

@@ -0,0 +1,70 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32407.343
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF", "MPF\MPF.csproj", "{7B1B75EB-8940-466F-BD51-76471A57F9BE}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.Test", "MPF.Test\MPF.Test.csproj", "{7CC064D2-38AB-4A05-8519-28660DE4562A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MPF.Check", "MPF.Check\MPF.Check.csproj", "{8CFDE289-E171-4D49-A40D-5293265C1253}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4D1DCF5A-F0B0-4E81-A05B-F1A7D37C9D9D}"
+	ProjectSection(SolutionItems) = preProject
+		appveyor.yml = appveyor.yml
+		CHANGELIST.md = CHANGELIST.md
+		.github\ISSUE_TEMPLATE\feature-request.md = .github\ISSUE_TEMPLATE\feature-request.md
+		.github\ISSUE_TEMPLATE\informational.md = .github\ISSUE_TEMPLATE\informational.md
+		.github\ISSUE_TEMPLATE\issue-report.md = .github\ISSUE_TEMPLATE\issue-report.md
+		publish-nix.sh = publish-nix.sh
+		publish-win.bat = publish-win.bat
+		README.md = README.md
+	EndProjectSection
+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.UI.Core", "MPF.UI.Core\MPF.UI.Core.csproj", "{EA3768DB-694A-4653-82E4-9FF71B8963F3}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MPF", "MPF", "{4160167D-681D-480B-ABC6-06AC869E5769}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7CC064D2-38AB-4A05-8519-28660DE4562A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7CC064D2-38AB-4A05-8519-28660DE4562A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7CC064D2-38AB-4A05-8519-28660DE4562A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7CC064D2-38AB-4A05-8519-28660DE4562A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8CFDE289-E171-4D49-A40D-5293265C1253}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{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
+		{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
+		{EA3768DB-694A-4653-82E4-9FF71B8963F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EA3768DB-694A-4653-82E4-9FF71B8963F3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EA3768DB-694A-4653-82E4-9FF71B8963F3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EA3768DB-694A-4653-82E4-9FF71B8963F3}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{7B1B75EB-8940-466F-BD51-76471A57F9BE} = {4160167D-681D-480B-ABC6-06AC869E5769}
+		{7CC064D2-38AB-4A05-8519-28660DE4562A} = {4160167D-681D-480B-ABC6-06AC869E5769}
+		{8CFDE289-E171-4D49-A40D-5293265C1253} = {4160167D-681D-480B-ABC6-06AC869E5769}
+		{70B1265D-FE49-472A-A83D-0B462152D37A} = {4160167D-681D-480B-ABC6-06AC869E5769}
+		{EA3768DB-694A-4653-82E4-9FF71B8963F3} = {4160167D-681D-480B-ABC6-06AC869E5769}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {73C62E6A-6584-4D93-83B5-ECB1FBDB469B}
+	EndGlobalSection
+EndGlobal

MPF/App.xaml

@@ -0,0 +1,776 @@
+<Application
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:Themes="clr-namespace:Microsoft.Windows.Themes;assembly=PresentationFramework.Aero"
+             xmlns:windows="clr-namespace:MPF.UI.Core.Windows;assembly=MPF.UI.Core"
+             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

@@ -0,0 +1,7 @@
+namespace MPF
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : System.Windows.Application { }
+}