Update to version 1.16.1

* Start reorganizing options and internals

* Make entire options flow more robust

* Few more TODOs, slightly cleaner code

* Simplify Options constructor

* Fix eject and reset

* Some other abstractions

* Enforce readonly

* Fix tests, like the TODO said

* Move specific output file parsing to specific parameters

* Add some future enums, add notes around .NET Core build path

* Wrap last incompatible .NET Core stuff

* Extract out CleanRip, fix a bunch of other spaghetti

App.config

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-    <configSections>
-        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
-            <section name="DICUI.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
-        </sectionGroup>
-    </configSections>
-    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
-    </startup>
-    <userSettings>
-        <DICUI.Properties.Settings>
-            <setting name="
-                     " serializeAs="String">
-                <value>Release_ANSI\\DiscImageCreator.exe</value>
-            </setting>
-        </DICUI.Properties.Settings>
-    </userSettings>
-</configuration>

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
-    {
-    }
-}

CHANGELIST.md

@@ -0,0 +1,161 @@
+### 1.16.1 (2020-05-07)
+
+- Add preliminary support for DD for Windows (end to end still NW)
+- Add CNF parsing for Konami Python 2 discs (PS2-based)
+- Updated included Aaru version
+- Massive cleanup effort to detangle large chunks of code
+- Miscellaneous bugfixes that came from the above
+
+### 1.16 (2020-04-13)
+
+- Updated to DIC version 20200403
+- UI updates based on user feedback
+- Added support for Aaru (formerly DiscImageChef)
+- Added more support for different output file formats (such as CleanRip)
+- Add PS1/PS2 serial extraction and matching
+- Fix PS1 date support when both PSX.EXE and normal executable are both present
+- Update BurnOutSharp
+- Many MANY bits of internal cleanup
+
+### 1.15 (2019-11-16)
+
+- Updated to DIC version 20191116
+- Support non-optical, non-floppy stuff better
+- Update protection scanning and fix some things
+
+### 1.14 (2019-10-01)
+
+- Updated to DIC version 20191001
+- Added builds for .NET 4.6.2, .NET 4.7.2, and .NET Core 3.0
+- Updated and fixed a bunch of things related to Redump
+- Fixed path persistence when changing system and media type
+- Added more system autodetects
+- Added new, optional, disc information filling window (WIP)
+
+### 1.13 (2019-07-02)
+
+- Added new DIC commands and flags
+- Made DICUI Check more robust
+- Added and updated systems along with format cleanup
+- Created a new SubmissionInfo template (and internals)
+- Added automatic grabbing of Redump information, if possible
+- Better media format support (BD, UMD)
+- Initial disc type detection
+
+### 1.12.2 (2019-04-19)
+
+- Added DICUI Check, a new standalone tool for parsing DIC output from platforms unsupported by DICUI
+- Added a few machines/formats
+- Updated to DIC version 20190326
+- Added DMI data extraction for Xbox and X360
+
+### 1.12.1 (2019-01-28)
+
+- Fixed !submissionInfo.txt output for CD-ROM and GD-ROM
+
+### 1.12 (2019-01-27)
+
+- Added a few new systems and formats
+- Added new DIC commands and flags
+- Updated the `!submissionInfo.txt` file order
+- Fixed Audio CD handling
+- Added Sega CD / Mega CD header extraction
+- Readded Floppy Disk as a supported format
+- And more! See the full Git commit list for more details
+
+### 1.11 (2018-09-20)
+
+- Fix formatting of XBOX and XBOX 360 security sector output
+- Add new XBOX swap commands and outputs
+- Fixes for some PlayStation 2 and 4 outputs
+- Added external programs to AppVeyor builds
+- Fixed `.` in path issues with DIC; attempted to fix issues with `&`
+- Combined XBOX 360 XGD 2/3 due to new DIC support with Kreon drives
+- Fixed (semi-)longstanding bug with XBOX disc layer detection
+- Added DVD-Video protection output
+- Made custom parameters work a little more intuitively
+- Added *EXPERIMENTAL* Winforms-based UI
+- And more! See the full Git commit list for more details
+
+### 1.10 (2018-07-29)
+
+- Added many new options for user customization
+- Added unit testing and an AppVeyor build
+- Many code refactorings
+- **LOG WINDOW**
+- Separated out protection scan and Unshield ports to new projects
+- Added "empty drive" support; should help with 3DO and HFS dumping
+- And much more! See the full Git commit list for more details
+
+### 1.07 (2018-06-27)
+
+- Separated system and media type for easier navigation
+- Combined instances of single- and dual-layer discs
+- Removed reliance on **sg-raw** and **psxt001z**
+- Added system and disc type to the submission info
+- First attempt at getting current disc type
+- Made the three PSX-specific fields (**EDC**, **Anti-modchip**, and **LibCrypt**) automatically filled in, when possible
+- Many, many, many behind the scenes updates for speed, future features, and stability
+
+### 1.06 (2018-06-15)
+
+- Fixed not being able to use the `/c2` flag properly
+- Fixed times when the ability to start dumping was improperly allowed
+- Added full support for XBOX and XBOX360 (XDG1, XDG2) dumping through DIC (using a Kreon, or presumably a 0800)
+
+### 1.05a (2018-06-14)
+
+- Fixed some ordering and nullability issues
+- Added automatic fields for PS1, PS2, Saturn
+
+### 1.05 (2018-06-14)
+
+- Miscellaneous fixes around custom parameter validation, dump information accuracy, settings window, and TODO cleanup
+- Add many more supported platforms, mostly arcade (based on publicly available information)
+- Add floppy disk dumping support
+- Add optional disc eject on completion
+- Add subdump for Sega Saturn
+- Fully support newest version of DIC including all new flags and commands
+- PlayStation and Saturn discs still don't have all internal information automatically generated
+
+### 1.04b (2018-06-13)
+
+- Added subIntention reading
+- Fixed extra extensions being appended
+- Fixed internationalization error (number formatting)
+- Fixed "Custom Input" not working
+
+### 1.04a (2018-06-13)
+
+- Fixed issue with empty trays
+- Added settings dialog
+
+### 1.04 (2018-06-13)
+
+- Behind-the-scenes fixes and formatting
+- Better checks for external programs
+- Automatically changing disc information
+- Custom parameters (and parameter validation)
+- Automatic drive speed selection
+- Automatic submission information creation
+- Add ability to stop a dump from the UI
+
+### 1.03 (2018-06-08)
+
+- edccchk now run on all CD-Roms
+- Discs unsupported by Windows are now regonized
+- Extra \ when accepting default save has been removed.
+ 
+### 1.02b (2018-05-18)
+
+- Added missing DLL
+
+### 1.02 (2018-05-18)
+
+- Fixed XBOX One and PS4 Drive Speed issue.
+- Started implementing DiscImageCreator Path selection.
+- Conforming my naming for objects and variable
+
+### 1.01d (2018-05-18)
+
+-Combine IBM PC-CD options, misc fixes.

DICUI.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>

DICUI.Check/DICUI.Check.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <OutputType>Exe</OutputType>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DICUI.Library\DICUI.Library.csproj">
+      <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
+      <Name>DICUI.Library</Name>
+    </ProjectReference>
+  </ItemGroup>
+
+</Project>

DICUI.Check/Program.cs

@@ -0,0 +1,235 @@
+using System;
+using System.IO;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI.Check
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Help options
+            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?")
+            {
+                DisplayHelp();
+                return;
+            }
+
+            // List options
+            if (args[0] == "-lm" || args[0] == "--listmedia")
+            {
+                ListMediaTypes();
+                Console.ReadLine();
+                return;
+            }
+            else if (args[0] == "-lp" || args[0] == "--listprograms")
+            {
+                ListPrograms();
+                Console.ReadLine();
+                return;
+            }
+            else if (args[0] == "-ls" || args[0] == "--listsystems")
+            {
+                ListKnownSystems();
+                Console.ReadLine();
+                return;
+            }
+
+            // Normal operation check
+            if (args.Length < 3)
+            {
+                DisplayHelp("Invalid number of arguments");
+                return;
+            }
+
+            // Check the MediaType
+            var mediaType = Converters.ToMediaType(args[0].Trim('"'));
+            if (mediaType == MediaType.NONE)
+            {
+                DisplayHelp($"{args[0]} is not a recognized media type");
+                return;
+            }
+
+            // Check the KnownSystem
+            var knownSystem = Converters.ToKnownSystem(args[1].Trim('"'));
+            if (knownSystem == KnownSystem.NONE)
+            {
+                DisplayHelp($"{args[1]} is not a recognized system");
+                return;
+            }
+
+            // Check for additional flags
+            string username = null, password = null;
+            string internalProgram = "DiscImageCreator";
+            int startIndex = 2;
+            for (; startIndex < args.Length; startIndex++)
+            {
+                // Redump login
+                if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--credentials="))
+                {
+                    string[] credentials = args[startIndex].Split('=')[1].Split(';');
+                    username = credentials[0];
+                    password = credentials[1];
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--credentials")
+                {
+                    username = args[startIndex + 1];
+                    password = args[startIndex + 2];
+                    startIndex += 2;
+                }
+
+                // Use specific program
+                else if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    internalProgram = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    internalProgram = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            // Make a new Progress object
+            var progress = new Progress<Result>();
+            progress.ProgressChanged += ProgressUpdated;
+
+            // 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]))
+                {
+                    DisplayHelp($"{args[i]} does not exist");
+                    return;
+                }
+
+                // Get the full file path
+                string filepath = Path.GetFullPath(args[i]);
+
+                // Now populate an environment
+                // TODO: Replace this with Dictionary constructor
+                var options = new Options
+                {
+                    InternalProgram = internalProgram,
+                    ScanForProtection = false,
+                    PromptForDiscInformation = false,
+
+                    Username = username,
+                    Password = password,
+                };
+
+                var env = new DumpEnvironment(options, "", filepath, null, knownSystem, mediaType, null);
+                env.FixOutputPaths();
+
+                // Finally, attempt to do the output dance
+                var result = env.VerifyAndSaveDumpOutput(progress);
+                Console.WriteLine(result.Message);
+            }
+        }
+
+        /// <summary>
+        /// Display help for DICUI.Check
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        private static void DisplayHelp(string error = null)
+        {
+            if (error != null)
+                Console.WriteLine(error);
+
+            Console.WriteLine("Usage:");
+            Console.WriteLine("DICUI.Check.exe <mediatype> <system> [options] </path/to/output.bin> ...");
+            Console.WriteLine();
+            Console.WriteLine(@"Common Media Types:
+bd / bluray     - BD-ROM
+cd / cdrom      - CD-ROM
+dvd             - DVD-ROM
+fd / floppy     - Floppy Disk
+gd / gdrom      - GD-ROM
+umd             - UMD");
+            Console.WriteLine("Run 'DICUI.Check.exe [-lm|--listmedia' for more options");
+            Console.WriteLine();
+            Console.WriteLine(@"Common Systems:
+apple / mac     - Apple Macintosh
+cdi             - Philips CD-i
+ibm / ibmpc     - IBM PC Compatible
+psx / ps1       - Sony PlayStation
+ps2             - Sony PlayStation 2
+psp             - Sony PlayStation Portable
+saturn          - Sega Saturn
+xbox            - Microsoft XBOX
+x360            - Microsoft XBOX 360");
+            Console.WriteLine("Run 'DICUI.Check.exe [-ls|--listsystems' for more options");
+            Console.WriteLine();
+            Console.WriteLine(@"Common Options:
+-c username password    - Redump credentials
+-u                      - Set dumping program");
+            Console.WriteLine();
+            Console.WriteLine(@"Common Dumping Programs:
+cr / cleanrip   - CleanRip
+dic             - DiscImageCreator");
+            Console.WriteLine("Run 'DICUI.Check.exe [-lp|--listprograms' for more options");
+            Console.WriteLine();
+        }
+
+        /// <summary>
+        /// List all media types with their short usable names
+        /// </summary>
+        private static void ListMediaTypes()
+        {
+            Console.WriteLine("Supported Media Types:");
+            foreach (var val in Enum.GetValues(typeof(MediaType)))
+            {
+                if (((MediaType)val) == MediaType.NONE)
+                    continue;
+
+                Console.WriteLine($"{((MediaType?)val).ShortName()} - {((MediaType?)val).LongName()}");
+            }
+        }
+
+        /// <summary>
+        /// List all programs with their short usable names
+        /// </summary>
+        private static void ListPrograms()
+        {
+            Console.WriteLine("Supported Programs:");
+            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
+            {
+                if (((InternalProgram)val) == InternalProgram.NONE)
+                    continue;
+
+                Console.WriteLine($"{((InternalProgram?)val).LongName()}");
+            }
+        }
+
+        /// <summary>
+        /// List all known systems with their short usable names
+        /// </summary>
+        private static void ListKnownSystems()
+        {
+            Console.WriteLine("Supported Known Systems:");
+            foreach (var val in Enum.GetValues(typeof(KnownSystem)))
+            {
+                if (((KnownSystem)val) == KnownSystem.NONE)
+                    continue;
+
+                Console.WriteLine($"{((KnownSystem?)val).ShortName()} - {((KnownSystem?)val).LongName()}");
+            }
+        }
+
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        private static void ProgressUpdated(object sender, Result value)
+        {
+            Console.WriteLine(value.Message);
+        }
+    }
+}

DICUI.Check/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DICUI.Check")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DICUI.Check")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8cfde289-e171-4d49-a40d-5293265c1253")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.16.1")]
+[assembly: AssemblyFileVersion("1.16.1.0")]

DICUI.Library/Aaru/Constants.cs

@@ -0,0 +1,455 @@
+namespace DICUI.Aaru
+{
+    /// <summary>
+    /// Top-level commands for Aaru
+    /// </summary>
+    public static class CommandStrings
+    {
+        // 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 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 ImageAnalyze = "analyze";
+        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>
+    public static class EncodingStrings
+    {
+        public static string ArabicMac = "x-mac-arabic";
+        public static string AtariASCII = "atascii";
+        public static string CentralEuropeanMac = "x-mac-ce";
+        public static string CommodorePETSCII = "petscii";
+        public static string CroatianMac = "x-mac-croatian";
+        public static string CyrillicMac = "x-mac-cryillic";
+        public static string FarsiMac = "x-mac-farsi";
+        public static string GreekMac = "x-mac-greek";
+        public static string HebrewMac = "x-mac-hebrew";
+        public static string RomanianMac = "x-mac-romanian";
+        public static string SinclairZXSpectrum = "spectrum";
+        public static string SinclairZX80 = "zx80";
+        public static string SinclairZX81 = "zx81";
+        public static string TurkishMac = "x-mac-turkish";
+        public static string UkrainianMac = "x-mac-ukrainian";
+        public static string Unicode = "utf-16";
+        public static string UnicodeBigEndian = "utf-16BE";
+        public static string UnicodeUTF32BigEndian = "utf-32BE";
+        public static string UnicodeUTF32 = "utf-32";
+        public static string UnicodeUTF7 = "utf-7";
+        public static string UnicodeUTF8 = "utf-8";
+        public static string USASCII = "us-ascii";
+        public static string WesternEuropeanAppleII = "apple2";
+        public static string WesternEuropeanAppleIIc = "apple2c";
+        public static string WesternEuropeanAppleIIe = "apple2e";
+        public static string WesternEuropeanAppleIIgs = "apple2gs";
+        public static string WesternEuropeanAppleLisa = "lisa";
+        public static string WesternEuropeanAtariST = "atarist";
+        public static string WesternEuropeanGEM = "gem";
+        public static string WesternEuropeanGEOS = "geos";
+        public static string WesternEuropeanISO = "iso-8859-1";
+        public static string WesternEuropeanMac = "macintosh";
+        public static 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 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 Fletcher16Long = "--fletcher16";
+        public const string Fletcher32Long = "--fletcher32";
+        public const string ForceShort = "-f";
+        public const string ForceLong = "--force";
+        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 PersistentLong = "--persistent";
+        public const string ResumeShort = "-r";
+        public const string ResumeLong = "--resume";
+        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 SpamSumShort = "-f";
+        public const string SpamSumLong = "--spamsum";
+        public const string StopOnErrorShort = "-s";
+        public const string StopOnErrorLong = "--stop-on-error";
+        public const string TapeShort = "-t";
+        public const string TapeLong = "--tape";
+        public const string TrimLong = "--trim";
+        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 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 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>
+    public static class FormatStrings
+    {
+        // Supported filters
+        public static string AppleDouble = "AppleDouble";
+        public static string AppleSingle = "AppleSingle";
+        public static string BZip2 = "BZip2";
+        public static string GZip = "GZip";
+        public static string LZip = "LZip";
+        public static string MacBinary = "MacBinary";
+        public static string NoFilter = "No filter";
+        public static string PCExchange = "PCExchange";
+        public static string XZ = "XZ";
+
+        // Read-only media image formats
+        public static string AppleDiskArchivalRetrievalTool = "Apple Disk Archival/Retrieval Tool";
+        public static string AppleNewDiskImageFormat = "Apple New Disk Image Format";
+        public static string AppleNIB = "Apple NIB";
+        public static string BlindWrite4 = "BlindWrite 4";
+        public static string BlindWrite5 = "BlindWrite 5";
+        public static string CPCEMUDiskFileAndExtendedCPCDiskFile = "CPCEMU Disk-File and Extended CPC Disk-File";
+        public static string D2FDiskImage = "d2f disk image";
+        public static string D88DiskImage = "D88 Disk Image";
+        public static string DIMDiskImage = "DIM Disk Image";
+        public static string DiscFerret = "DiscFerret";
+        public static string DiscJuggler = "DiscJuggler";
+        public static string DreamcastGDIImage = "Dreamcast GDI image";
+        public static string DunfieldsIMD = "Dunfield's IMD";
+        public static string HDCopyDiskImage = "HD-Copy disk image";
+        public static string KryoFluxSTREAM = "KryoFlux STREAM";
+        public static string MAMECompressedHunksOfData = "MAME Compressed Hunks of Data";
+        public static string MicrosoftVHDX = "Microsoft VHDX";
+        public static string NeroBurningROMImage = "Nero Burning ROM image";
+        public static string PartCloneDiskImage = "PartClone disk image";
+        public static string PartimageDiskImage = "Partimage disk image";
+        public static string SpectrumFloppyDiskImage = "Spectrum Floppy Disk Image";
+        public static string SuperCardPro = "SuperCardPro";
+        public static string SydexCopyQM = "Sydex CopyQM";
+        public static string SydexTeleDisk = "Sydex TeleDisk";
+
+        // Read/write media image formats
+        public static string ACTApricotDiskImage = "ACT Apricot Disk Image";
+        public static string Alcohol120MediaDescriptorStructure = "Alcohol 120% Media Descriptor Structure";
+        public static string Anex86DiskImage = "Anex86 Disk Image";
+        public static string Apple2InterleavedDiskImage = "Apple ][Interleaved Disk Image";
+        public static string Apple2IMG = "Apple 2IMG";
+        public static string AppleDiskCopy42 = "Apple DiskCopy 4.2";
+        public static string AppleUniversalDiskImageFormat = "Apple Universal Disk Image Format";
+        public static string BasicLisaUtility = "Basic Lisa Utility";
+        public static string CDRDAOTocfile = "CDRDAO tocfile";
+        public static string CDRWinCuesheet = "CDRWin cuesheet";
+        public static string CisCopyDiskImageDCFile = "CisCopy Disk Image(DC-File)";
+        public static string CloneCD = "CloneCD";
+        public static string CopyTape = "CopyTape";
+        public static string DigitalResearchDiskCopy = "Digital Research DiskCopy";
+        public static string AaruFormat = "Aaru format";
+        public static string IBMSaveDskF = "IBM SaveDskF";
+        public static string MAXIDiskImage = "MAXI Disk image";
+        public static string ParallelsDiskImage = "Parallels disk image";
+        public static string QEMUCopyOnWriteDiskImage = "QEMU Copy-On-Write disk image";
+        public static string QEMUCopyOnWriteDiskImageV2 = "QEMU Copy-On-Write disk image v2";
+        public static string QEMUEnhancedDiskImage = "QEMU Enhanced Disk image";
+        public static string RawDiskImage = "Raw Disk Image";
+        public static string RayAracheliansDiskIMage = "Ray Arachelian's Disk IMage";
+        public static string RSIDEHardDiskImage = "RS-IDE Hard Disk Image";
+        public static string T98HardDiskImage = "T98 Hard Disk Image";
+        public static string T98NextNHDr0DiskImage = "T98-Next NHD r0 Disk Image";
+        public static string Virtual98DiskImage = "Virtual98 Disk Image";
+        public static string VirtualBoxDiskImage = "VirtualBox Disk Image";
+        public static string VirtualPC = "VirtualPC";
+        public static string VMwareDiskImage = "VMware disk image";
+
+        // Supported filesystems for identification and information only
+        public static string AcornAdvancedDiscFilingSystem = "Acorn Advanced Disc Filing System";
+        public static string AlexanderOsipovDOSFileSystem = "Alexander Osipov DOS file system";
+        public static string AmigaDOSFilesystem = "Amiga DOS filesystem";
+        public static string AppleFileSystem = "Apple File System";
+        public static string AppleHFSPlusFilesystem = "Apple HFS+ filesystem";
+        public static string AppleHierarchicalFileSystem = "Apple Hierarchical File System";
+        public static string AppleProDOSFilesystem = "Apple ProDOS filesystem";
+        public static string AtheOSFilesystem = "AtheOS Filesystem";
+        public static string BeFilesystem = "Be Filesystem";
+        public static string BSDFastFileSystem = "BSD Fast File System(aka UNIX File System, UFS)";
+        public static string BTreeFileSystem = "B-tree file system";
+        public static string CommodoreFileSystem = "Commodore file system";
+        public static string CramFilesystem = "Cram filesystem";
+        public static string DumpEightPlugin = "dump(8) Plugin";
+        public static string ECMA67 = "ECMA-67";
+        public static string ExtentFileSystemPlugin = "Extent File System Plugin";
+        public static string F2FSPlugin = "F2FS Plugin";
+        public static string Files11OnDiskStructure = "Files-11 On-Disk Structure";
+        public static string FossilFilesystemPlugin = "Fossil Filesystem Plugin";
+        public static string HAMMERFilesystem = "HAMMER Filesystem";
+        public static string HighPerformanceOpticalFileSystem = "High Performance Optical File System";
+        public static string HPLogicalInterchangeFormatPlugin = "HP Logical Interchange Format Plugin";
+        public static string JFSPlugin = "JFS Plugin";
+        public static string LinuxExtendedFilesystem = "Linux extended Filesystem";
+        public static string LinuxExtendedFilesystem234 = "Linux extended Filesystem 2, 3 and 4";
+        public static string LocusFilesystemPlugin = "Locus Filesystem Plugin";
+        public static string MicroDOSFileSystem = "MicroDOS file system";
+        public static string MicrosoftExtendedFileAllocationTable = "Microsoft Extended File Allocation Table";
+        public static string MinixFilesystem = "Minix Filesystem";
+        public static string NewTechnologyFileSystem = "New Technology File System(NTFS)";
+        public static string NILFS2Plugin = "NILFS2 Plugin";
+        public static string NintendoOpticalFilesystems = "Nintendo optical filesystems";
+        public static string OS2HighPerformanceFileSystem = "OS/2 High Performance File System";
+        public static string OS9RandomBlockFilePlugin = "OS-9 Random Block File Plugin";
+        public static string PCEngineCDPlugin = "PC Engine CD Plugin";
+        public static string PCFXPlugin = "PC-FX Plugin";
+        public static string ProfessionalFileSystem = "Professional File System";
+        public static string QNX4Plugin = "QNX4 Plugin";
+        public static string QNX6Plugin = "QNX6 Plugin";
+        public static string ReiserFilesystemPlugin = "Reiser Filesystem Plugin";
+        public static string Reiser4FilesystemPlugin = "Reiser4 Filesystem Plugin";
+        public static string ResilientFileSystemPlugin = "Resilient File System plugin";
+        public static string RT11FileSystem = "RT-11 file system";
+        public static string SmartFileSystem = "SmartFileSystem";
+        public static string SolarOSFilesystem = "Solar_OS filesystem";
+        public static string SquashFilesystem = "Squash filesystem";
+        public static string UNICOSFilesystemPlugin = "UNICOS Filesystem Plugin";
+        public static string UniversalDiskFormat = "Universal Disk Format";
+        public static string UNIXBootFilesystem = "UNIX Boot filesystem";
+        public static string UNIXSystemVFilesystem = "UNIX System V filesystem";
+        public static string VeritasFilesystem = "Veritas filesystem";
+        public static string VMwareFilesystem = "VMware filesystem";
+        public static string XFSFilesystemPlugin = "XFS Filesystem Plugin";
+        public static string XiaFilesystem = "Xia filesystem";
+        public static string ZFSFilesystemPlugin = "ZFS Filesystem Plugin";
+
+        // Supported filesystems that can read their contents
+        public static string AppleDOSFileSystem = "Apple DOS File System";
+        public static string AppleLisaFileSystem = "Apple Lisa File System";
+        public static string AppleMacintoshFileSystem = "Apple Macintosh File System";
+        public static string CPMFileSystem = "CP/M File System";
+        public static string FATXFilesystemPlugin = "FATX Filesystem Plugin";
+        public static string ISO9660Filesystem = "ISO9660 Filesystem";
+        public static string MicrosoftFileAllocationTable = "Microsoft File Allocation Table";
+        public static string OperaFilesystemPlugin = "Opera Filesystem Plugin";
+        public static string UCSDPascalFilesystem = "U.C.S.D.Pascal filesystem";
+
+        // Supported partitioning schemes
+        public static string AcornFileCorePartitions = "Acorn FileCore partitions";
+        public static string ACTApricotPartitions = "ACT Apricot partitions";
+        public static string AmigaRigidDiskBlock = "Amiga Rigid Disk Block";
+        public static string ApplePartitionMap = "Apple Partition Map";
+        public static string AtariPartitions = "Atari partitions";
+        public static string BSDDisklabel = "BSD disklabel";
+        public static string DECDisklabel = "DEC disklabel";
+        public static string DragonFlyBSD64bitDisklabel = "DragonFly BSD 64-bit disklabel";
+        public static string GUIDPartitionTable = "GUID Partition Table";
+        public static string Human68kPartitions = "Human 68k partitions";
+        public static string MasterBootRecord = "Master Boot Record";
+        public static string NECPC9800PartitionTable = "NEC PC-9800 partition table";
+        public static string NeXTDisklabel = "NeXT Disklabel";
+        public static string Plan9PartitionTable = "Plan9 partition table";
+        public static string RioKarmaPartitioning = "Rio Karma partitioning";
+        public static string SGIDiskVolumeHeader = "SGI Disk Volume Header";
+        public static string SunDisklabel = "Sun Disklabel";
+        public static string UNIXHardwired = "UNIX hardwired";
+        public static string UNIXVTOC = "UNIX VTOC";
+        public static string XboxPartitioning = "Xbox partitioning";
+        public static string XENIX = "XENIX";
+    }
+
+    /// <summary>
+    /// Supported namespaces for Aaru
+    /// </summary>
+    public static class NamespaceStrings
+    {
+        // Namespaces for Apple Lisa File System
+        public static string LisaOfficeSystem = "office";
+        public static string LisaPascalWorkshop = "workshop";
+
+        // Namespaces for ISO9660 Filesystem
+        public static string JolietVolumeDescriptor = "joliet";
+        public static string PrimaryVolumeDescriptor = "normal";
+        public static string PrimaryVolumeDescriptorwithEncoding = "romeo";
+        public static string RockRidge = "rrip";
+        public static string PrimaryVolumeDescriptorVersionSuffix = "vms";
+
+        // Namespaces for Microsoft File Allocation Table
+        public static string DOS = "dos";
+        public static string LFNWhenAvailable = "ecs";
+        public static string LongFileNames = "lfn";
+        public static string WindowsNT = "nt";
+        public static string OS2Extended = "os2";
+    }
+
+    /// <summary>
+    /// Supported options for Aaru
+    /// </summary>
+    public static class OptionStrings
+    {
+        // ACT Apricot Disk Image
+        public static string ACTApricotDiskImageCompress = "compress"; // boolean, default false
+
+        // Apple DiskCopy 4.2
+        public static string AppleDiskCopyMacOSX = "macosx"; // boolean, default false
+
+        // CDRDAO tocfile
+        public static string CDRDAOTocfileSeparate = "separate"; // boolean, default false
+
+        // CDRWin cuesheet
+        public static string CDRWinCuesheetSeparate = "separate"; // boolean, default false
+
+        // Aaru format
+        public static string AaruDeduplicate = "deduplicate"; // boolean, default true
+        public static string AaruDictionary = "dictionary"; // number, default 33554432
+        public static string AaruMaxDDTSize = "max_ddt_size"; // number, default 256
+        public static string AaruMD5 = "md5"; // boolean, default false
+        public static string AaruNoCompress = "nocompress"; // boolean, default false
+        public static string AaruSectorsPerBlock = "sectors_per_block"; // number, default 4096
+        public static string AaruSHA1 = "sha1"; // boolean, default false
+        public static string AaruSHA256 = "sha256"; // boolean, default false
+        public static string AaruSpamSum = "spamsum"; // boolean, default false
+
+        // VMware disk image
+        public static string VMwareDiskImageAdapterType = "adapter_type"; // string, default ide
+        public static string VMwareDiskImageHWVersion = "hwversion"; // number, default 4
+        public static string VMwareDiskImageSparse = "sparse"; // boolean, default false
+        public static string VMwareDiskImageSplit = "split"; // boolean, default false
+    }
+}

DICUI.Library/Aaru/Converters.cs

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

DICUI.Library/Aaru/Enumerations.cs

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

DICUI.Library/CleanRIp/Parameters.cs

@@ -0,0 +1,319 @@
+using System.IO;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI.CleanRip
+{
+    /// <summary>
+    /// Represents a generic set of CleanRip parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        /// <summary>
+        /// Populate a Parameters object from a param string
+        /// </summary>
+        /// <param name="parameters">String possibly representing a set of parameters</param>
+        public Parameters(string parameters)
+            : base(parameters)
+        {
+            this.InternalProgram = InternalProgram.CleanRip;
+        }
+
+        /// <summary>
+        /// Generate parameters based on a set of known inputs
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="quietMode">Enable quiet mode (no beeps)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        public Parameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, bool paranoid, bool quietMode, int retryCount)
+            : base(system, type, driveLetter, filename, driveSpeed, paranoid, quietMode, retryCount)
+        {
+        }
+
+        /// <summary>
+        /// Blindly generate a parameter string based on the inputs
+        /// </summary>
+        /// <returns>Correctly formatted parameter string, null on error</returns>
+        public override string GenerateParameters() => null;
+
+        /// <summary>
+        /// Get the input path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public override string InputPath() => null;
+
+        /// <summary>
+        /// Get the output path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public override string OutputPath() => null;
+
+        /// <summary>
+        /// Get the processing speed from the implementation
+        /// </summary>
+        /// <returns>int? representing the speed, null on error</returns>
+        public override int? GetSpeed() => null;
+
+        /// <summary>
+        /// Set the processing speed int the implementation
+        /// </summary>
+        /// <param name="speed">int? representing the speed</param>
+        public override void SetSpeed(int? speed) { }
+
+        /// <summary>
+        /// Get the MediaType from the current set of parameters
+        /// </summary>
+        /// <returns>MediaType value if successful, null on error</returns>
+        public override MediaType? GetMediaType() => null;
+
+        /// <summary>
+        /// Gets if the current command is considered a dumping command or not
+        /// </summary>
+        /// <returns>True if it's a dumping command, false otherwise</returns>
+        public override bool IsDumpingCommand() => true;
+
+        /// <summary>
+        /// Reset all special variables to have default values
+        /// </summary>
+        protected override void ResetValues() { }
+
+        /// <summary>
+        /// Set default parameters for a given system and media type
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        protected override void SetDefaultParameters(
+            KnownSystem? system,
+            MediaType? type,
+            char driveLetter,
+            string filename,
+            int? driveSpeed,
+            bool paranoid,
+            int retryCount)
+        {
+        }
+
+        /// <summary>
+        /// Scan a possible parameter string and populate whatever possible
+        /// </summary>
+        /// <param name="parameters">String possibly representing parameters</param>
+        /// <returns></returns>
+        protected override bool ValidateAndSetParameters(string parameters) => true;
+
+        /// <summary>
+        /// Validate if all required output files exist
+        /// </summary>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <returns></returns>
+        public override bool CheckAllOutputFilesExist(string basePath, KnownSystem? system, MediaType? type)
+        {
+            switch (type)
+            {
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return File.Exists(basePath + "-dumpinfo.txt")
+                        && File.Exists(basePath + ".bca");
+
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Generate a SubmissionInfo for the output files
+        /// </summary>
+        /// <param name="info">Base submission info to fill in specifics for</param>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <param name="drive">Drive representing the disc to get information from</param>
+        /// <returns></returns>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, KnownSystem? system, MediaType? type, Drive drive)
+        {
+            info.TracksAndWriteOffsets.ClrMameProData = GetCleanripDatfile(basePath + ".iso", basePath + "-dumpinfo.txt");
+
+            // Extract info based generically on MediaType
+            switch (type)
+            {
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    if (File.Exists(basePath + ".bca"))
+                        info.Extras.BCA = GetFullFile(basePath + ".bca", true);
+
+                    if (GetGameCubeWiiInformation(basePath + "-dumpinfo.txt", out Region? gcRegion, out string gcVersion))
+                    {
+                        info.CommonDiscInfo.Region = info.CommonDiscInfo.Region ?? gcRegion;
+                        info.VersionAndEditions.Version = string.IsNullOrEmpty(info.VersionAndEditions.Version) ? gcVersion : info.VersionAndEditions.Version;
+                    }
+
+                    break;
+            }
+        }
+
+        #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>
+        private string GetCleanripDatfile(string iso, string dumpinfo)
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return null;
+
+            using (StreamReader 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"))
+                        return null;
+
+                    // Read all lines and gather dat information
+                    while (!sr.EndOfStream)
+                    {
+                        string line = sr.ReadLine().Trim();
+                        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);
+                    }
+
+                    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>
+        /// <returns></returns>
+        private bool GetGameCubeWiiInformation(string dumpinfo, out Region? region, out string version)
+        {
+            region = null; version = null;
+
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(dumpinfo))
+                return false;
+
+            using (StreamReader sr = File.OpenText(dumpinfo))
+            {
+                try
+                {
+                    // Make sure this file is a dumpinfo
+                    if (!sr.ReadLine().Contains("--File Generated by CleanRip"))
+                        return false;
+
+                    // Read all lines and gather dat information
+                    while (!sr.EndOfStream)
+                    {
+                        string line = sr.ReadLine().Trim();
+                        if (line.StartsWith("Version"))
+                        {
+                            version = line.Substring(9);
+                        }
+                        else if (line.StartsWith("Filename"))
+                        {
+                            string serial = line.Substring(10);
+
+                            // 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.USA;
+                                    break;
+                                case 'F':
+                                    region = Region.France;
+                                    break;
+                                case 'I':
+                                    region = Region.Italy;
+                                    break;
+                                case 'J':
+                                    region = Region.Japan;
+                                    break;
+                                case 'K':
+                                    region = Region.Korea;
+                                    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.USA; // Japanese import to USA
+                                    break;
+                                case 'P':
+                                    region = Region.Europe;
+                                    break;
+                                case 'R':
+                                    region = Region.Russia;
+                                    break;
+                                case 'S':
+                                    region = Region.Spain;
+                                    break;
+                                case 'Q':
+                                    region = Region.Korea; // Korea with Japanese language
+                                    break;
+                                case 'T':
+                                    region = Region.Korea; // 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
+    }
+}

DICUI.Library/DD/Constants.cs

@@ -0,0 +1,31 @@
+namespace DICUI.DD
+{
+    /// <summary>
+    /// Top-level commands for DD
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string List = "--list";
+    }
+
+    /// <summary>
+    /// Dumping flags for DD
+    /// </summary>
+    public static class FlagStrings
+    {
+        // Boolean flags
+        public const string Progress = "--progress";
+        public const string Size = "--size";
+
+        // Int64 flags
+        public const string BlockSize = "bs";
+        public const string Count = "count";
+        public const string Seek = "seek";
+        public const string Skip = "skip";
+
+        // String flags
+        public const string Filter = "--filter";
+        public const string InputFile = "if";
+        public const string OutputFile = "of";
+    }
+}

DICUI.Library/DD/Converters.cs

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

DICUI.Library/DD/Enumerations.cs

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

DICUI.Library/DD/Parameters.cs

@@ -0,0 +1,620 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI.DD
+{
+    /// <summary>
+    /// Represents a generic set of DD parameters
+    /// </summary>
+    public class Parameters : BaseParameters
+    {
+        /// <summary>
+        /// Base command to run
+        /// </summary>
+        public Command BaseCommand { get; set; }
+
+        /// <summary>
+        /// Set of flags to pass to the executable
+        /// </summary>
+        protected Dictionary<Flag, bool?> _flags = new Dictionary<Flag, bool?>();
+        public bool? this[Flag key]
+        {
+            get
+            {
+                if (_flags.ContainsKey(key))
+                    return _flags[key];
+
+                return null;
+            }
+            set
+            {
+                _flags[key] = value;
+            }
+        }
+        protected internal IEnumerable<Flag> Keys => _flags.Keys;
+
+        #region Flag Values
+
+        public long? BlockSizeValue { get; set; }
+
+        public long? CountValue { get; set; }
+
+        // fixed, removable, disk, partition
+        public string FilterValue { get; set; }
+
+        public string InputFileValue { get; set; }
+
+        public string OutputFileValue { get; set; }
+
+        public long? SeekValue { get; set; }
+
+        public long? SkipValue { get; set; }
+
+        #endregion
+
+        /// <summary>
+        /// Populate a Parameters object from a param string
+        /// </summary>
+        /// <param name="parameters">String possibly representing a set of parameters</param>
+        public Parameters(string parameters)
+            : base(parameters)
+        {
+            this.InternalProgram = InternalProgram.DD;
+        }
+
+        /// <summary>
+        /// Generate parameters based on a set of known inputs
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="quietMode">Enable quiet mode (no beeps)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        public Parameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, bool paranoid, bool quietMode, int retryCount)
+            : base(system, type, driveLetter, filename, driveSpeed, paranoid, quietMode, retryCount)
+        {
+        }
+
+        /// <summary>
+        /// Blindly generate a parameter string based on the inputs
+        /// </summary>
+        /// <returns>Correctly formatted parameter string, null on error</returns>
+        public override string GenerateParameters()
+        {
+            List<string> parameters = new List<string>();
+
+            if (BaseCommand != Command.NONE)
+                parameters.Add(Converters.LongName(BaseCommand));
+
+            #region Boolean flags
+
+            // Progress
+            if (GetSupportedCommands(Flag.Progress).Contains(BaseCommand))
+            {
+                if (this[Flag.Progress] == true)
+                    parameters.Add($"{this[Flag.Progress]}");
+            }
+
+            // Size
+            if (GetSupportedCommands(Flag.Size).Contains(BaseCommand))
+            {
+                if (this[Flag.Size] == true)
+                    parameters.Add($"{this[Flag.Size]}");
+            }
+
+            #endregion
+
+            #region Int64 flags
+
+            // Block Size
+            if (GetSupportedCommands(Flag.BlockSize).Contains(BaseCommand))
+            {
+                if (this[Flag.BlockSize] == true && BlockSizeValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.BlockSize)}={BlockSizeValue}");
+            }
+
+            // Count
+            if (GetSupportedCommands(Flag.Count).Contains(BaseCommand))
+            {
+                if (this[Flag.Count] == true && CountValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.Count)}={CountValue}");
+            }
+
+            // Seek
+            if (GetSupportedCommands(Flag.Seek).Contains(BaseCommand))
+            {
+                if (this[Flag.Seek] == true && SeekValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.Seek)}={SeekValue}");
+            }
+
+            // Skip
+            if (GetSupportedCommands(Flag.Skip).Contains(BaseCommand))
+            {
+                if (this[Flag.Skip] == true && SkipValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.Skip)}={SkipValue}");
+            }
+
+            #endregion
+
+            #region String flags
+
+            // Filter
+            if (GetSupportedCommands(Flag.Filter).Contains(BaseCommand))
+            {
+                if (this[Flag.Filter] == true && FilterValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.Filter)}={FilterValue}");
+            }
+
+            // Input File
+            if (GetSupportedCommands(Flag.InputFile).Contains(BaseCommand))
+            {
+                if (this[Flag.InputFile] == true && InputFileValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.InputFile)}={InputFileValue}");
+                else
+                    return null;
+            }
+
+            // Output File
+            if (GetSupportedCommands(Flag.OutputFile).Contains(BaseCommand))
+            {
+                if (this[Flag.OutputFile] == true && OutputFileValue != null)
+                    parameters.Add($"{Converters.LongName(Flag.OutputFile)}={OutputFileValue}");
+                else
+                    return null;
+            }
+
+            #endregion
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Get the input path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public override string InputPath() => InputFileValue;
+
+        /// <summary>
+        /// Get the output path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public override string OutputPath() => OutputFileValue;
+
+        /// <summary>
+        /// Get the processing speed from the implementation
+        /// </summary>
+        /// <returns>int? representing the speed, null on error</returns>
+        /// <remarks>DD does not support drive speeds</remarks>
+        public override int? GetSpeed() => 1;
+
+        /// <summary>
+        /// Set the processing speed int the implementation
+        /// </summary>
+        /// <param name="speed">int? representing the speed</param>
+        /// <remarks>DD does not support drive speeds</remarks>
+        public override void SetSpeed(int? speed)
+        {
+        }
+
+        /// <summary>
+        /// Get the MediaType from the current set of parameters
+        /// </summary>
+        /// <returns>MediaType value if successful, null on error</returns>
+        /// <remarks>DD does not know the difference between media types</remarks>
+        public override MediaType? GetMediaType() => null;
+
+        /// <summary>
+        /// Gets if the current command is considered a dumping command or not
+        /// </summary>
+        /// <returns>True if it's a dumping command, false otherwise</returns>
+        public override bool IsDumpingCommand()
+        {
+            switch (this.BaseCommand)
+            {
+                case Command.List:
+                    return false;
+                default:
+                    return true;
+            }
+        }
+
+        /// <summary>
+        /// Reset all special variables to have default values
+        /// </summary>
+        protected override void ResetValues()
+        {
+            BaseCommand = Command.NONE;
+
+            _flags = new Dictionary<Flag, bool?>();
+
+            BlockSizeValue = null;
+            CountValue = null;
+            InputFileValue = null;
+            OutputFileValue = null;
+            SeekValue = null;
+            SkipValue = null;
+        }
+
+        /// <summary>
+        /// Set default parameters for a given system and media type
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        protected override void SetDefaultParameters(
+            KnownSystem? system,
+            MediaType? type,
+            char driveLetter,
+            string filename,
+            int? driveSpeed,
+            bool paranoid,
+            int retryCount)
+        {
+            BaseCommand = Command.NONE;
+
+            this[Flag.InputFile] = true;
+            InputFileValue = $"\\\\?\\{driveLetter}:";
+
+            this[Flag.OutputFile] = true;
+            OutputFileValue = filename;
+
+            // TODO: Add more common block sizes
+            this[Flag.BlockSize] = true;
+            switch (type)
+            {
+                case MediaType.FloppyDisk:
+                    BlockSizeValue = 1440 * 1024;
+                    break;
+
+                default:
+                    BlockSizeValue = 1024 * 1024 * 1024;
+                    break;
+            }
+
+            this[Flag.Progress] = true;
+            this[Flag.Size] = true;
+        }
+
+        /// <summary>
+        /// Scan a possible parameter string and populate whatever possible
+        /// </summary>
+        /// <param name="parameters">String possibly representing parameters</param>
+        /// <returns></returns>
+        protected override bool ValidateAndSetParameters(string parameters)
+        {
+            // The string has to be valid by itself first
+            if (string.IsNullOrWhiteSpace(parameters))
+                return false;
+
+            // Now split the string into parts for easier validation
+            // https://stackoverflow.com/questions/14655023/split-a-string-that-has-white-spaces-unless-they-are-enclosed-within-quotes
+            parameters = parameters.Trim();
+            List<string> parts = Regex.Matches(parameters, @"[\""].+?[\""]|[^ ]+")
+                .Cast<Match>()
+                .Select(m => m.Value)
+                .ToList();
+
+            // Determine what the commandline should look like given the first item
+            int start = 0;
+            BaseCommand = Converters.StringToCommand(parts[0]);
+            if (BaseCommand != Command.NONE)
+                start = 1;
+
+            // Loop through all auxilary flags, if necessary
+            int i = 0;
+            for (i = start; i < parts.Count; i++)
+            {
+                // Flag read-out values
+                long? longValue = null;
+                string stringValue = null;
+
+                // Keep a count of keys to determine if we should break out to filename handling or not
+                int keyCount = Keys.Count();
+
+                #region Boolean flags
+
+                // Progress
+                ProcessBooleanParameter(parts, FlagStrings.Progress, Flag.Progress, ref i);
+
+                // Size
+                ProcessBooleanParameter(parts, FlagStrings.Size, Flag.Size, ref i);
+
+                #endregion
+
+                #region Int64 flags
+
+                // Block Size
+                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, Flag.BlockSize, ref i);
+                if (longValue == Int64.MinValue)
+                    return false;
+                else if (longValue != null)
+                    BlockSizeValue = longValue;
+
+                // Count
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, Flag.Count, ref i);
+                if (longValue == Int64.MinValue)
+                    return false;
+                else if (longValue != null)
+                    CountValue = longValue;
+
+                // Seek
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, Flag.Seek, ref i);
+                if (longValue == Int64.MinValue)
+                    return false;
+                else if (longValue != null)
+                    SeekValue = longValue;
+
+                // Skip
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, Flag.Skip, ref i);
+                if (longValue == Int64.MinValue)
+                    return false;
+                else if (longValue != null)
+                    SkipValue = longValue;
+
+                #endregion
+
+                #region String flags
+
+                // Filter (fixed, removable, disk, partition)
+                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, Flag.Filter, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
+                    FilterValue = stringValue;
+
+                // Input File
+                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, Flag.InputFile, ref i);
+                if (string.Equals(stringValue, string.Empty))
+                    return false;
+                else if (stringValue != null)
+                    InputFileValue = stringValue;
+
+                // Output File
+                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, Flag.OutputFile, ref i);
+                if (string.Equals(stringValue, string.Empty))
+                    return false;
+                else if (stringValue != null)
+                    OutputFileValue = stringValue;
+
+                #endregion
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Validate if all required output files exist
+        /// </summary>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <returns></returns>
+        public override bool CheckAllOutputFilesExist(string basePath, KnownSystem? system, MediaType? type)
+        {
+            // TODO: Figure out what sort of output files are expected... just `.bin`?
+            return true;
+        }
+
+        /// <summary>
+        /// Generate a SubmissionInfo for the output files
+        /// </summary>
+        /// <param name="info">Base submission info to fill in specifics for</param>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <param name="drive">Drive representing the disc to get information from</param>
+        /// <returns></returns>
+        public override void GenerateSubmissionInfo(SubmissionInfo info, string basePath, KnownSystem? system, MediaType? type, Drive drive)
+        {
+            // TODO: Implement getting submission info, if possible
+        }
+
+        /// <summary>
+        /// Get the list of commands that use a given flag
+        /// </summary>
+        /// <param name="flag">Flag value to get commands for</param>
+        /// <returns>List of Commands, if possible</returns>
+        private List<Command> GetSupportedCommands(Flag flag)
+        {
+            var commands = new List<Command>();
+            switch (flag)
+            {
+                #region Boolean flags
+
+                case Flag.Progress:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.Size:
+                    commands.Add(Command.NONE);
+                    break;
+
+                #endregion
+
+                #region Int64 flags
+
+                case Flag.BlockSize:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.Count:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.Seek:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.Skip:
+                    commands.Add(Command.NONE);
+                    break;
+
+                #endregion
+
+                #region String flags
+
+                case Flag.Filter:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.InputFile:
+                    commands.Add(Command.NONE);
+                    break;
+                case Flag.OutputFile:
+                    commands.Add(Command.NONE);
+                    break;
+
+                #endregion
+
+                case Flag.NONE:
+                default:
+                    return commands;
+            }
+
+            return commands;
+        }
+
+        /// <summary>
+        /// Process a boolean parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string to check</param>
+        /// <param name="flag">Flag value corresponding to the flag</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
+        private bool ProcessBooleanParameter(List<string> parts, string flagString, Flag flag, ref int i)
+        {
+            if (parts == null)
+                return false;
+
+            if (parts[i] == flagString)
+            {
+                if (!GetSupportedCommands(flag).Contains(BaseCommand))
+                    return false;
+
+                this[flag] = true;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Process an Int64 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string to check</param>
+        /// <param name="flag">Flag value corresponding to the flag</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
+        private long? ProcessInt64Parameter(List<string> parts, string flagString, Flag flag, ref int i)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i].StartsWith(flagString))
+            {
+                if (!GetSupportedCommands(flag).Contains(BaseCommand))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+                long factor = 1;
+
+                // Characters
+                if (valuePart.EndsWith("c", StringComparison.Ordinal))
+                {
+                    factor = 1;
+                    valuePart.TrimEnd('c');
+                }
+
+                // Words
+                else if (valuePart.EndsWith("w", StringComparison.Ordinal))
+                {
+                    factor = 2;
+                    valuePart.TrimEnd('w');
+                }
+
+                // Double Words
+                else if (valuePart.EndsWith("d", StringComparison.Ordinal))
+                {
+                    factor = 4;
+                    valuePart.TrimEnd('d');
+                }
+
+                // Quad Words
+                else if (valuePart.EndsWith("q", StringComparison.Ordinal))
+                {
+                    factor = 8;
+                    valuePart.TrimEnd('q');
+                }
+
+                // Kilobytes
+                else if (valuePart.EndsWith("k", StringComparison.Ordinal))
+                {
+                    factor = 1024;
+                    valuePart.TrimEnd('k');
+                }
+
+                // Megabytes
+                else if (valuePart.EndsWith("M", StringComparison.Ordinal))
+                {
+                    factor = 1024 * 1024;
+                    valuePart.TrimEnd('M');
+                }
+
+                // Gigabytes
+                else if (valuePart.EndsWith("G", StringComparison.Ordinal))
+                {
+                    factor = 1024 * 1024 * 1024;
+                    valuePart.TrimEnd('G');
+                }
+
+                if (!IsValidInt64(valuePart))
+                    return null;
+
+                this[flag] = true;
+                return long.Parse(valuePart) * factor;
+            }
+
+            return Int64.MinValue;
+        }
+
+        /// <summary>
+        /// Process a string parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string to check</param>
+        /// <param name="flag">Flag value corresponding to the flag</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <returns>String value if possible, string.Empty on missing, null on error</returns>
+        private string ProcessStringParameter(List<string> parts, string flagString, Flag flag, ref int i)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == flagString)
+            {
+                if (!GetSupportedCommands(flag).Contains(BaseCommand))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                this[flag] = true;
+                return valuePart.Trim('"');
+            }
+
+            return string.Empty;
+        }
+    }
+}

DICUI.Library/DICUI.Library.csproj

@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='netcoreapp3.1'">
+    <DefineConstants>NET_FRAMEWORK</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'!='netcoreapp3.1'">
+    <COMReference Include="IMAPI2">
+      <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+    <COMReference Include="IMAPI2FS">
+      <Guid>{2C941FD0-975B-59BE-A960-9A2A262853A5}</Guid>
+      <VersionMajor>1</VersionMajor>
+      <VersionMinor>0</VersionMinor>
+      <Lcid>0</Lcid>
+      <WrapperTool>tlbimp</WrapperTool>
+      <Isolated>False</Isolated>
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </COMReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BurnOutSharp" Version="1.3.9.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="System.Management" Version="4.7.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="System.Management" />
+  </ItemGroup>
+
+</Project>

DICUI.Library/Data/BaseParameters.cs

@@ -0,0 +1,382 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using DICUI.Utilities;
+
+namespace DICUI.Data
+{
+    public abstract class BaseParameters
+    {
+        /// <summary>
+        /// Path to the executable
+        /// </summary>
+        public string ExecutablePath { get; set; }
+
+        /// <summary>
+        /// Program that this set of parameters represents
+        /// </summary>
+        public InternalProgram InternalProgram { get; set; }
+
+        /// <summary>
+        /// Process to track external program
+        /// </summary>
+        private Process process;
+
+        /// <summary>
+        /// Populate a Parameters object from a param string
+        /// </summary>
+        /// <param name="parameters">String possibly representing a set of parameters</param>
+        public BaseParameters(string parameters)
+        {
+            // If any parameters are not valid, wipe out everything
+            if (!ValidateAndSetParameters(parameters))
+            {
+                ResetValues();
+            }
+        }
+
+        /// <summary>
+        /// Generate parameters based on a set of known inputs
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="quietMode">Enable quiet mode (no beeps)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        public BaseParameters(KnownSystem? system, MediaType? type, char driveLetter, string filename, int? driveSpeed, bool paranoid, bool quietMode, int retryCount)
+        {
+            SetDefaultParameters(system, type, driveLetter, filename, driveSpeed, paranoid, retryCount);
+        }
+
+        /// <summary>
+        /// Blindly generate a parameter string based on the inputs
+        /// </summary>
+        /// <returns>Correctly formatted parameter string, null on error</returns>
+        public abstract string GenerateParameters();
+
+        /// <summary>
+        /// Get the input path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public abstract string InputPath();
+
+        /// <summary>
+        /// Get the output path from the implementation
+        /// </summary>
+        /// <returns>String representing the path, null on error</returns>
+        public abstract string OutputPath();
+
+        /// <summary>
+        /// Get the processing speed from the implementation
+        /// </summary>
+        /// <returns>int? representing the speed, null on error</returns>
+        public abstract int? GetSpeed();
+
+        /// <summary>
+        /// Set the processing speed int the implementation
+        /// </summary>
+        /// <param name="speed">int? representing the speed</param>
+        public abstract void SetSpeed(int? speed);
+
+        /// <summary>
+        /// Get the MediaType from the current set of parameters
+        /// </summary>
+        /// <returns>MediaType value if successful, null on error</returns>
+        public abstract MediaType? GetMediaType();
+
+        /// <summary>
+        /// Gets if the current command is considered a dumping command or not
+        /// </summary>
+        /// <returns>True if it's a dumping command, false otherwise</returns>
+        public abstract bool IsDumpingCommand();
+
+        /// <summary>
+        /// Returns if the current Parameter object is valid
+        /// </summary>
+        /// <returns></returns>
+        public bool IsValid()
+        {
+            return GenerateParameters() != null;
+        }
+
+        /// <summary>
+        /// Reset all special variables to have default values
+        /// </summary>
+        protected abstract void ResetValues();
+
+        /// <summary>
+        /// Set default parameters for a given system and media type
+        /// </summary>
+        /// <param name="system">KnownSystem value to use</param>
+        /// <param name="type">MediaType value to use</param>
+        /// <param name="driveLetter">Drive letter to use</param>
+        /// <param name="filename">Filename to use</param>
+        /// <param name="driveSpeed">Drive speed to use</param>
+        /// <param name="paranoid">Enable paranoid mode (safer dumping)</param>
+        /// <param name="retryCount">User-defined reread count</param>
+        protected abstract void SetDefaultParameters(
+            KnownSystem? system,
+            MediaType? type,
+            char driveLetter,
+            string filename,
+            int? driveSpeed,
+            bool paranoid,
+            int retryCount);
+
+        /// <summary>
+        /// Scan a possible parameter string and populate whatever possible
+        /// </summary>
+        /// <param name="parameters">String possibly representing parameters</param>
+        /// <returns></returns>
+        protected abstract bool ValidateAndSetParameters(string parameters);
+
+        /// <summary>
+        /// Validate if all required output files exist
+        /// </summary>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <returns></returns>
+        public abstract bool CheckAllOutputFilesExist(string basePath, KnownSystem? system, MediaType? type);
+
+        /// <summary>
+        /// Generate a SubmissionInfo for the output files
+        /// </summary>
+        /// <param name="submissionInfo">Base submission info to fill in specifics for</param>
+        /// <param name="basePath">Base filename and path to use for checking</param>
+        /// <param name="system">KnownSystem type representing the media</param>
+        /// <param name="type">MediaType type representing the media</param>
+        /// <param name="drive">Drive representing the disc to get information from</param>
+        public abstract void GenerateSubmissionInfo(SubmissionInfo submissionInfo, string basePath, KnownSystem? system, MediaType? type, Drive drive);
+
+        /// <summary>
+        /// Run internal program
+        /// </summary>
+        public void ExecuteInternalProgram()
+        {
+            process = new Process()
+            {
+                StartInfo = new ProcessStartInfo()
+                {
+                    FileName = ExecutablePath,
+                    Arguments = GenerateParameters() ?? "",
+                },
+            };
+
+            process.Start();
+            process.WaitForExit();
+        }
+
+        /// <summary>
+        /// Run internal program async with an input set of parameters
+        /// </summary>
+        /// <param name="parameters"></param>
+        /// <returns>Standard output from commandline window</returns>
+        public 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>
+        /// Cancel an in-progress dumping process
+        /// </summary>
+        public void KillInternalProgram()
+        {
+            try
+            {
+                if (process != null && !process.HasExited)
+                    process.Kill();
+            }
+            catch
+            { }
+        }
+
+        /// <summary>
+        /// Returns whether or not the selected item exists
+        /// </summary>
+        /// <param name="parameters">List of parameters to check against</param>
+        /// <param name="index">Current index</param>
+        /// <returns>True if the next item exists, false otherwise</returns>
+        protected bool DoesExist(List<string> parameters, int index)
+        {
+            if (index >= parameters.Count)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Get the full lines from the input file, if possible
+        /// </summary>
+        /// <param name="filename">file location</param>
+        /// <param name="binary">True if should read as binary, false otherwise (default)</param>
+        /// <returns>Full text of the file, null on error</returns>
+        protected string GetFullFile(string filename, bool binary = false)
+        {
+            // If the file doesn't exist, we can't get info from it
+            if (!File.Exists(filename))
+                return null;
+
+            // If we're reading as binary
+            if (binary)
+            {
+                string hex = string.Empty;
+                using (BinaryReader br = new BinaryReader(File.OpenRead(filename)))
+                {
+                    while (br.BaseStream.Position < br.BaseStream.Length)
+                    {
+                        hex += Convert.ToString(br.ReadByte(), 16);
+                    }
+                }
+                return hex;
+            }
+
+            return string.Join("\n", File.ReadAllLines(filename));
+        }
+
+        /// <summary>
+        /// Returns whether a string is a flag (starts with '/')
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <returns>True if it's a flag, false otherwise</returns>
+        protected bool IsFlag(string parameter)
+        {
+            if (parameter.Trim('\"').StartsWith("/"))
+                return true;
+
+            return false;
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid drive letter
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <returns>True if it's a valid drive letter, false otherwise</returns>
+        protected bool IsValidDriveLetter(string parameter)
+        {
+            if (!Regex.IsMatch(parameter, @"^[A-Z]:?\\?$"))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid bool
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <returns>True if it's a valid bool, false otherwise</returns>
+        protected bool IsValidBool(string parameter)
+        {
+            return bool.TryParse(parameter, out bool temp);
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid byte
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <param name="lowerBound">Lower bound (>=)</param>
+        /// <param name="upperBound">Upper bound (<=)</param>
+        /// <returns>True if it's a valid byte, false otherwise</returns>
+        protected bool IsValidInt8(string parameter, sbyte lowerBound = -1, sbyte upperBound = -1)
+        {
+            if (!sbyte.TryParse(parameter, out sbyte temp))
+                return false;
+            else if (lowerBound != -1 && temp < lowerBound)
+                return false;
+            else if (upperBound != -1 && temp > upperBound)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid Int16
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <param name="lowerBound">Lower bound (>=)</param>
+        /// <param name="upperBound">Upper bound (<=)</param>
+        /// <returns>True if it's a valid Int16, false otherwise</returns>
+        protected bool IsValidInt16(string parameter, short lowerBound = -1, short upperBound = -1)
+        {
+            if (!short.TryParse(parameter, out short temp))
+                return false;
+            else if (lowerBound != -1 && temp < lowerBound)
+                return false;
+            else if (upperBound != -1 && temp > upperBound)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid Int32
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <param name="lowerBound">Lower bound (>=)</param>
+        /// <param name="upperBound">Upper bound (<=)</param>
+        /// <returns>True if it's a valid Int32, false otherwise</returns>
+        protected bool IsValidInt32(string parameter, int lowerBound = -1, int upperBound = -1)
+        {
+            if (!int.TryParse(parameter, out int temp))
+                return false;
+            else if (lowerBound != -1 && temp < lowerBound)
+                return false;
+            else if (upperBound != -1 && temp > upperBound)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns whether a string is a valid Int64
+        /// </summary>
+        /// <param name="parameter">String value to check</param>
+        /// <param name="lowerBound">Lower bound (>=)</param>
+        /// <param name="upperBound">Upper bound (<=)</param>
+        /// <returns>True if it's a valid Int64, false otherwise</returns>
+        protected bool IsValidInt64(string parameter, long lowerBound = -1, long upperBound = -1)
+        {
+            if (!long.TryParse(parameter, out long temp))
+                return false;
+            else if (lowerBound != -1 && temp < lowerBound)
+                return false;
+            else if (upperBound != -1 && temp > upperBound)
+                return false;
+
+            return true;
+        }
+    }
+}

DICUI.Library/Data/Constants.cs

@@ -0,0 +1,69 @@
+namespace DICUI.Data
+{
+    /// <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 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 MatchingIDsField = "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 XBOXDMIHash = "DMI.bin Hashes";
+        public const string XBOXPFIHash = "PFI.bin Hashes";
+        public const string XBOXSSHash = "SS.bin Hashes";
+        public const string XBOXSSRanges = "Security Sector Ranges";
+        public const string XBOXSSVersion = "Security Sector Version";
+
+        // Default values
+
+        public const string RequiredValue = "(REQUIRED)";
+        public const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
+        public const string OptionalValue = "(OPTIONAL)";
+        public const string DiscNotDetected = "Disc Not Detected";
+    }
+}

DICUI.Library/Data/Enumerations.cs

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

DICUI.Library/Data/Options.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace DICUI.Data
+{
+    public class Options : IDictionary<string, string>
+    {
+        private Dictionary<string, string> _settings;
+
+        #region Internal Program
+
+        public string AaruPath
+        {
+            get { return GetStringSetting(_settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            set { _settings["AaruPath"] = value; }
+        }
+
+        public string CreatorPath
+        {
+            get { return GetStringSetting(_settings, "CreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            set { _settings["CreatorPath"] = value; }
+        }
+
+        public string DDPath
+        {
+            get { return GetStringSetting(_settings, "DDPath", "Programs\\DD\\dd.exe"); }
+            set { _settings["DDPath"] = value; }
+        }
+
+        public string InternalProgram
+        {
+            get { return GetStringSetting(_settings, "InternalProgram", Data.InternalProgram.DiscImageCreator.ToString()); }
+            set { _settings["InternalProgram"] = value; }
+        }
+
+        #endregion
+
+        #region Extra Paths
+
+        public string DefaultOutputPath
+        {
+            get { return GetStringSetting(_settings, "DefaultOutputPath", "ISO"); }
+            set { _settings["DefaultOutputPath"] = value; }
+        }
+
+        public string SubDumpPath
+        {
+            get { return GetStringSetting(_settings, "SubDumpPath", "Programs\\Subdump\\subdump.exe"); }
+            set { _settings["SubDumpPath"] = value; }
+        }
+
+        #endregion
+
+        #region Dumping Speeds
+
+        public int PreferredDumpSpeedCD
+        {
+            get { return GetInt32Setting(_settings, "PreferredDumpSpeedCD", 72); }
+            set { _settings["PreferredDumpSpeedCD"] = value.ToString(); }
+        }
+
+        public int PreferredDumpSpeedDVD
+        {
+            get { return GetInt32Setting(_settings, "PreferredDumpSpeedDVD", 24); }
+            set { _settings["PreferredDumpSpeedDVD"] = value.ToString(); }
+        }
+
+        public int PreferredDumpSpeedBD
+        {
+            get { return GetInt32Setting(_settings, "PreferredDumpSpeedBD", 16); }
+            set { _settings["PreferredDumpSpeedBD"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Extra Dumping Options
+
+        public bool QuietMode
+        {
+            get { return GetBooleanSetting(_settings, "QuietMode", false); }
+            set { _settings["QuietMode"] = value.ToString(); }
+        }
+
+        public bool ParanoidMode
+        {
+            get { return GetBooleanSetting(_settings, "ParanoidMode", false); }
+            set { _settings["ParanoidMode"] = value.ToString(); }
+        }
+
+        public bool ScanForProtection
+        {
+            get { return GetBooleanSetting(_settings, "ScanForProtection", true); }
+            set { _settings["ScanForProtection"] = value.ToString(); }
+        }
+
+        public int RereadAmountForC2
+        {
+            get { return GetInt32Setting(_settings, "RereadAmountForC2", 20); }
+            set { _settings["RereadAmountForC2"] = value.ToString(); }
+        }
+
+        public bool AddPlaceholders
+        {
+            get { return GetBooleanSetting(_settings, "AddPlaceholders", true); }
+            set { _settings["AddPlaceholders"] = value.ToString(); }
+        }
+
+        public bool PromptForDiscInformation
+        {
+            get { return GetBooleanSetting(_settings, "PromptForDiscInformation", true); }
+            set { _settings["PromptForDiscInformation"] = value.ToString(); }
+        }
+
+        public bool IgnoreFixedDrives
+        {
+            get { return GetBooleanSetting(_settings, "IgnoreFixedDrives", false); }
+            set { _settings["IgnoreFixedDrives"] = value.ToString(); }
+        }
+
+        public bool ResetDriveAfterDump
+        {
+            get { return GetBooleanSetting(_settings, "ResetDriveAfterDump", false); }
+            set { _settings["ResetDriveAfterDump"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Skip Options
+
+        public bool SkipMediaTypeDetection
+        {
+            get { return GetBooleanSetting(_settings, "SkipMediaTypeDetection", false); }
+            set { _settings["SkipMediaTypeDetection"] = value.ToString(); }
+        }
+
+        public bool SkipSystemDetection
+        {
+            get { return GetBooleanSetting(_settings, "SkipSystemDetection", false); }
+            set { _settings["SkipSystemDetection"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Logging Options
+
+        public bool VerboseLogging
+        {
+            get { return GetBooleanSetting(_settings, "VerboseLogging", true); }
+            set { _settings["VerboseLogging"] = value.ToString(); }
+        }
+
+        public bool OpenLogWindowAtStartup
+        {
+            get { return GetBooleanSetting(_settings, "OpenLogWindowAtStartup", true); }
+            set { _settings["OpenLogWindowAtStartup"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redump Login Information
+
+        public string Username
+        {
+            get { return GetStringSetting(_settings, "Username", ""); }
+            set { _settings["Username"] = value; }
+        }
+
+        // TODO: Figure out a way to keep this encrypted in some way, BASE64 to start?
+        public string Password
+        {
+            get { return GetStringSetting(_settings, "Password", ""); }
+            set { _settings["Password"] = value; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Constructor taking a dictionary for settings
+        /// </summary>
+        /// <param name="settings"></param>
+        public Options(Dictionary<string, string> settings = null)
+        {
+            this._settings = settings ?? new Dictionary<string, string>();
+        }
+
+        /// <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>
+        private bool GetBooleanSetting(Dictionary<string, string> settings, string key, bool defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (Boolean.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>
+        private int GetInt32Setting(Dictionary<string, string> settings, string key, int defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (Int32.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>
+        private string GetStringSetting(Dictionary<string, string> settings, string key, string defaultValue)
+        {
+            if (settings.ContainsKey(key))
+                return settings[key];
+            else
+                return defaultValue;
+        }
+
+        #region IDictionary implementations
+
+        public ICollection<string> Keys => _settings.Keys;
+
+        public ICollection<string> Values => _settings.Values;
+
+        public int Count => _settings.Count;
+
+        public bool IsReadOnly => ((IDictionary<string, string>)_settings).IsReadOnly;
+
+        public string this[string key]
+        {
+            get { return (_settings.ContainsKey(key) ? _settings[key] : null); }
+            set { _settings[key] = value; }
+        }
+
+        public bool ContainsKey(string key) => _settings.ContainsKey(key);
+
+        public void Add(string key, string value) => _settings.Add(key, value);
+
+        public bool Remove(string key) => _settings.Remove(key);
+
+        public bool TryGetValue(string key, out string value) => _settings.TryGetValue(key, out value);
+
+        public void Add(KeyValuePair<string, string> item) => _settings.Add(item.Key, item.Value);
+
+        public void Clear() => _settings.Clear();
+
+        public bool Contains(KeyValuePair<string, string> item) => ((IDictionary<string, string>)_settings).Contains(item);
+
+        public void CopyTo(KeyValuePair<string, string>[] array, int arrayIndex) => ((IDictionary<string, string>)_settings).CopyTo(array, arrayIndex);
+
+        public bool Remove(KeyValuePair<string, string> item) => ((IDictionary<string, string>)_settings).Remove(item);
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator() => _settings.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => _settings.GetEnumerator();
+
+        #endregion
+    }
+}

DICUI.Library/Data/SubmissionInfo.cs

@@ -0,0 +1,500 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using System.Net;
+using DICUI.Utilities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+
+namespace DICUI.Data
+{
+    public class SubmissionInfo
+    {
+        /// <summary>
+        /// List of matched Redump IDs
+        /// </summary>
+        [JsonIgnore]
+        public List<int> MatchedIDs { get; set; }
+
+        /// <summary>
+        /// DateTime of when the disc was added
+        /// </summary>
+        [JsonIgnore]
+        public DateTime? Added { get; set; }
+
+        /// <summary>
+        /// DateTime of when the disc was last modified
+        /// </summary>
+        [JsonIgnore]
+        public DateTime? LastModified { get; set; }
+
+        [JsonProperty(PropertyName = "common_disc_info", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public CommonDiscInfoSection CommonDiscInfo { get; set; } = new CommonDiscInfoSection();
+
+        [JsonProperty(PropertyName = "versions_and_editions", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public VersionAndEditionsSection VersionAndEditions { get; set; } = new VersionAndEditionsSection();
+
+        [JsonProperty(PropertyName = "edc", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public EDCSection EDC { get; set; } = new EDCSection();
+
+        [JsonProperty(PropertyName = "parent_clone_relationship", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public ParentCloneRelationshipSection ParentCloneRelationship { get; set; } = new ParentCloneRelationshipSection();
+
+        [JsonProperty(PropertyName = "extras", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public ExtrasSection Extras { get; set; } = new ExtrasSection();
+
+        [JsonProperty(PropertyName = "copy_protection", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public CopyProtectionSection CopyProtection { get; set; } = new CopyProtectionSection();
+
+        [JsonProperty(PropertyName = "dumpers_and_status", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public DumpersAndStatusSection DumpersAndStatus { get; set; } = new DumpersAndStatusSection();
+
+        [JsonProperty(PropertyName = "tracks_and_write_offsets", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public TracksAndWriteOffsetsSection TracksAndWriteOffsets { get; set; } = new TracksAndWriteOffsetsSection();
+
+        [JsonProperty(PropertyName = "size_and_checksums", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public SizeAndChecksumsSection SizeAndChecksums { get; set; } = new SizeAndChecksumsSection();
+
+        #region Regexes
+
+        private readonly Regex addedRegex = new Regex(@"<tr><th>Added</th><td>(.*?)</td></tr>");
+        private readonly Regex barcodeRegex = new Regex(@"<tr><th>Barcode</th></tr><tr><td>(.*?)</td></tr>");
+        private readonly Regex bcaRegex = new Regex(@"<h3>BCA .*?/></h3></td><td .*?></td></tr>"
+            + "<tr><th>Row</th><th>Contents</th><th>ASCII</th></tr>"
+            + "<tr><td>(?<row1number>.*?)</td><td>(?<row1contents>.*?)</td><td>(?<row1ascii>.*?)</td></tr>"
+            + "<tr><td>(?<row2number>.*?)</td><td>(?<row2contents>.*?)</td><td>(?<row2ascii>.*?)</td></tr>"
+            + "<tr><td>(?<row3number>.*?)</td><td>(?<row3contents>.*?)</td><td>(?<row3ascii>.*?)</td></tr>"
+            + "<tr><td>(?<row4number>.*?)</td><td>(?<row4contents>.*?)</td><td>(?<row4ascii>.*?)</td></tr>");
+        private readonly Regex categoryRegex = new Regex(@"<tr><th>Category</th><td>(.*?)</td></tr>");
+        private readonly Regex commentsRegex = new Regex(@"<tr><th>Comments</th></tr><tr><td>(.*?)</td></tr>");
+        private readonly Regex contentsRegex = new Regex(@"<tr><th>Contents</th></tr><tr .*?><td>(.*?)</td></tr>");
+        private readonly Regex discNumberLetterRegex = new Regex(@"\((.*?)\)");
+        private readonly Regex dumpersRegex = new Regex(@"<a href=""/discs/dumper/(.*?)/"">");
+        private readonly Regex editionRegex = new Regex(@"<tr><th>Edition</th><td>(.*?)</td></tr>");
+        private readonly Regex errorCountRegex = new Regex(@"<tr><th>Errors count</th><td>(.*?)</td></tr>");
+        private readonly Regex foreignTitleRegex = new Regex(@"<h2>(.*?)</h2>");
+        private readonly Regex fullMatchRegex = new Regex(@"<td class=""static"">full match ids: (.*?)</td>");
+        private readonly Regex languagesRegex = new Regex(@"<img src=""/images/languages/(.*?)\.png"" alt="".*?"" title="".*?"" />\s*");
+        private readonly Regex lastModifiedRegex = new Regex(@"<tr><th>Last modified</th><td>(.*?)</td></tr>");
+        private readonly Regex mediaRegex = new Regex(@"<tr><th>Media</th><td>(.*?)</td></tr>");
+        private readonly Regex partialMatchRegex = new Regex(@"<td class=""static"">partial match ids: (.*?)</td>");
+        private readonly Regex pvdRegex = new Regex(@"<h3>Primary Volume Descriptor (PVD) <img .*?/></h3></td><td .*?></td></tr>"
+            + @"<tr><th>Record / Entry</th><th>Contents</th><th>Date</th><th>Time</th><th>GMT</th></tr>"
+            + @"<tr><td>Creation</td><td>(?<creationbytes>.*?)</td><td>(?<creationdate>.*?)</td><td>(?<creationtime>.*?)</td><td>(?<creationtimezone>.*?)</td></tr>"
+            + @"<tr><td>Modification</td><td>(?<modificationbytes>.*?)</td><td>(?<modificationdate>.*?)</td><td>(?<modificationtime>.*?)</td><td>(?<modificationtimezone>.*?)</td></tr>"
+            + @"<tr><td>Expiration</td><td>(?<expirationbytes>.*?)</td><td>(?<expirationdate>.*?)</td><td>(?<expirationtime>.*?)</td><td>(?<expirationtimezone>.*?)</td></tr>"
+            + @"<tr><td>Effective</td><td>(?<effectivebytes>.*?)</td><td>(?<effectivedate>.*?)</td><td>(?<effectivetime>.*?)</td><td>(?<effectivetimezone>.*?)</td></tr>");
+        private readonly Regex regionRegex = new Regex(@"<tr><th>Region</th><td><a href=""/discs/region/(.*?)/"">");
+        private readonly Regex ringCodeDoubleRegex = new Regex(@""); // Varies based on available fields, like Addtional Mould
+        private readonly Regex ringCodeSingleRegex = new Regex(@""); // Varies based on available fields, like Addtional Mould
+        private readonly Regex serialRegex = new Regex(@"<tr><th>Serial</th><td>(.*?)</td></tr>");
+        private readonly Regex systemRegex = new Regex(@"<tr><th>System</th><td><a href=""/discs/system/(.*?)/"">");
+        private readonly Regex titleRegex = new Regex(@"<h1>(.*?)</h1>");
+        private readonly Regex trackRegex = new Regex(@"<tr><td>(?<number>.*?)</td><td>(?<type>.*?)</td><td>(?<pregap>.*?)</td><td>(?<length>.*?)</td><td>(?<sectors>.*?)</td><td>(?<size>.*?)</td><td>(?<crc32>.*?)</td><td>(?<md5>.*?)</td><td>(?<sha1>.*?)</td></tr>");
+        private readonly Regex trackCountRegex = new Regex(@"<tr><th>Number of tracks</th><td>(.*?)</td></tr>");
+        private readonly Regex versionRegex = new Regex(@"<tr><th>Version</th><td>(.*?)</td></tr>");
+        private readonly Regex writeOffsetRegex = new Regex(@"<tr><th>Write offset</th><td>(.*?)</td></tr>");
+
+        #endregion
+
+        /// <summary>
+        /// Fill in information from a Redump disc page
+        /// </summary>
+        /// <param name="discData">String representation of the disc page</param>
+        public void FillFromDiscPage(string discData)
+        {
+            // Title, Disc Number/Letter, Disc Title
+            var match = titleRegex.Match(discData);
+            if (match.Success)
+            {
+                string title = WebUtility.HtmlDecode(match.Groups[1].Value);
+
+                // If we have parenthesis, title is everything before the first one
+                int firstParenLocation = title.IndexOf(" (");
+                if (firstParenLocation >= 0)
+                {
+                    this.CommonDiscInfo.Title = title.Substring(0, firstParenLocation);
+                    var subMatches = discNumberLetterRegex.Match(title);
+                    for (int i = 1; i < subMatches.Groups.Count; i++)
+                    {
+                        string subMatch = subMatches.Groups[i].Value;
+
+                        // Disc number or letter
+                        if (subMatch.StartsWith("Disc"))
+                            this.CommonDiscInfo.DiscNumberLetter = subMatch.Remove(0, "Disc ".Length);
+
+                        // Disc title
+                        else
+                            this.CommonDiscInfo.DiscTitle = subMatch;
+                    }
+                }
+                // Otherwise, leave the title as-is
+                else
+                {
+                    this.CommonDiscInfo.Title = title;
+                }
+            }
+
+            // Foreign Title
+            match = foreignTitleRegex.Match(discData);
+            if (match.Success)
+                this.CommonDiscInfo.ForeignTitleNonLatin = WebUtility.HtmlDecode(match.Groups[1].Value);
+            else
+                this.CommonDiscInfo.ForeignTitleNonLatin = null;
+
+            // Category
+            match = categoryRegex.Match(discData);
+            if (match.Success)
+                this.CommonDiscInfo.Category = Converters.ToCategory(match.Groups[1].Value);
+            else
+                this.CommonDiscInfo.Category = Data.Category.Games;
+
+            // Region
+            match = regionRegex.Match(discData);
+            if (match.Success)
+                this.CommonDiscInfo.Region = Converters.ToRegion(match.Groups[1].Value);
+
+            // Languages
+            var matches = languagesRegex.Matches(discData);
+            if (matches.Count > 0)
+            {
+                List<Language?> tempLanguages = new List<Language?>();
+                foreach (Match submatch in matches)
+                    tempLanguages.Add(Converters.ToLanguage(submatch.Groups[1].Value));
+
+                this.CommonDiscInfo.Languages = tempLanguages.ToArray();
+            }
+
+            // Serial
+            match = serialRegex.Match(discData);
+            if (match.Success)
+                this.CommonDiscInfo.Serial = WebUtility.HtmlDecode(match.Groups[1].Value);
+
+            // Error count
+            match = errorCountRegex.Match(discData);
+            if (match.Success)
+            {
+                // If the error counts don't match, then use the one from the disc page
+                if (!string.IsNullOrEmpty(this.CommonDiscInfo.ErrorsCount) && match.Groups[1].Value != this.CommonDiscInfo.ErrorsCount)
+                    this.CommonDiscInfo.ErrorsCount = match.Groups[1].Value;
+            }
+
+            // Version
+            match = versionRegex.Match(discData);
+            if (match.Success)
+                this.VersionAndEditions.Version = WebUtility.HtmlDecode(match.Groups[1].Value);
+
+            // Edition
+            match = editionRegex.Match(discData);
+            if (match.Success)
+                this.VersionAndEditions.OtherEditions = WebUtility.HtmlDecode(match.Groups[1].Value);
+
+            // Dumpers
+            matches = dumpersRegex.Matches(discData);
+            if (matches.Count > 0)
+            {
+                // Start with any currently listed dumpers
+                List<string> tempDumpers = new List<string>();
+                if (this.DumpersAndStatus.Dumpers.Length > 0)
+                {
+                    foreach (string dumper in this.DumpersAndStatus.Dumpers)
+                        tempDumpers.Add(dumper);
+                }
+
+                foreach (Match submatch in matches)
+                    tempDumpers.Add(WebUtility.HtmlDecode(submatch.Groups[1].Value));
+
+                this.DumpersAndStatus.Dumpers = tempDumpers.ToArray();
+            }
+
+            // Barcode
+            match = barcodeRegex.Match(discData);
+            if (match.Success)
+                this.CommonDiscInfo.Barcode = WebUtility.HtmlDecode(match.Groups[1].Value);
+
+            // Comments
+            match = commentsRegex.Match(discData);
+            if (match.Success)
+            {
+                this.CommonDiscInfo.Comments = WebUtility.HtmlDecode(match.Groups[1].Value)
+                    .Replace("<br />", "\n")
+                    .Replace("<b>ISBN</b>", "[T:ISBN]") + "\n";
+            }
+
+            // Contents
+            match = contentsRegex.Match(discData);
+            if (match.Success)
+            {
+                this.CommonDiscInfo.Contents = WebUtility.HtmlDecode(match.Groups[1].Value)
+                       .Replace("<br />", "\n")
+                       .Replace("</div>", "");
+                this.CommonDiscInfo.Contents = Regex.Replace(this.CommonDiscInfo.Contents, @"<div .*?>", "");
+            }
+
+            // Added
+            match = addedRegex.Match(discData);
+            if (match.Success)
+                this.Added = DateTime.Parse(match.Groups[1].Value);
+
+            // Last Modified
+            match = lastModifiedRegex.Match(discData);
+            if (match.Success)
+                this.LastModified = DateTime.Parse(match.Groups[1].Value);
+        }
+    }
+
+    /// <summary>
+    /// Common disc info section of New Disc Form
+    /// </summary>
+    public class CommonDiscInfoSection
+    {
+        // Name not defined by Redump
+        [JsonProperty(PropertyName = "d_system", Required = Required.AllowNull)]
+        [JsonConverter(typeof(KnownSystemConverter))]
+        public KnownSystem? System { get; set; }
+
+        // Name not defined by Redump
+        // TODO: Have this convert to a new `RedumpMedia?` if possible, for submission
+        [JsonProperty(PropertyName = "d_media", Required = Required.AllowNull)]
+        [JsonConverter(typeof(MediaTypeConverter))]
+        public MediaType? Media { get; set; }
+
+        [JsonProperty(PropertyName = "d_title", Required = Required.AllowNull)]
+        public string Title { get; set; }
+
+        [JsonProperty(PropertyName = "d_title_foreign", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string ForeignTitleNonLatin { get; set; }
+
+        [JsonProperty(PropertyName = "d_number", NullValueHandling = NullValueHandling.Ignore)]
+        public string DiscNumberLetter { get; set; }
+
+        [JsonProperty(PropertyName = "d_label", NullValueHandling = NullValueHandling.Ignore)]
+        public string DiscTitle { get; set; }
+
+        [JsonProperty(PropertyName = "d_category", Required = Required.AllowNull)]
+        public Category? Category { get; set; }
+
+        [JsonProperty(PropertyName = "d_region", Required = Required.AllowNull)]
+        [JsonConverter(typeof(RegionConverter))]
+        public Region? Region { get; set; }
+
+        [JsonProperty(PropertyName = "d_languages", Required = Required.AllowNull)]
+        [JsonConverter(typeof(LanguagesConverter))]
+        public Language?[] Languages { get; set; }
+
+        [JsonProperty(PropertyName = "d_languages_selection", NullValueHandling = NullValueHandling.Ignore, DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [JsonConverter(typeof(LanguageSelectionConverter))]
+        public LanguageSelection?[] LanguageSelection { get; set; }
+
+        [JsonProperty(PropertyName = "d_serial", NullValueHandling = NullValueHandling.Ignore)]
+        public string Serial { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring", NullValueHandling = NullValueHandling.Ignore)]
+        public string Ring { get; }
+
+        [JsonProperty(PropertyName = "d_ring_0_id", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingId { get; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ma1", Required = Required.AllowNull)]
+        public string MasteringRingFirstLayerDataSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ma1_sid", NullValueHandling = NullValueHandling.Ignore)]
+        public string MasteringSIDCodeFirstLayerDataSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ts1", NullValueHandling = NullValueHandling.Ignore)]
+        public string ToolstampMasteringCodeFirstLayerDataSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_mo1_sid", NullValueHandling = NullValueHandling.Ignore)]
+        public string MouldSIDCodeFirstLayerDataSide { get; set; }
+
+        [JsonProperty(PropertyName = "dr_ring_0_mo1", NullValueHandling = NullValueHandling.Ignore)]
+        public string AdditionalMouldFirstLayerDataSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ma2", NullValueHandling = NullValueHandling.Ignore)]
+        public string MasteringRingSecondLayerLabelSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ma2_sid", NullValueHandling = NullValueHandling.Ignore)]
+        public string MasteringSIDCodeSecondLayerLabelSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_ts2", NullValueHandling = NullValueHandling.Ignore)]
+        public string ToolstampMasteringCodeSecondLayerLabelSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_mo2_sid", NullValueHandling = NullValueHandling.Ignore)]
+        public string MouldSIDCodeSecondLayerLabelSide { get; set; }
+
+        [JsonProperty(PropertyName = "dr_ring_0_mo2", NullValueHandling = NullValueHandling.Ignore)]
+        public string AdditionalMouldSecondLayerLabelSide { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_0_offsets", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingOffsetsHidden { get { return "1"; } }
+
+        [JsonProperty(PropertyName = "d_ring_0_0_id", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingZeroId { get; }
+
+        [JsonProperty(PropertyName = "d_ring_0_0_density", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingZeroDensity { get; }
+
+        [JsonProperty(PropertyName = "d_ring_0_0_value", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingWriteOffset { get; set; }
+
+        [JsonProperty(PropertyName = "d_ring_count", NullValueHandling = NullValueHandling.Ignore)]
+        public string RingCount { get { return "1"; } }
+
+        [JsonProperty(PropertyName = "d_barcode", NullValueHandling = NullValueHandling.Ignore)]
+        public string Barcode { get; set; }
+
+        [JsonProperty(PropertyName = "d_date", NullValueHandling = NullValueHandling.Ignore)]
+        public string EXEDateBuildDate { get; set; }
+
+        [JsonProperty(PropertyName = "d_errors", NullValueHandling = NullValueHandling.Ignore)]
+        public string ErrorsCount { get; set; }
+
+        [JsonProperty(PropertyName = "d_comments", NullValueHandling = NullValueHandling.Ignore)]
+        public string Comments { get; set; }
+
+        [JsonProperty(PropertyName = "d_contents", NullValueHandling = NullValueHandling.Ignore)]
+        public string Contents { get; set; }
+    }
+
+    /// <summary>
+    /// Version and editions section of New Disc form
+    /// </summary>
+    public class VersionAndEditionsSection
+    {
+        [JsonProperty(PropertyName = "d_version", NullValueHandling = NullValueHandling.Ignore)]
+        public string Version { get; set; }
+
+        [JsonProperty(PropertyName = "d_version_datfile", NullValueHandling = NullValueHandling.Ignore)]
+        public string VersionDatfile { get; set; }
+
+        [JsonProperty(PropertyName = "d_editions", NullValueHandling = NullValueHandling.Ignore)]
+        public string[] CommonEditions { get; set; }
+
+        [JsonProperty(PropertyName = "d_editions_text", NullValueHandling = NullValueHandling.Ignore)]
+        public string OtherEditions { get; set; }
+    }
+
+    /// <summary>
+    /// EDC section of New Disc form (PSX only)
+    /// </summary>
+    public class EDCSection
+    {
+        [JsonProperty(PropertyName = "d_edc", NullValueHandling = NullValueHandling.Ignore)]
+        public YesNo EDC { get; set; }
+    }
+
+    /// <summary>
+    /// Parent/Clone relationship section of New Disc form
+    /// </summary>
+    public class ParentCloneRelationshipSection
+    {
+        [JsonProperty(PropertyName = "d_parent_id", NullValueHandling = NullValueHandling.Ignore)]
+        public string ParentID { get; set; }
+
+        [JsonProperty(PropertyName = "d_is_regional_parent", NullValueHandling = NullValueHandling.Ignore)]
+        public bool RegionalParent { get; set; }
+    }
+
+    /// <summary>
+    /// Extras section of New Disc form
+    /// </summary>
+    public class ExtrasSection
+    {
+        [JsonProperty(PropertyName = "d_pvd", NullValueHandling = NullValueHandling.Ignore)]
+        public string PVD { get; set; }
+
+        [JsonProperty(PropertyName = "d_d1_key", NullValueHandling = NullValueHandling.Ignore)]
+        public string DiscKey { get; set; }
+
+        [JsonProperty(PropertyName = "d_d2_key", NullValueHandling = NullValueHandling.Ignore)]
+        public string DiscID { get; set; }
+
+        [JsonProperty(PropertyName = "d_pic_data", NullValueHandling = NullValueHandling.Ignore)]
+        public string PIC { get; set; }
+
+        [JsonProperty(PropertyName = "d_header", NullValueHandling = NullValueHandling.Ignore)]
+        public string Header { get; set; }
+
+        [JsonProperty(PropertyName = "d_bca", NullValueHandling = NullValueHandling.Ignore)]
+        public string BCA { get; set; }
+
+        [JsonProperty(PropertyName = "d_ssranges", NullValueHandling = NullValueHandling.Ignore)]
+        public string SecuritySectorRanges { get; set; }
+    }
+
+    /// <summary>
+    /// Copy protection section of New Disc form
+    /// </summary>
+    public class CopyProtectionSection
+    {
+        [JsonProperty(PropertyName = "d_protection_a", NullValueHandling = NullValueHandling.Ignore)]
+        public YesNo AntiModchip { get; set; }
+
+        [JsonProperty(PropertyName = "d_protection_1", NullValueHandling = NullValueHandling.Ignore)]
+        public YesNo LibCrypt { get; set; }
+
+        [JsonProperty(PropertyName = "d_libcrypt", NullValueHandling = NullValueHandling.Ignore)]
+        public string LibCryptData { get; set; }
+
+        [JsonProperty(PropertyName = "d_protection", NullValueHandling = NullValueHandling.Ignore)]
+        public string Protection { get; set; }
+
+        [JsonProperty(PropertyName = "d_securom", NullValueHandling = NullValueHandling.Ignore)]
+        public string SecuROMData { get; set; }
+    }
+
+    /// <summary>
+    /// Dumpers and status section of New Disc form (Moderator only)
+    /// </summary>
+    public class DumpersAndStatusSection
+    {
+        [JsonProperty(PropertyName = "d_status", NullValueHandling = NullValueHandling.Ignore)]
+        public DumpStatus Status { get; set; }
+
+        [JsonProperty(PropertyName = "d_dumpers", NullValueHandling = NullValueHandling.Ignore)]
+        public string[] Dumpers { get; set; }
+
+        [JsonProperty(PropertyName = "d_dumpers_text", NullValueHandling = NullValueHandling.Ignore)]
+        public string OtherDumpers { get; set; }
+    }
+
+    /// <summary>
+    /// Tracks and write offsets section of New Disc form (CD/GD-based)
+    /// </summary>
+    public class TracksAndWriteOffsetsSection
+    {
+        [JsonProperty(PropertyName = "d_tracks", NullValueHandling = NullValueHandling.Ignore)]
+        public string ClrMameProData { get; set; }
+
+        [JsonProperty(PropertyName = "d_cue", NullValueHandling = NullValueHandling.Ignore)]
+        public string Cuesheet { get; set; }
+
+        [JsonProperty(PropertyName = "d_offset", NullValueHandling = NullValueHandling.Ignore)]
+        public int[] CommonWriteOffsets { get; set; }
+
+        [JsonProperty(PropertyName = "d_offset_text", NullValueHandling = NullValueHandling.Ignore)]
+        public string OtherWriteOffsets { get; set; }
+    }
+
+    /// <summary>
+    /// Size & checksums section of New Disc form (DVD/BD/UMD-based)
+    /// </summary>
+    public class SizeAndChecksumsSection
+    {
+        [JsonProperty(PropertyName = "d_layerbreak", NullValueHandling = NullValueHandling.Ignore)]
+        public long Layerbreak { get; set; }
+
+        [JsonProperty(PropertyName = "d_size", NullValueHandling = NullValueHandling.Ignore)]
+        public long Size { get; set; }
+
+        [JsonProperty(PropertyName = "d_crc32", NullValueHandling = NullValueHandling.Ignore)]
+        public string CRC32 { get; set; }
+
+        [JsonProperty(PropertyName = "d_md5", NullValueHandling = NullValueHandling.Ignore)]
+        public string MD5 { get; set; }
+
+        [JsonProperty(PropertyName = "d_sha1", NullValueHandling = NullValueHandling.Ignore)]
+        public string SHA1 { get; set; }
+    }
+}

DICUI.Library/DiscImageCreator/Constants.cs

@@ -0,0 +1,66 @@
+namespace DICUI.DiscImageCreator
+{
+    /// <summary>
+    /// Top-level commands for DiscImageCreator
+    /// </summary>
+    public static class CommandStrings
+    {
+        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 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 DisableBeep = "/q";
+        public const string ForceUnitAccess = "/f";
+        public const string MultiSession = "/ms";
+        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 Raw = "/raw";
+        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 VideoNow = "/vn";
+        public const string VideoNowColor = "/vnc";
+        public const string VideoNowXP = "/vnx";
+    }
+}

DICUI.Library/DiscImageCreator/Converters.cs

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

DICUI.Library/DiscImageCreator/Enumerations.cs

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

DICUI.Library/Properties/AssemblyInfo.cs

@@ -0,0 +1,37 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DICUI.Library")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DICUI.Library")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("51ab0928-13f9-44bf-a407-b6957a43a056")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.16.1")]
+[assembly: AssemblyFileVersion("1.16.1.0")]
+[assembly: InternalsVisibleTo("DICUI.Test")]

DICUI.Library/Utilities/Drive.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using DICUI.Data;
+
+namespace DICUI.Utilities
+{
+    /// <summary>
+    /// Represents information for a single drive
+    /// </summary>
+    public class Drive
+    {
+        /// <summary>
+        /// Represents drive type
+        /// </summary>
+        public InternalDriveType? InternalDriveType { get; set; }
+
+        /// <summary>
+        /// DriveInfo object representing the drive, if possible
+        /// </summary>
+        public DriveInfo DriveInfo { get; private set; }
+
+        /// <summary>
+        /// Windows drive letter
+        /// </summary>
+        public char Letter { get { return DriveInfo?.Name[0] ?? '\0'; } }
+
+        /// <summary>
+        /// Media label as read by Windows
+        /// </summary>
+        public string VolumeLabel
+        {
+            get
+            {
+                if (DriveInfo.IsReady)
+                {
+                    if (string.IsNullOrWhiteSpace(DriveInfo.VolumeLabel))
+                        return "track";
+                    else
+                        return DriveInfo.VolumeLabel;
+                }
+                else
+                {
+                    return Template.DiscNotDetected;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Drive partition format
+        /// </summary>
+        public string DriveFormat { get { return DriveInfo.DriveFormat; } }
+
+        /// <summary>
+        /// Represents if Windows has marked the drive as active
+        /// </summary>
+        public bool MarkedActive { get { return DriveInfo.IsReady; } }
+
+        public Drive(InternalDriveType? driveType, DriveInfo driveInfo)
+        {
+            this.InternalDriveType = driveType;
+            this.DriveInfo = driveInfo;
+        }
+    }
+}

DICUI.Library/Utilities/Extensions.cs

@@ -0,0 +1,261 @@
+using DICUI.Data;
+
+namespace DICUI.Utilities
+{
+    public static class Extensions
+    {
+        #region Redump Information Lists
+
+        /// <summary>
+        /// List of systems that are not publically accessible
+        /// </summary>
+        public static readonly RedumpSystem[] BannedSystems = new RedumpSystem[]
+        {
+            RedumpSystem.AudioCD,
+            RedumpSystem.BDVideo,
+            RedumpSystem.DVDVideo,
+            RedumpSystem.HasbroVideoNow,
+            RedumpSystem.HasbroVideoNowColor,
+            RedumpSystem.HasbroVideoNowJr,
+            RedumpSystem.HasbroVideoNowXP,
+            RedumpSystem.KonamiM2,
+            RedumpSystem.MicrosoftXbox360,
+            RedumpSystem.MicrosoftXboxOne,
+            RedumpSystem.NavisoftNaviken21,
+            RedumpSystem.NintendoWii,
+            RedumpSystem.NintendoWiiU,
+            RedumpSystem.PanasonicM2,
+            RedumpSystem.PhilipsCDiDigitalVideo,
+            RedumpSystem.SegaRingEdge,
+            RedumpSystem.SegaRingEdge2,
+            RedumpSystem.SonyPlayStation3,
+            RedumpSystem.SonyPlayStation4,
+            RedumpSystem.VideoCD,
+        };
+
+        /// <summary>
+        /// List of systems that have a Cues pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasCues = new RedumpSystem[]
+        {
+            RedumpSystem.AppleMacintosh,
+            RedumpSystem.AudioCD,
+            RedumpSystem.BandaiPippin,
+            RedumpSystem.BandaiPlaydiaQuickInteractiveSystem,
+            RedumpSystem.CommodoreAmigaCD,
+            RedumpSystem.CommodoreAmigaCD32,
+            RedumpSystem.CommodoreAmigaCDTV,
+            RedumpSystem.FujitsuFMTownsseries,
+            RedumpSystem.HasbroVideoNow,
+            RedumpSystem.HasbroVideoNowJr,
+            RedumpSystem.IBMPCcompatible,
+            RedumpSystem.IncredibleTechnologiesEagle,
+            RedumpSystem.KonamieAmusement,
+            RedumpSystem.KonamiFireBeat,
+            RedumpSystem.KonamiM2,
+            RedumpSystem.KonamiSystemGV,
+            RedumpSystem.MattelHyperScan,
+            RedumpSystem.MicrosoftXbox,
+            RedumpSystem.MicrosoftXbox360,
+            RedumpSystem.NamcoSystem246,
+            RedumpSystem.NavisoftNaviken21,
+            RedumpSystem.NECPC88series,
+            RedumpSystem.NECPC98series,
+            RedumpSystem.NECPCEngineCDTurboGrafxCD,
+            RedumpSystem.NECPCFXPCFXGA,
+            RedumpSystem.PalmOS,
+            RedumpSystem.Panasonic3DOInteractiveMultiplayer,
+            RedumpSystem.PanasonicM2,
+            RedumpSystem.PhilipsCDi,
+            RedumpSystem.PhilipsCDiDigitalVideo,
+            RedumpSystem.PhotoCD,
+            RedumpSystem.PlayStationGameSharkUpdates,
+            RedumpSystem.SegaChihiro,
+            RedumpSystem.SegaDreamcast,
+            RedumpSystem.SegaMegaCDSegaCD,
+            RedumpSystem.SegaNaomi,
+            RedumpSystem.SegaNaomi2,
+            RedumpSystem.SegaSaturn,
+            RedumpSystem.SegaTriforce,
+            RedumpSystem.SNKNeoGeoCD,
+            RedumpSystem.SonyPlayStation,
+            RedumpSystem.SonyPlayStation2,
+            RedumpSystem.SonyPlayStation3,
+            RedumpSystem.TABAustriaQuizard,
+            RedumpSystem.TomyKissSite,
+            RedumpSystem.VideoCD,
+            RedumpSystem.VTechVFlashVSmilePro,
+};
+
+        /// <summary>
+        /// List of systems that has a Dat pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasDat = new RedumpSystem[]
+        {
+            RedumpSystem.MicrosoftXboxBIOS,
+            RedumpSystem.NintendoGameCubeBIOS,
+            RedumpSystem.SonyPlayStationBIOS,
+            RedumpSystem.SonyPlayStation2BIOS,
+
+            RedumpSystem.AppleMacintosh,
+            RedumpSystem.AudioCD,
+            RedumpSystem.BDVideo,
+            RedumpSystem.BandaiPippin,
+            RedumpSystem.BandaiPlaydiaQuickInteractiveSystem,
+            RedumpSystem.CommodoreAmigaCD,
+            RedumpSystem.CommodoreAmigaCD32,
+            RedumpSystem.CommodoreAmigaCDTV,
+            RedumpSystem.DVDVideo,
+            RedumpSystem.FujitsuFMTownsseries,
+            RedumpSystem.HasbroVideoNow,
+            RedumpSystem.HasbroVideoNowJr,
+            RedumpSystem.IBMPCcompatible,
+            RedumpSystem.IncredibleTechnologiesEagle,
+            RedumpSystem.KonamiFireBeat,
+            RedumpSystem.KonamiM2,
+            RedumpSystem.KonamiSystemGV,
+            RedumpSystem.KonamieAmusement,
+            RedumpSystem.MattelHyperScan,
+            RedumpSystem.MicrosoftXbox,
+            RedumpSystem.MicrosoftXbox360,
+            RedumpSystem.MicrosoftXboxOne,
+            RedumpSystem.NamcoSystem246,
+            RedumpSystem.NavisoftNaviken21,
+            RedumpSystem.NECPC88series,
+            RedumpSystem.NECPC98series,
+            RedumpSystem.NECPCEngineCDTurboGrafxCD,
+            RedumpSystem.NECPCFXPCFXGA,
+            RedumpSystem.NinendoGameCube,
+            RedumpSystem.NintendoWii,
+            RedumpSystem.NintendoWiiU,
+            RedumpSystem.PalmOS,
+            RedumpSystem.Panasonic3DOInteractiveMultiplayer,
+            RedumpSystem.PanasonicM2,
+            RedumpSystem.PhilipsCDi,
+            RedumpSystem.PhilipsCDiDigitalVideo,
+            RedumpSystem.PhotoCD,
+            RedumpSystem.PlayStationGameSharkUpdates,
+            RedumpSystem.SegaChihiro,
+            RedumpSystem.SegaDreamcast,
+            RedumpSystem.SegaLindbergh,
+            RedumpSystem.SegaMegaCDSegaCD,
+            RedumpSystem.SegaNaomi,
+            RedumpSystem.SegaNaomi2,
+            RedumpSystem.SegaRingEdge,
+            RedumpSystem.SegaRingEdge2,
+            RedumpSystem.SegaSaturn,
+            RedumpSystem.SegaTriforce,
+            RedumpSystem.SNKNeoGeoCD,
+            RedumpSystem.SonyPlayStation,
+            RedumpSystem.SonyPlayStation2,
+            RedumpSystem.SonyPlayStation3,
+            RedumpSystem.SonyPlayStation4,
+            RedumpSystem.SonyPlayStationPortable,
+            RedumpSystem.TABAustriaQuizard,
+            RedumpSystem.TomyKissSite,
+            RedumpSystem.VideoCD,
+            RedumpSystem.VMLabsNUON,
+            RedumpSystem.VTechVFlashVSmilePro,
+            RedumpSystem.ZAPiTGamesGameWaveFamilyEntertainmentSystem,
+        };
+
+        /// <summary>
+        /// List of systems that has a Decrypted Keys pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasDkeys = new RedumpSystem[]
+        {
+            RedumpSystem.SonyPlayStation3,
+        };
+
+        /// <summary>
+        /// List of systems that has a GDI pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasGdi = new RedumpSystem[]
+        {
+            RedumpSystem.SegaChihiro,
+            RedumpSystem.SegaDreamcast,
+            RedumpSystem.SegaNaomi,
+            RedumpSystem.SegaNaomi2,
+            RedumpSystem.SegaTriforce,
+        };
+
+        /// <summary>
+        /// List of systems that has a Keys pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasKeys = new RedumpSystem[]
+        {
+            RedumpSystem.NintendoWiiU,
+            RedumpSystem.SonyPlayStation3,
+        };
+
+        /// <summary>
+        /// List of systems that has an LSD pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasLsd = new RedumpSystem[]
+        {
+            RedumpSystem.IBMPCcompatible,
+            RedumpSystem.SonyPlayStation,
+        };
+
+        /// <summary>
+        /// List of systems that has an SBI pack
+        /// </summary>
+        public static readonly RedumpSystem[] HasSbi = new RedumpSystem[]
+        {
+            RedumpSystem.IBMPCcompatible,
+            RedumpSystem.SonyPlayStation,
+        };
+
+        #endregion
+
+        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;
+            }
+        }
+
+        public static KnownSystemCategory Category(this KnownSystem? system)
+        {
+            if (system < KnownSystem.MarkerDiscBasedConsoleEnd)
+                return KnownSystemCategory.DiscBasedConsole;
+            /*
+            else if (system < KnownSystem.MarkerOtherConsoleEnd)
+                return KnownSystemCategory.OtherConsole;
+            */
+            else if (system < KnownSystem.MarkerComputerEnd)
+                return KnownSystemCategory.Computer;
+            else if (system < KnownSystem.MarkerArcadeEnd)
+                return KnownSystemCategory.Arcade;
+            else if (system < KnownSystem.MarkerOtherEnd)
+                return KnownSystemCategory.Other;
+            else
+                return KnownSystemCategory.Custom;
+        }
+
+        public static bool IsMarker(this KnownSystem? system)
+        {
+            switch (system)
+            {
+                case KnownSystem.MarkerArcadeEnd:
+                case KnownSystem.MarkerComputerEnd:
+                case KnownSystem.MarkerDiscBasedConsoleEnd:
+                // case KnownSystem.MarkerOtherConsoleEnd:
+                case KnownSystem.MarkerOtherEnd:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}

DICUI.Library/Utilities/Result.cs

@@ -0,0 +1,66 @@
+namespace DICUI.Utilities
+{
+    /// <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>
+        public static Result Success(string message) => new Result(true, message);
+
+        /// <summary>
+        /// Create a success result with a custom message with format parameters
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+        /// <param name="args">Formatting parameters for the string</param>
+        public static Result Success(string message, params object[] args) => new Result(true, string.Format(message, args));
+
+        /// <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>
+        public static Result Failure(string message) => new Result(false, message);
+
+        /// <summary>
+        /// Create a failure result with a custom message with format parameters
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+        /// <param name="args">Formatting parameters for the string</param>
+        public static Result Failure(string message, params object[] args) => new Result(false, string.Format(message, args));
+
+        /// <summary>
+        /// Results can be compared to boolean values based on the success value
+        /// </summary>
+        public static implicit operator bool(Result result) => result.success;
+    }
+}

DICUI.Library/Web/CookieAwareWebClient.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Net;
+
+namespace DICUI.Web
+{
+    // https://stackoverflow.com/questions/1777221/using-cookiecontainer-with-webclient-class
+    public class CookieAwareWebClient : WebClient
+    {
+        private readonly CookieContainer m_container = new CookieContainer();
+
+        protected override WebRequest GetWebRequest(Uri address)
+        {
+            WebRequest request = base.GetWebRequest(address);
+            HttpWebRequest webRequest = request as HttpWebRequest;
+            if (webRequest != null)
+            {
+                webRequest.CookieContainer = m_container;
+            }
+
+            return request;
+        }
+
+        /// <summary>
+        /// Get the last downloaded filename, if possible
+        /// </summary>
+        /// <returns></returns>
+        public string GetLastFilename()
+        {
+            // Try to extract the filename from the Content-Disposition header
+            if (!string.IsNullOrEmpty(this.ResponseHeaders["Content-Disposition"]))
+                return this.ResponseHeaders["Content-Disposition"].Substring(this.ResponseHeaders["Content-Disposition"].IndexOf("filename=") + 9).Replace("\"", "");
+
+            return null;
+        }
+    }
+}

DICUI.Library/Web/RedumpAccess.cs

@@ -0,0 +1,385 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI.Web
+{
+    public class RedumpAccess
+    {
+        #region Base URLs
+
+        private const string loginUrl = "http://forum.redump.org/login/";
+
+        #endregion
+
+        #region Disc URLs and Extensions
+
+        private const string discPageUrl = @"http://redump.org/disc/{0}/";
+        private const string wipDiscPageUrl = @"http://redump.org/newdisc/{0}/";
+
+        private const string changesExt = "/changes/";
+        private const string cueExt = "cue/";
+        private const string gdiExt = "gdi/";
+        private const string keyExt = "key/";
+        private const string md5Ext = "md5/";
+        private const string sbiExt = "sbi/";
+        private const string sfvExt = "sfv/";
+        private const string sha1Ext = "sha1/";
+
+        #endregion
+
+        #region List URLs
+
+        private const string lastModifiedUrl = @"http://redump.org/discs/sort/modified/dir/desc?page={0}";
+        private const string quickSearchUrl = @"http://redump.org/discs/quicksearch/{0}/?page={1}";
+        private const string userDumpsUrl = @"http://redump.org/discs/dumper/{0}/?page={1}";
+        private const string wipDumpsUrl = @"http://redump.org/discs-wip/";
+
+        #endregion
+
+        #region Pack URLs
+
+        private const string packCuesUrl = @"http://redump.org/cues/{0}/";
+        private const string packDatfileUrl = @"http://redump.org/datfile/{0}/";
+        private const string packDkeysUrl = @"http://redump.org/dkeys/{0}/";
+        private const string packGdiUrl = @"http://redump.org/gdi/{0}/";
+        private const string packKeysUrl = @"http://redump.org/keys/{0}/";
+        private const string packSbiUrl = @"http://redump.org/sbi/{0}/";
+
+        #endregion
+
+        #region Regexes
+
+        private readonly Regex discRegex = new Regex(@"<a href=""/disc/(\d+)/"">");
+        private readonly Regex newDiscRegex = new Regex(@"<a href=""/newdisc/(\d+)/"">");
+        private readonly Regex tokenRegex = new Regex(@"<input type=""hidden"" name=""csrf_token"" value=""(.*?)"" />");
+
+        #endregion
+
+        /// <summary>
+        /// Login to Redump, if possible
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        /// <param name="username">Redump username to log in for protected systems</param>
+        /// <param name="password">Redump password to log in for protected systems</param>
+        /// <returns>True login was successful, false otherwise</returns>
+        public bool RedumpLogin(CookieAwareWebClient wc, string username, string password)
+        {
+            if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
+                return false;
+
+            var loginPage = wc.DownloadString(loginUrl);
+            string token = this.tokenRegex.Match(loginPage).Groups[1].Value;
+
+            wc.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
+            wc.Encoding = Encoding.UTF8;
+            var response = wc.UploadString(loginUrl, $"form_sent=1&redirect_url=&csrf_token={token}&req_username={username}&req_password={password}&save_pass=0");
+
+            if (response.Contains("Incorrect username and/or password."))
+                return false;
+            else
+                return true;
+        }
+
+        #region Process IDs and Pages
+
+        /// <summary>
+        /// Get the list of the last modified IDs, in order of appearance
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        /// <param name="pageCount">Number of pages to grab until stopping; -1 means continue until end</param>
+        /// <returns>A list of IDs in order of last modified</returns>
+        private List<int> ProcessLastModified(CookieAwareWebClient wc, int pageCount = -1)
+        {
+            List<int> ids = new List<int>();
+
+            // If we have a -1 page count, set the maximum page limit
+            if (pageCount == -1)
+                pageCount = Int32.MaxValue;
+
+            // Keep getting last modified pages until there are none left
+            int pageNumber = 1;
+            while (pageNumber < pageCount)
+            {
+                List<int> pageIds = CheckSingleSitePage(wc, string.Format(lastModifiedUrl, pageNumber++));
+                ids.AddRange(pageIds);
+                if (pageIds.Count < 2)
+                    break;
+            }
+
+            return ids;
+        }
+
+        /// <summary>
+        /// Retrieve premade packs from Redump
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        private void ProcessAllPacks(CookieAwareWebClient wc)
+        {
+            var cuesPacks = this.DownloadPacks(wc, packCuesUrl, Extensions.HasCues, "CUEs");
+            var datPacks = this.DownloadPacks(wc, packDatfileUrl, Extensions.HasDat, "DATs");
+            var dkeyPacks = this.DownloadPacks(wc, packDkeysUrl, Extensions.HasDkeys, "Decrypted KEYS");
+            var gdiPacks = this.DownloadPacks(wc, packGdiUrl, Extensions.HasGdi, "GDIs");
+            var keysPacks = this.DownloadPacks(wc, packKeysUrl, Extensions.HasKeys, "KEYS");
+            var sbiPacks = this.DownloadPacks(wc, packSbiUrl, Extensions.HasSbi, "SBIs");
+        }
+
+        /// <summary>
+        /// Retrieve premade packs from Redump
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        /// <param name="system">RedumpSystem to get all possible packs for</param>
+        private void ProcessPacksForSystem(CookieAwareWebClient wc, RedumpSystem system)
+        {
+            var packs = new Dictionary<string, byte[]>();
+
+            if (Extensions.HasCues.Contains(system))
+                packs.Add("cues", this.DownloadPack(wc, packCuesUrl, system, "CUEs"));
+
+            if (Extensions.HasDat.Contains(system))
+                packs.Add("dat", this.DownloadPack(wc, packDatfileUrl, system, "DATs"));
+
+            if (Extensions.HasDkeys.Contains(system))
+                packs.Add("dkeys", this.DownloadPack(wc, packDkeysUrl, system, "Decrypted KEYS"));
+
+            if (Extensions.HasGdi.Contains(system))
+                packs.Add("gdi", this.DownloadPack(wc, packGdiUrl, system, "GDIs"));
+
+            if (Extensions.HasKeys.Contains(system))
+                packs.Add("keys", this.DownloadPack(wc, packKeysUrl, system, "KEYS"));
+
+            if (Extensions.HasSbi.Contains(system))
+                packs.Add("sbi", this.DownloadPack(wc, packSbiUrl, system, "SBIs"));
+        }
+
+        /// <summary>
+        /// Get the list of IDs that associate with a given string
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        /// <param name="query">Value to search for in Redump</param>
+        /// <returns>A list of IDs associated with that value</returns>
+        public List<int> ProcessSearch(CookieAwareWebClient wc, string query)
+        {
+            List<int> ids = new List<int>();
+
+            // Keep getting quicksearch pages until there are none left
+            int pageNumber = 1;
+            while (true)
+            {
+                List<int> pageIds = CheckSingleSitePage(wc, string.Format(quickSearchUrl, query, pageNumber++));
+                ids.AddRange(pageIds);
+                if (pageIds.Count < 2)
+                    break;
+            }
+
+            return ids;
+        }
+
+        /// <summary>
+        /// Get the list of IDs associated with the given user
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to hold the login state</param>
+        /// <param name="username">Redump username to get the list of IDs for</param>
+        /// <returns>A list of IDs associated with that user</returns>
+        private List<int> ProcessUser(CookieAwareWebClient wc, string username)
+        {
+            List<int> ids = new List<int>();
+
+            // Keep getting user pages until there are none left
+            int pageNumber = 1;
+            while (true)
+            {
+                List<int> pageIds = CheckSingleSitePage(wc, string.Format(userDumpsUrl, username, pageNumber++));
+                ids.AddRange(pageIds);
+                if (pageIds.Count < 2)
+                    break;
+            }
+
+            return ids;
+        }
+
+        #endregion
+
+        #region Single item processing
+
+        /// <summary>
+        /// Process a Redump site page as a list of possible IDs or disc page
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the pages</param>
+        /// <param name="url">Page URL to check and parse</param>
+        /// <returns>List of matching IDs</returns>
+        private List<int> CheckSingleSitePage(CookieAwareWebClient wc, string url)
+        {
+            List<int> ids = new List<int>();
+
+            var dumpsPage = wc.DownloadString(url);
+
+            // If we have no dumps left
+            if (dumpsPage.Contains("No discs found."))
+                return ids;
+
+            // If we have a single disc page already
+            if (dumpsPage.Contains("<b>Download:</b>"))
+            {
+                var value = Regex.Match(dumpsPage, @"/disc/(\d+)/sfv/").Groups[1].Value;
+                if (Int32.TryParse(value, out int id))
+                    ids.Add(id);
+
+                return ids;
+            }
+
+            // Otherwise, traverse each dump on the page
+            var matches = discRegex.Matches(dumpsPage);
+            foreach (Match match in matches)
+            {
+                try
+                {
+                    if (Int32.TryParse(match.Groups[1].Value, out int value))
+                        ids.Add(value);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"An exception has occurred: {ex}");
+                    continue;
+                }
+            }
+
+            return ids;
+        }
+
+        /// <summary>
+        /// Process a Redump WIP page as a list of possible IDs or disc page
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the pages</param>
+        /// <param name="url">Page URL to check and parse</param>
+        /// <returns>List of matching IDs</returns>
+        private List<int> CheckSingleWIPPage(CookieAwareWebClient wc, string url)
+        {
+            List<int> ids = new List<int>();
+
+            var wipDumpsPage = wc.DownloadString(url);
+
+            // If we have no WIP dumps left
+            if (wipDumpsPage.Contains("No WIP discs found."))
+                return ids;
+
+            // Otherwise, traverse each dump on the page
+            var matches = newDiscRegex.Matches(wipDumpsPage);
+            foreach (Match match in matches)
+            {
+                try
+                {
+                    if (Int32.TryParse(match.Groups[1].Value, out int value))
+                        ids.Add(value);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"An exception has occurred: {ex}");
+                    continue;
+                }
+            }
+
+            return ids;
+        }
+
+        /// <summary>
+        /// Download an individual pack
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the packs</param>
+        /// <param name="url">Base URL to download using</param>
+        /// <param name="system">System to download packs for</param>
+        /// <param name="title">Name of the pack that is downloading</param>
+        private byte[] DownloadPack(CookieAwareWebClient wc, string url, RedumpSystem system, string title)
+        {
+            Console.WriteLine($"Downloading {title}");
+            Console.Write($"\r{system.LongName()}{new string(' ', Console.BufferWidth - system.LongName().Length - 1)}");
+            var pack = wc.DownloadData(string.Format(url, system.ShortName()));
+
+            Console.Write($"\rComplete!{new string(' ', Console.BufferWidth - 10)}");
+            Console.WriteLine();
+
+            return pack;
+        }
+
+        /// <summary>
+        /// Download a set of packs
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the packs</param>
+        /// <param name="url">Base URL to download using</param>
+        /// <param name="systems">List of systems to download packs for</param>
+        /// <param name="title">Name of the pack that is downloading</param>
+        private Dictionary<RedumpSystem, byte[]> DownloadPacks(CookieAwareWebClient wc, string url, RedumpSystem[] systems, string title)
+        {
+            var dict = new Dictionary<RedumpSystem, byte[]>();
+
+            Console.WriteLine($"Downloading {title}");
+            foreach (var system in systems)
+            {
+                Console.Write($"\r{system.LongName()}{new string(' ', Console.BufferWidth - system.LongName().Length - 1)}");
+                dict.Add(system, wc.DownloadData(string.Format(url, system.ShortName())));
+            }
+
+            Console.Write($"\rComplete!{new string(' ', Console.BufferWidth - 10)}");
+            Console.WriteLine();
+
+            return dict;
+        }
+
+        /// <summary>
+        /// Download an individual site ID page as a string, if possible
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the pages</param>
+        /// <param name="id">Redump disc ID to retrieve</param>
+        /// <returns>Disc page as a string, null on error</returns>
+        public string DownloadSingleSiteID(CookieAwareWebClient wc, int id)
+        {
+            string paddedId = id.ToString().PadLeft(5, '0');
+            Console.WriteLine($"Processing ID: {paddedId}");
+            try
+            {
+                string discPage = wc.DownloadString(string.Format(discPageUrl, +id));
+                if (discPage.Contains($"Disc with ID \"{id}\" doesn't exist"))
+                    return null;
+                else
+                    return discPage;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"An exception has occurred: {ex}");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Download an individual WIP ID page as a string, if possible
+        /// </summary>
+        /// <param name="wc">CookieAwareWebClient to access the pages</param>
+        /// <param name="id">Redump disc ID to retrieve</param>
+        /// <returns>WIP disc page as a string, null on error</returns>
+        private string DownloadSingleWIPID(CookieAwareWebClient wc, int id)
+        {
+            string paddedId = id.ToString().PadLeft(5, '0');
+            Console.WriteLine($"Processing WIP ID: {paddedId}");
+            try
+            {
+                string discPage = wc.DownloadString(string.Format(wipDiscPageUrl, +id));
+                if (discPage.Contains($"WIP Disc with ID \"{id}\" doesn't exist"))
+                    return null;
+                else
+                    return discPage;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"An exception has occurred: {ex}");
+                return null;
+            }
+        }
+
+        #endregion
+    }
+}

DICUI.Test/DICUI.Test.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DICUI.Library\DICUI.Library.csproj">
+      <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
+      <Name>DICUI.Library</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\DICUI\DICUI.csproj">
+      <Project>{7b1b75eb-8940-466f-bd51-76471a57f9be}</Project>
+      <Name>DICUI</Name>
+    </ProjectReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeCoverage" Version="16.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.3.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.abstractions" Version="2.0.3" />
+    <PackageReference Include="xunit.analyzers" Version="0.10.0" />
+    <PackageReference Include="xunit.assert" Version="2.4.1" />
+    <PackageReference Include="xunit.core" Version="2.4.1" />
+    <PackageReference Include="xunit.extensibility.core" Version="2.4.1" />
+    <PackageReference Include="xunit.extensibility.execution" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.console" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+  </ItemGroup>
+
+</Project>

DICUI.Test/ResultTest.cs

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

DICUI.Test/UI/AllowedSpeedsTest.cs

@@ -0,0 +1,21 @@
+using System.Linq;
+using DICUI.Data;
+using Xunit;
+
+namespace DICUI.Test.Data
+{
+    public class UIElementsTest
+    {
+        [Theory]
+        [InlineData(MediaType.CDROM, 72)]
+        [InlineData(MediaType.DVD, 24)]
+        [InlineData(MediaType.BluRay, 16)]
+        [InlineData(MediaType.LaserDisc, 72)] // TODO: Update when fully determined
+        [InlineData(null, 72)] // TODO: Update when fully determined
+        public void GetAllowedDriveSpeedForMediaTypeTest(MediaType? mediaType, int maxExpected)
+        {
+            var actual = Constants.GetSpeedsForMediaType(mediaType);
+            Assert.Equal(maxExpected, actual.Last());
+        }
+    }
+}

DICUI.Test/Utilities/ConvertersTest.cs

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

DICUI.Test/Utilities/DumpEnvironmentTest.cs

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

DICUI.Test/Utilities/KnownSystemExtensionsTest.cs

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

DICUI.Test/Utilities/MediaTypeExtensionsTest.cs

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

DICUI.Test/Utilities/ParametersTest.cs

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

DICUI.Test/Utilities/ValidatorsTest.cs

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

DICUI.csproj

@@ -1,136 +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.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>
-    <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="MainWindow.xaml.cs">
-      <DependentUpon>MainWindow.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Properties\AssemblyInfo.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-  </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,9 +1,22 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2036
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28803.156
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI", "DICUI.csproj", "{7B1B75EB-8940-466F-BD51-76471A57F9BE}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI", "DICUI\DICUI.csproj", "{7B1B75EB-8940-466F-BD51-76471A57F9BE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI.Test", "DICUI.Test\DICUI.Test.csproj", "{7CC064D2-38AB-4A05-8519-28660DE4562A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI.Library", "DICUI.Library\DICUI.Library.csproj", "{51AB0928-13F9-44BF-A407-B6957A43A056}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI.Check", "DICUI.Check\DICUI.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
+		README.md = README.md
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -15,6 +28,18 @@ Global
 		{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
+		{51AB0928-13F9-44BF-A407-B6957A43A056}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{51AB0928-13F9-44BF-A407-B6957A43A056}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{51AB0928-13F9-44BF-A407-B6957A43A056}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{51AB0928-13F9-44BF-A407-B6957A43A056}.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
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

DICUI/App.config

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <appSettings>
+    <add key="AaruPath" value="Programs\Aaru\Aaru.exe"/>
+    <add key="CreatorPath" value="Programs\Creator\DiscImageCreator.exe"/>
+    <add key="DDPath" value="Programs\DD\dd.exe"/>
+    <add key="SubDumpPath" value="Programs\Subdump\subdump.exe"/>
+    <add key="DefaultOutputPath" value="ISO"/>
+    <add key="InternalProgram" value="DiscImageCreator"/>
+
+    <add key="PreferredDumpSpeedCD" value="48"/>
+    <add key="PreferredDumpSpeedDVD" value="24"/>
+    <add key="PreferredDumpSpeedBD" value="16"/>
+
+    <add key="QuietMode" value="false"/>
+    <add key="ParanoidMode" value="false"/>
+    <add key="ScanForProtection" value="true"/>
+    <add key="SkipMediaTypeDetection" value="false"/>
+    <add key="SkipSystemDetection" value="false"/>
+    <add key="RereadAmountForC2" value="20"/>
+    <add key="VerboseLogging" value="true"/>
+    <add key="OpenLogWindowAtStartup" value="true"/>
+    <add key="AddPlaceholders" value="true"/>
+    <add key="PromptForDiscInformation" value="true"/>
+    <add key="IgnoreFixedDrives" value="false"/>
+    <add key="ResetDriveAfterDump" value="false"/>
+
+    <add key="Username" value=""/>
+    <add key="Password" value=""/>
+  </appSettings>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/></startup></configuration>

DICUI/App.xaml

@@ -2,7 +2,7 @@
              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">
+             StartupUri="Windows\MainWindow.xaml">
     <Application.Resources>
          
     </Application.Resources>

DICUI/App.xaml.cs

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

DICUI/ComboBoxItems/CategoryComboBoxItem.cs

@@ -0,0 +1,29 @@
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Represents a single item in the Category combo box
+    /// </summary>
+    public class CategoryComboBoxItem
+    {
+        private object data;
+
+        public CategoryComboBoxItem(Category? category) => data = category;
+
+        public static implicit operator Category? (CategoryComboBoxItem item) => item.data as Category?;
+
+        public string Name
+        {
+            get { return (data as Category?).LongName(); }
+        }
+
+        public bool IsChecked { get; set; }
+
+        public Category? Value
+        {
+            get { return data as Category?; }
+        }
+    }
+}

DICUI/ComboBoxItems/KnownSystemComboBoxItem.cs

@@ -0,0 +1,35 @@
+using System.Windows.Media;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Represents a single item in the System combo box
+    /// </summary>
+    public class KnownSystemComboBoxItem
+    {
+        private object data;
+
+        public KnownSystemComboBoxItem(KnownSystem? system) => data = system;
+        public KnownSystemComboBoxItem(KnownSystemCategory? category) => data = category;
+
+        public Brush Foreground { get => IsHeader() ? Brushes.Gray : Brushes.Black; }
+
+        public bool IsHeader() => data is KnownSystemCategory?;
+        public bool IsSystem() => data is KnownSystem?;
+
+        public static implicit operator KnownSystem? (KnownSystemComboBoxItem item) => item.data as KnownSystem?;
+
+        public string Name
+        {
+            get
+            {
+                if (IsHeader())
+                    return "---------- " + (data as KnownSystemCategory?).LongName() + " ----------";
+                else
+                    return (data as KnownSystem?).LongName();
+            }
+        }
+    }
+}

DICUI/ComboBoxItems/LanguageComboBoxItem.cs

@@ -0,0 +1,29 @@
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Represents a single item in the Language combo box
+    /// </summary>
+    public class LanguageComboBoxItem
+    {
+        private object data;
+
+        public LanguageComboBoxItem(Language? region) => data = region;
+
+        public static implicit operator Language? (LanguageComboBoxItem item) => item.data as Language?;
+
+        public string Name
+        {
+            get { return (data as Language?).LongName(); }
+        }
+
+        public bool IsChecked { get; set; }
+
+        public Language? Value
+        {
+            get { return data as Language?; }
+        }
+    }
+}

DICUI/ComboBoxItems/MediaTypeComboBoxItem.cs

@@ -0,0 +1,20 @@
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Represents a single item in the MediaType combo box
+    /// </summary>
+    public class MediaTypeComboBoxItem
+    {
+        private MediaType? data;
+
+        public MediaTypeComboBoxItem(MediaType? mediaType) => data = mediaType;
+
+        public static implicit operator MediaType? (MediaTypeComboBoxItem item) => item.data;
+
+        public string Name { get { return data.LongName(); }
+        }
+    }
+}

DICUI/ComboBoxItems/RegionComboBoxItem.cs

@@ -0,0 +1,30 @@
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Represents a single item in the Region combo box
+    /// </summary>
+    public class RegionComboBoxItem
+    {
+        private object data;
+
+        public RegionComboBoxItem(Region? region) => data = region;
+
+        public static implicit operator Region? (RegionComboBoxItem item) => item.data as Region?;
+
+        public string Name
+        {
+            get
+            {
+                return (data as Region?).LongName();
+            }
+        }
+
+        public Region? Value
+        {
+            get { return data as Region?; }
+        }
+    }
+}

DICUI/Constants.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Media;
+using DICUI.Data;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Variables for UI elements
+    /// </summary>
+    public static class Constants
+    {
+        public const string StartDumping = "Start Dumping";
+        public const string StopDumping = "Stop Dumping";
+
+        public const int LogWindowMarginFromMainWindow = 10;
+
+        // Private lists of known drive speed ranges
+        private static IReadOnlyList<int> cd { get; } = new List<int> { 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72 };
+        private static IReadOnlyList<int> dvd { get; } = cd.Where(s => s <= 24).ToList();
+        private static IReadOnlyList<int> bd { get; } = cd.Where(s => s <= 16).ToList();
+        private static IReadOnlyList<int> unknown { get; } = cd; // TODO: All or {1}? Maybe null?
+
+        /// <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.HDDVD:
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return dvd;
+                case MediaType.BluRay:
+                    return bd;
+                default:
+                    return unknown;
+            }
+        }
+
+        // Create collections for UI based on known drive speeds
+        public static DoubleCollection SpeedsForCDAsCollection { get; } = GetDoubleCollectionFromIntList(cd);
+        public static DoubleCollection SpeedsForDVDAsCollection { get; } = GetDoubleCollectionFromIntList(dvd);
+        public static DoubleCollection SpeedsForBDAsCollection { get; } = GetDoubleCollectionFromIntList(bd);
+        private static DoubleCollection GetDoubleCollectionFromIntList(IReadOnlyList<int> list)
+            => new DoubleCollection(list.Select(i => Convert.ToDouble(i)).ToList());
+    }
+}

DICUI/DICUI.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
+  <PropertyGroup>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <OutputType>WinExe</OutputType>
+    <UseWindowsForms>true</UseWindowsForms>
+    <UseWPF>true</UseWPF>
+    <Prefer32Bit>true</Prefer32Bit>
+    <ApplicationIcon>Icon.ico</ApplicationIcon>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Configuration.ConfigurationManager" Version="4.6.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DICUI.Library\DICUI.Library.csproj">
+      <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
+      <Name>DICUI.Library</Name>
+    </ProjectReference>
+  </ItemGroup>
+
+</Project>

DICUI/EnumDescriptionConverter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using DICUI.Data;
+using DICUI.Utilities;
+
+namespace DICUI
+{
+    /// <summary>
+    /// Used to provide a converter to XAML files to render comboboxes with enum values
+    /// </summary>
+    public class EnumDescriptionConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            // Common
+            if (value is MediaType?)
+                return ((MediaType?)value).LongName();
+            else if (value is KnownSystem?)
+                return ((KnownSystem?)value).LongName();
+
+            // Default
+            else
+                return "";
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return string.Empty;
+        }
+    }
+}

DICUI/Properties/AssemblyInfo.cs

@@ -12,7 +12,7 @@ using System.Windows;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("DICUI")]
-[assembly: AssemblyCopyright("Copyright ©  2018")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -51,5 +51,8 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.16.1")]
+[assembly: AssemblyFileVersion("1.16.1.0")]
+
+// Anything marked as internal can be used by the test methods
+[assembly: InternalsVisibleTo("DICUI.Test")]

DICUI/UIOptions.cs

@@ -0,0 +1,122 @@
+using System.Collections.Generic;
+using System.Configuration;
+using DICUI.Data;
+
+namespace DICUI
+{
+    public class UIOptions
+    {
+        // TODO: Is there any way that this can be made private?
+        public Options Options { get; set; }
+
+        #region Passthrough readonly values
+
+        // TODO: Can any of these be removed?
+        public string DefaultOutputPath { get { return Options.DefaultOutputPath; } }
+        public bool IgnoreFixedDrives { get { return Options.IgnoreFixedDrives; } }
+        public bool ResetDriveAfterDump { get { return Options.ResetDriveAfterDump; } }
+        public bool SkipMediaTypeDetection { get { return Options.SkipMediaTypeDetection; } }
+        public bool SkipSystemDetection { get { return Options.SkipSystemDetection; } }
+        public bool OpenLogWindowAtStartup { get { return Options.OpenLogWindowAtStartup; } }
+
+        #endregion
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public UIOptions()
+        {
+            Load();
+        }
+
+        /// <summary>
+        /// Save a configuration from internal Options
+        /// </summary>
+        public void Save()
+        {
+            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+
+            // Loop through all settings in Options and save them, overwriting existing settings
+            foreach (var kvp in Options)
+            {
+                configFile.AppSettings.Settings.Remove(kvp.Key);
+                configFile.AppSettings.Settings.Add(kvp.Key, kvp.Value);
+            }
+
+            configFile.Save(ConfigurationSaveMode.Modified);
+        }
+
+        /// <summary>
+        /// Load a configuration into internal Options
+        /// </summary>
+        private void Load()
+        {
+            Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+
+            var settings = ConvertToDictionary(configFile);
+            Options = new Options(settings);
+        }
+
+        /// <summary>
+        /// Get a setting value from the base Options
+        /// </summary>
+        /// <param name="key">Key to retrieve the value for</param>
+        /// <returns>String value if possible, null otherwise</returns>
+        public string Get(string key)
+        {
+            return Options[key];
+        }
+
+        /// <summary>
+        /// Set a setting value in the base Options
+        /// </summary>
+        /// <param name="key">Key to set the value for</param>
+        /// <param name="value">Value to set</param>
+        public void Set(string key, string value)
+        {
+            Options[key] = value;
+        }
+
+        /// <summary>
+        /// Get the preferred dumping speed given a media type
+        /// </summary>
+        /// <param name="type">MediaType representing the current selection</param>
+        /// <returns>Int value representing the dump speed</returns>
+        public int GetPreferredDumpSpeedForMediaType(MediaType? type)
+        {
+            switch (type)
+            {
+                case MediaType.CDROM:
+                case MediaType.GDROM:
+                    return this.Options.PreferredDumpSpeedCD;
+                case MediaType.DVD:
+                case MediaType.HDDVD:
+                case MediaType.NintendoGameCubeGameDisc:
+                case MediaType.NintendoWiiOpticalDisc:
+                    return this.Options.PreferredDumpSpeedDVD;
+                case MediaType.BluRay:
+                    return this.Options.PreferredDumpSpeedBD;
+                default:
+                    return this.Options.PreferredDumpSpeedCD;
+            }
+        }
+
+        /// <summary>
+        /// Convert the configuration app settings to a dictionary
+        /// </summary>
+        /// <param name="configFile">Configuration to load from</param>
+        /// <returns>Dictionary with all values from app settings</returns>
+        private Dictionary<string, string> ConvertToDictionary(Configuration configFile)
+        {
+            var settings = configFile.AppSettings.Settings;
+            var dict = new Dictionary<string, string>();
+
+            foreach (string key in settings.AllKeys)
+            {
+                dict[key] = settings[key]?.Value ?? string.Empty;
+            }
+
+            return dict;
+        }
+    }
+}

DICUI/ViewModels.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Windows.Media;
+using DICUI.Windows;
+
+namespace DICUI
+{
+    public class OptionsViewModel
+    {
+        private UIOptions _uiOptions;
+
+        #region Internal Program
+
+        public string AaruPath
+        {
+            get { return _uiOptions.Options.AaruPath; }
+            set { _uiOptions.Options.AaruPath = value; }
+        }
+
+        public string CreatorPath
+        {
+            get { return _uiOptions.Options.CreatorPath; }
+            set { _uiOptions.Options.CreatorPath = value; }
+        }
+
+        public string DDPath
+        {
+            get { return _uiOptions.Options.DDPath; }
+            set { _uiOptions.Options.DDPath = value; }
+        }
+
+        public string InternalProgram
+        {
+            get { return _uiOptions.Options.InternalProgram; }
+            set { _uiOptions.Options.InternalProgram = value; }
+        }
+
+        #endregion
+
+        #region Extra Paths
+
+        public string DefaultOutputPath
+        {
+            get { return _uiOptions.Options.DefaultOutputPath; }
+            set { _uiOptions.Options.DefaultOutputPath = value; }
+        }
+
+        public string SubDumpPath
+        {
+            get { return _uiOptions.Options.SubDumpPath; }
+            set { _uiOptions.Options.SubDumpPath = value; }
+        }
+
+        #endregion
+
+        #region Dumping Speeds
+
+        public int PreferredDumpSpeedCD
+        {
+            get { return _uiOptions.Options.PreferredDumpSpeedCD; }
+            set { _uiOptions.Options.PreferredDumpSpeedCD = value; }
+        }
+
+        public int PreferredDumpSpeedDVD
+        {
+            get { return _uiOptions.Options.PreferredDumpSpeedDVD; }
+            set { _uiOptions.Options.PreferredDumpSpeedDVD = value; }
+        }
+
+        public int PreferredDumpSpeedBD
+        {
+            get { return _uiOptions.Options.PreferredDumpSpeedBD; }
+            set { _uiOptions.Options.PreferredDumpSpeedBD = value; }
+        }
+
+        #endregion
+
+        #region Extra Dumping Options
+
+        public bool QuietMode
+        {
+            get { return _uiOptions.Options.QuietMode; }
+            set { _uiOptions.Options.QuietMode = value; }
+        }
+
+        public bool ParanoidMode
+        {
+            get { return _uiOptions.Options.ParanoidMode; }
+            set { _uiOptions.Options.ParanoidMode = value; }
+        }
+
+        public bool ScanForProtection
+        {
+            get { return _uiOptions.Options.ScanForProtection; }
+            set { _uiOptions.Options.ScanForProtection = value; }
+        }
+
+        public string RereadAmountForC2
+        {
+            get { return Convert.ToString(_uiOptions.Options.RereadAmountForC2); }
+            set
+            {
+                if (Int32.TryParse(value, out int result))
+                    _uiOptions.Options.RereadAmountForC2 = result;
+            }
+        }
+
+        public bool AddPlaceholders
+        {
+            get { return _uiOptions.Options.AddPlaceholders; }
+            set { _uiOptions.Options.AddPlaceholders = value; }
+        }
+
+        public bool PromptForDiscInformation
+        {
+            get { return _uiOptions.Options.PromptForDiscInformation; }
+            set { _uiOptions.Options.PromptForDiscInformation = value; }
+        }
+
+        public bool IgnoreFixedDrives
+        {
+            get { return _uiOptions.Options.IgnoreFixedDrives; }
+            set { _uiOptions.Options.IgnoreFixedDrives = value; }
+        }
+
+        public bool ResetDriveAfterDump
+        {
+            get { return _uiOptions.Options.ResetDriveAfterDump; }
+            set { _uiOptions.Options.ResetDriveAfterDump = value; }
+        }
+
+        #endregion
+
+        #region Skip Options
+
+        public bool SkipMediaTypeDetection
+        {
+            get { return _uiOptions.Options.SkipMediaTypeDetection; }
+            set { _uiOptions.Options.SkipMediaTypeDetection = value; }
+        }
+
+        public bool SkipSystemDetection
+        {
+            get { return _uiOptions.Options.SkipSystemDetection; }
+            set { _uiOptions.Options.SkipSystemDetection = value; }
+        }
+
+        #endregion
+
+        #region Logging Options
+
+        public bool VerboseLogging
+        {
+            get { return _uiOptions.Options.VerboseLogging; }
+            set
+            {
+                _uiOptions.Options.VerboseLogging = value;
+                _uiOptions.Save(); // TODO: Why does this save here?
+            }
+        }
+
+        public bool OpenLogWindowAtStartup
+        {
+            get { return _uiOptions.Options.OpenLogWindowAtStartup; }
+            set
+            {
+                _uiOptions.Options.OpenLogWindowAtStartup = value;
+                _uiOptions.Save(); // TODO: Why does this save here?
+            }
+        }
+
+        #endregion
+
+        #region Redump Login Information
+
+        public string Username
+        {
+            get { return _uiOptions.Options.Username; }
+            set { _uiOptions.Options.Username = value; }
+        }
+
+        public string Password
+        {
+            get { return _uiOptions.Options.Password; }
+            set { _uiOptions.Options.Password = value; }
+        }
+
+        #endregion
+
+        public OptionsViewModel(UIOptions uiOptions)
+        {
+            this._uiOptions = uiOptions;
+        }
+    }
+
+    public class LoggerViewModel
+    {
+        private LogWindow _logWindow;
+
+        public void SetWindow(LogWindow logWindow) => _logWindow = logWindow;
+
+        public bool WindowVisible
+        {
+            get => _logWindow != null ? _logWindow.IsVisible : false;
+            set
+            {
+                if (value)
+                {
+                    _logWindow.AdjustPositionToMainWindow();
+                    _logWindow.Show();
+                }
+                else
+                    _logWindow.Hide();
+            }
+        }
+
+        public void VerboseLog(string text)
+        {
+            if (ViewModels.OptionsViewModel.VerboseLogging)
+                _logWindow.AppendToTextBox(text, Brushes.Yellow);
+        }
+
+        public void VerboseLog(string format, params object[] args) => VerboseLog(string.Format(format, args));
+        public void VerboseLogLn(string format, params object[] args) => VerboseLog(string.Format(format, args) + "\n");
+    }
+
+    public static class ViewModels
+    {
+        public static OptionsViewModel OptionsViewModel { get; set; }
+        public static LoggerViewModel LoggerViewModel { get; set; } = new LoggerViewModel();
+    }
+}

DICUI/Windows/DiscInformationWindow.xaml

@@ -0,0 +1,156 @@
+<Window x:Class="DICUI.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:local="clr-namespace:DICUI"
+        mc:Ignorable="d"
+        Title="Disc Information" Height="705" Width="515.132" ResizeMode="NoResize"
+        Closed="OnClosed">
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="585"/>
+            <RowDefinition Height="80"/>
+        </Grid.RowDefinitions>
+
+        <GroupBox Grid.Row="0" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Common Disc Information">
+            <Grid Margin="10,15,10,10">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                    <RowDefinition Height="25"/>
+                </Grid.RowDefinitions>
+
+                <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Title" />
+                <TextBox x:Name="TitleTextBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Foreign Title (Non-Latin)" />
+                <TextBox x:Name="ForeignTitleTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Disc Number / Letter" />
+                <TextBox x:Name="DiscNumberLetterTextBox" Grid.Row="2" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Disc Title" />
+                <TextBox x:Name="DiscTitleTextBox" Grid.Row="3" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Category" />
+                <ComboBox x:Name="CategoryComboBox" Grid.Row="4" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" >
+                    <ComboBox.ItemTemplate>
+                        <DataTemplate>
+                            <TextBlock Text="{Binding Path=Name}" />
+                        </DataTemplate>
+                    </ComboBox.ItemTemplate>
+                </ComboBox>
+
+                <Label Grid.Row="5" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Region" />
+                <ComboBox x:Name="RegionComboBox" Grid.Row="5" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" >
+                    <ComboBox.ItemTemplate>
+                        <DataTemplate>
+                            <TextBlock Text="{Binding Path=Name}" />
+                        </DataTemplate>
+                    </ComboBox.ItemTemplate>
+                </ComboBox>
+
+                <Label Grid.Row="6" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Languages" />
+                <ComboBox x:Name="LanguagesComboBox" Grid.Row="6" Grid.Column="1" Height="24" HorizontalAlignment="Stretch" >
+                    <ComboBox.ItemTemplate>
+                        <DataTemplate>
+                            <CheckBox IsChecked="{Binding IsChecked}" Content="{Binding Path=Name}" />
+                        </DataTemplate>
+                    </ComboBox.ItemTemplate>
+                </ComboBox>
+
+                <Label Grid.Row="7" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Serial" />
+                <TextBox x:Name="SerialTextBox" Grid.Row="7" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <!-- Layer 0 / Data Side -->
+                <Label Grid.Row="8" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Data/L0 Mastering Ring" />
+                <TextBox x:Name="L0MasteringRingTextBox" Grid.Row="8" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" AcceptsTab="True" />
+
+                <Label Grid.Row="9" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Data/L0 Mastering SID" />
+                <TextBox x:Name="L0MasteringSIDTextBox" Grid.Row="9" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="10" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Data/L0 Toolstamp/Mastering Code" />
+                <TextBox x:Name="L0ToolstampTextBox" Grid.Row="10" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="11" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Data/L0 Mould SID" />
+                <TextBox x:Name="L0MouldSIDTextBox" Grid.Row="11" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="12" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Data/L0 Additional Mould" />
+                <TextBox x:Name="L0AdditionalMouldTextBox" Grid.Row="12" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <!-- Layer 1 / Label Side -->
+                <Label Grid.Row="13" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Label/L1 Mastering Ring" />
+                <TextBox x:Name="L1MasteringRingTextBox" Grid.Row="13" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" AcceptsTab="True" />
+
+                <Label Grid.Row="14" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Label/L1 Mastering SID" />
+                <TextBox x:Name="L1MasteringSIDTextBox" Grid.Row="14" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="15" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Label/L1 Toolstamp/Mastering Code" />
+                <TextBox x:Name="L1ToolstampTextBox" Grid.Row="15" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="16" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Label/L1 Mould SID" />
+                <TextBox x:Name="L1MouldSIDTextBox" Grid.Row="16" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="17" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Label/L1 Additional Mould" />
+                <TextBox x:Name="L1AdditionalMouldTextBox" Grid.Row="17" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="18" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Barcode" />
+                <TextBox x:Name="BarcodeTextBox" Grid.Row="18" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <!-- This needs to be a multiline textbox -->
+                <Label Grid.Row="19" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Comments" />
+                <TextBox x:Name="CommentsTextBox" Grid.Row="19" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" AcceptsReturn="True" AcceptsTab="True" />
+
+                <!-- This needs to be a multiline textbox -->
+                <Label Grid.Row="20" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Contents" />
+                <TextBox x:Name="ContentsTextBox" Grid.Row="20" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" AcceptsReturn="True" AcceptsTab="True"/>
+            </Grid>
+        </GroupBox>
+
+        <GroupBox Grid.Row="1" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Version and Editions">
+            <Grid Height="60">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="1*"/>
+                    <ColumnDefinition Width="1*"/>
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="24"/>
+                    <RowDefinition Height="24"/>
+                </Grid.RowDefinitions>
+
+                <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Version" />
+                <TextBox x:Name="VersionTextBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+
+                <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Edition" />
+                <TextBox x:Name="EditionTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+            </Grid>
+        </GroupBox>
+    </Grid>
+</Window>

DICUI/Windows/DiscInformationWindow.xaml.cs

@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using DICUI.Data;
+
+namespace DICUI.Windows
+{
+    /// <summary>
+    /// Interaction logic for DiscInformationWindow.xaml
+    /// </summary>
+    public partial class DiscInformationWindow : Window
+    {
+        private readonly MainWindow _mainWindow;
+        private readonly SubmissionInfo _submissionInfo;
+
+        private List<CategoryComboBoxItem> _categories;
+        private List<RegionComboBoxItem> _regions;
+        private List<LanguageComboBoxItem> _languages;
+
+        public DiscInformationWindow(MainWindow mainWindow, SubmissionInfo submissionInfo)
+        {
+            InitializeComponent();
+            _mainWindow = mainWindow;
+            _submissionInfo = submissionInfo;
+
+            PopulateCategories();
+            PopulateRegions();
+            PopulateLanguages();
+            DisableFieldsIfNeeded();
+        }
+
+        public void Refresh()
+        {
+            TitleTextBox.Text = _submissionInfo.CommonDiscInfo.Title ?? "";
+            ForeignTitleTextBox.Text = _submissionInfo.CommonDiscInfo.ForeignTitleNonLatin ?? "";
+            DiscNumberLetterTextBox.Text = _submissionInfo.CommonDiscInfo.DiscNumberLetter ?? "";
+            DiscTitleTextBox.Text = _submissionInfo.CommonDiscInfo.DiscTitle ?? "";
+            CategoryComboBox.SelectedIndex = _categories.FindIndex(r => r == _submissionInfo.CommonDiscInfo.Category);
+            RegionComboBox.SelectedIndex = _regions.FindIndex(r => r == _submissionInfo.CommonDiscInfo.Region);
+            if (_submissionInfo.CommonDiscInfo.Languages != null)
+            {
+                foreach (var language in _submissionInfo.CommonDiscInfo.Languages)
+                    _languages.Find(l => l == language).IsChecked = true;
+            }
+            SerialTextBox.Text = _submissionInfo.CommonDiscInfo.Serial ?? "";
+            L0MasteringRingTextBox.Text = _submissionInfo.CommonDiscInfo.MasteringRingFirstLayerDataSide ?? "";
+            L0MasteringSIDTextBox.Text = _submissionInfo.CommonDiscInfo.MasteringSIDCodeFirstLayerDataSide ?? "";
+            L0ToolstampTextBox.Text = _submissionInfo.CommonDiscInfo.ToolstampMasteringCodeFirstLayerDataSide ?? "";
+            L0MouldSIDTextBox.Text = _submissionInfo.CommonDiscInfo.MouldSIDCodeFirstLayerDataSide ?? "";
+            L0AdditionalMouldTextBox.Text = _submissionInfo.CommonDiscInfo.AdditionalMouldFirstLayerDataSide ?? "";
+            L1MasteringRingTextBox.Text = _submissionInfo.CommonDiscInfo.MasteringRingSecondLayerLabelSide ?? "";
+            L1MasteringSIDTextBox.Text = _submissionInfo.CommonDiscInfo.MasteringSIDCodeSecondLayerLabelSide ?? "";
+            L1ToolstampTextBox.Text = _submissionInfo.CommonDiscInfo.ToolstampMasteringCodeSecondLayerLabelSide ?? "";
+            L1MouldSIDTextBox.Text = _submissionInfo.CommonDiscInfo.MouldSIDCodeSecondLayerLabelSide ?? "";
+            L1AdditionalMouldTextBox.Text = _submissionInfo.CommonDiscInfo.AdditionalMouldSecondLayerLabelSide ?? "";
+            BarcodeTextBox.Text = _submissionInfo.CommonDiscInfo.Barcode ?? "";
+            CommentsTextBox.Text = _submissionInfo.CommonDiscInfo.Comments ?? "";
+            ContentsTextBox.Text = _submissionInfo.CommonDiscInfo.Contents ?? "";
+
+            VersionTextBox.Text = _submissionInfo.VersionAndEditions.Version ?? "";
+            EditionTextBox.Text = _submissionInfo.VersionAndEditions.OtherEditions ?? "";
+        }
+
+        /// <summary>
+        /// Get a complete list of categories and fill the combo box
+        /// </summary>
+        private void PopulateCategories()
+        {
+            var categories = Enum.GetValues(typeof(Category)).OfType<Category?>().ToList();
+
+            ViewModels.LoggerViewModel.VerboseLogLn("Populating categories, {0} categories found.", categories.Count);
+
+            _categories = new List<CategoryComboBoxItem>();
+            foreach (var category in categories)
+            {
+                _categories.Add(new CategoryComboBoxItem(category));
+            }
+
+            CategoryComboBox.ItemsSource = _categories;
+            CategoryComboBox.SelectedIndex = 0;
+        }
+
+        /// <summary>
+        /// Get a complete list of regions and fill the combo box
+        /// </summary>
+        private void PopulateRegions()
+        {
+            var regions = Enum.GetValues(typeof(Region)).OfType<Region?>().ToList();
+
+            ViewModels.LoggerViewModel.VerboseLogLn("Populating regions, {0} regions found.", regions.Count);
+
+            _regions = new List<RegionComboBoxItem>();
+            foreach (var region in regions)
+            {
+                _regions.Add(new RegionComboBoxItem(region));
+            }
+
+            RegionComboBox.ItemsSource = _regions;
+            RegionComboBox.SelectedIndex = 0;
+        }
+
+        /// <summary>
+        /// Get a complete list of languages and fill the combo box
+        /// </summary>
+        private void PopulateLanguages()
+        {
+            var languages = Enum.GetValues(typeof(Language)).OfType<Language?>().ToList();
+
+            ViewModels.LoggerViewModel.VerboseLogLn("Populating languages, {0} languages found.", languages.Count);
+
+            _languages = new List<LanguageComboBoxItem>();
+            foreach (var language in languages)
+            {
+                _languages.Add(new LanguageComboBoxItem(language));
+            }
+
+            LanguagesComboBox.ItemsSource = _languages;
+            LanguagesComboBox.SelectedIndex = 0;
+        }
+
+        /// <summary>
+        /// Disable fields that aren't applicable to the current disc
+        /// </summary>
+        private void DisableFieldsIfNeeded()
+        {
+            // Only disable for single-layer discs
+            if (_submissionInfo.SizeAndChecksums.Layerbreak == default(long))
+            {
+                L1MasteringRingTextBox.IsEnabled = false;
+                L1MasteringRingTextBox.Background = Brushes.Gray;
+
+                L1MasteringSIDTextBox.IsEnabled = false;
+                L1MasteringSIDTextBox.Background = Brushes.Gray;
+
+                L1ToolstampTextBox.IsEnabled = false;
+                L1ToolstampTextBox.Background = Brushes.Gray;
+
+                L1MouldSIDTextBox.IsEnabled = false;
+                L1MouldSIDTextBox.Background = Brushes.Gray;
+
+                L1AdditionalMouldTextBox.IsEnabled = false;
+                L1AdditionalMouldTextBox.Background = Brushes.Gray;
+            }
+        }
+
+        #region Event Handlers
+
+        private void OnClosed(object sender, EventArgs e)
+        {
+            _submissionInfo.CommonDiscInfo.Title = TitleTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.ForeignTitleNonLatin = ForeignTitleTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.DiscNumberLetter = DiscNumberLetterTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.DiscTitle = DiscTitleTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.Category = (CategoryComboBox.SelectedItem as CategoryComboBoxItem)?.Value ?? Category.Games;
+            _submissionInfo.CommonDiscInfo.Region = (RegionComboBox.SelectedItem as RegionComboBoxItem)?.Value ?? Region.World;
+            var languages = new List<Language?>();
+            foreach (var language in _languages)
+            {
+                if (language.IsChecked)
+                    languages.Add(language.Value);
+            }
+            if (languages.Count == 0)
+                languages.Add(null);
+            _submissionInfo.CommonDiscInfo.Languages = languages.ToArray();
+            _submissionInfo.CommonDiscInfo.Serial = SerialTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MasteringRingFirstLayerDataSide = L0MasteringRingTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MasteringSIDCodeFirstLayerDataSide = L0MasteringSIDTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.ToolstampMasteringCodeFirstLayerDataSide = L0ToolstampTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MouldSIDCodeFirstLayerDataSide = L0MouldSIDTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.AdditionalMouldFirstLayerDataSide = L0AdditionalMouldTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MasteringRingSecondLayerLabelSide = L1MasteringRingTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MasteringSIDCodeSecondLayerLabelSide = L1MasteringSIDTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.ToolstampMasteringCodeSecondLayerLabelSide = L1ToolstampTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.MouldSIDCodeSecondLayerLabelSide = L1MouldSIDTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.AdditionalMouldSecondLayerLabelSide = L1AdditionalMouldTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.Barcode = BarcodeTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.Comments = CommentsTextBox.Text ?? "";
+            _submissionInfo.CommonDiscInfo.Contents = ContentsTextBox.Text ?? "";
+
+            _submissionInfo.VersionAndEditions.Version = VersionTextBox.Text ?? "";
+            _submissionInfo.VersionAndEditions.OtherEditions = EditionTextBox.Text ?? "";
+
+            Hide();
+        }
+
+        #endregion
+    }
+}

DICUI/Windows/LogWindow.xaml

@@ -0,0 +1,56 @@
+<Window x:Class="DICUI.Windows.LogWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:local="clr-namespace:DICUI"
+        xmlns:diag="clr-namespace:System.Diagnostics;assembly=WindowsBase"
+        Title="Log Window" Height="350" Width="600" Closed="OnWindowClosed" Loaded="OnWindowLoaded"
+        >
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="40" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="40" />
+        </Grid.RowDefinitions>
+        <Grid Grid.Row="0" Height="22" Margin="10 10 10 0">
+            <ProgressBar x:Name="progressBar" />
+            <TextBlock x:Name="progressLabel" Grid.Row="0" Height="22" HorizontalAlignment="Center" VerticalAlignment="Center" Padding="0 2 0 0" />
+        </Grid>
+        <Border Grid.Row="1" Background="White" BorderBrush="Gainsboro" BorderThickness="1" Margin="10">
+            <ScrollViewer Name="outputViewer" SizeChanged="ScrollViewer_SizeChanged">
+                <RichTextBox Name="output" FontFamily="Consolas" Background="#202020" IsReadOnly="true" TextChanged="OnTextChanged" />
+            </ScrollViewer>
+        </Border>
+
+        <Grid Grid.Row="2">
+            <Grid.RowDefinitions>
+                <RowDefinition />
+            </Grid.RowDefinitions>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition />
+                <ColumnDefinition />
+                <ColumnDefinition Width="3*"/>
+                <ColumnDefinition />
+                <ColumnDefinition />
+                <ColumnDefinition />
+            </Grid.ColumnDefinitions>
+
+            <CheckBox Content="Verbose" Margin="10 0 0 10" Grid.Column="0" VerticalAlignment="Center" 
+                      ToolTip="Enable verbose logging of tasks"
+                      DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+                      IsChecked="{Binding Path=VerboseLogging}"    
+            />
+            <CheckBox Content="Open at startup" Margin="10 0 0 10" Grid.Column="1" Grid.ColumnSpan="2" VerticalAlignment="Center" 
+                      ToolTip="Open this window at startup"
+                      DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+                      IsChecked="{Binding Path=OpenLogWindowAtStartup}"    
+            />
+            <Button Margin="0 0 10 10" Grid.Column="3" Height="22" Width="60" Content="Clear" HorizontalAlignment="Right" Click="OnClearButton" />
+            <Button Margin="0 0 10 10" Grid.Column="4" Height="22" Width="60" Content="Hide" HorizontalAlignment="Right" Click="OnHideButton" />
+            <Button Margin="0 0 10 10" Grid.Column="5" Height="22" Width="60" Content="Save" HorizontalAlignment="Right" Click="OnSaveButton" />
+            <Button Visibility="Hidden" Name="AbortButton" Margin="0 0 10 10" Grid.Column="2" Height="22" Width="80" Content="Abort" HorizontalAlignment="Right" Click="OnAbortButton" />
+        </Grid>
+        
+
+
+    </Grid>
+</Window>

DICUI/Windows/LogWindow.xaml.cs

@@ -0,0 +1,399 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Interop;
+using System.Windows.Media;
+
+namespace DICUI.Windows
+{
+    public partial class LogWindow : Window
+    {
+        private const int GWL_STYLE = -16;
+        private const int WS_SYSMENU = 0x80000;
+        [DllImport("user32.dll", SetLastError = true)]
+        private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
+        [DllImport("user32.dll")]
+        private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
+
+        private MainWindow _mainWindow;
+
+        private FlowDocument _document;
+        private Paragraph _paragraph;
+        private List<Matcher> _matchers;
+
+        volatile Process _process;
+
+        public LogWindow(MainWindow mainWindow)
+        {
+            InitializeComponent();
+
+            this._mainWindow = mainWindow;
+
+            _document = new FlowDocument();
+            _paragraph = new Paragraph();
+            _document.Blocks.Add(_paragraph);
+            output.Document = _document;
+
+            _matchers = new List<Matcher>();
+
+            _matchers.Add(new Matcher(
+                "Descrambling data sector of img (LBA)",
+                @"\s*(\d+)\/\s*(\d+)$",
+                match => {
+                    if (UInt32.TryParse(match.Groups[1].Value, out uint current) && UInt32.TryParse(match.Groups[2].Value, out uint total))
+                    {
+                        float percentProgress = (current / (float)total) * 100;
+                        progressBar.Value = percentProgress;
+                        progressLabel.Text = string.Format("Descrambling image.. ({0:##.##}%)", percentProgress);
+                    }
+            }));
+
+            _matchers.Add(new Matcher(
+                @"Creating .scm (LBA)",
+                @"\s*(\d+)\/\s*(\d+)$",
+                match => {
+                    if (UInt32.TryParse(match.Groups[1].Value, out uint current) && UInt32.TryParse(match.Groups[2].Value, out uint total))
+                    {
+                        float percentProgress = (current / (float)total) * 100;
+                        progressBar.Value = percentProgress;
+                        progressLabel.Text = string.Format("Creating scrambled image.. ({0:##.##}%)", percentProgress);
+                    }
+            }));
+
+            _matchers.Add(new Matcher(
+                "Checking sectors (LBA)",
+                @"\s*(\d+)\/\s*(\d+)$",
+                match => {
+                    if (UInt32.TryParse(match.Groups[1].Value, out uint current) && UInt32.TryParse(match.Groups[2].Value, out uint total))
+                    {
+                        float percentProgress = (current / (float)total) * 100;
+                        progressBar.Value = percentProgress;
+                        progressLabel.Text = string.Format("Checking for errors.. ({0:##.##}%)", percentProgress);
+                    }
+            }));
+
+            _matchers.Add(new Matcher(
+                "Scanning sector (LBA)",
+                @"\s*(\d+)\/\s*(\d+)$",
+                match => {
+                    if (UInt32.TryParse(match.Groups[1].Value, out uint current) && UInt32.TryParse(match.Groups[2].Value, out uint total))
+                    {
+                        float percentProgress = (current / (float)total) * 100;
+                        progressBar.Value = percentProgress;
+                        progressLabel.Text = string.Format("Scanning sectors for protection.. ({0:##.##}%)", percentProgress);
+                    }
+                }));
+        }
+
+        public void StartDump(string args)
+        {
+            AppendToTextBox(string.Format("Launching DIC with args: {0}\r\n", args), Brushes.Orange);
+
+            Task.Run(() =>
+            {
+                _process = new Process()
+                {
+                    StartInfo = new ProcessStartInfo()
+                    {
+                        FileName = @"Programs/DiscImageCreator.exe",
+                        Arguments = args,
+                        CreateNoWindow = true,
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                    },
+                };
+
+                StreamState stdoutState = new StreamState(false);
+                StreamState stderrState = new StreamState(true);
+
+                //_cmd.ErrorDataReceived += (process, text) => Dispatcher.Invoke(() => UpdateConsole(text.Data, Brushes.Red));
+                _process.Start();
+
+                var _1 = ConsumeOutput(_process.StandardOutput, s => Dispatcher.Invoke(() => UpdateConsole(s, stdoutState)));
+                var _2 = ConsumeOutput(_process.StandardError, s => Dispatcher.Invoke(() => UpdateConsole(s, stderrState)));
+
+                _process.EnableRaisingEvents = true;
+                _process.Exited += OnProcessExit;
+            });
+        }
+
+        public void AdjustPositionToMainWindow()
+        {
+            this.Left = _mainWindow.Left;
+            this.Top = _mainWindow.Top + _mainWindow.Height + Constants.LogWindowMarginFromMainWindow;
+        }
+
+        private void GracefullyTerminateProcess()
+        {
+            if (_process != null)
+            {
+                _process.Exited -= OnProcessExit;
+                bool isForced = !_process.HasExited;
+
+                if (isForced)
+                {
+                    AppendToTextBox("\r\nForcefully Killing the process\r\n", Brushes.Red);
+                    _process.Kill();
+                    _process.WaitForExit();
+                }
+
+                AppendToTextBox(string.Format("\r\nExit Code: {0}\r\n", _process.ExitCode), _process.ExitCode == 0 ? Brushes.Green : Brushes.Red);
+
+                if (_process.ExitCode == 0)
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        progressLabel.Text = "Done!";
+                        progressBar.Value = 100;
+                        progressBar.Foreground = Brushes.Green;
+                    });
+                }
+                else
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        progressLabel.Text = isForced ? "Aborted by user" : "Error, please check log!";
+                        progressBar.Value = 100;
+                        progressBar.Foreground = Brushes.Red;
+                    });
+                }
+
+                _process.Close();
+            }
+
+            _process = null;
+        }
+
+        private void ScrollViewer_SizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            outputViewer.ScrollToBottom();
+        }
+
+        async Task ConsumeOutput(TextReader reader, Action<string> callback)
+        {
+            char[] buffer = new char[256];
+            int cch;
+
+            while ((cch = await reader.ReadAsync(buffer, 0, buffer.Length)) > 0)
+            {
+                callback(new string(buffer, 0, cch));
+            }
+        }
+
+        // this is used to optimize the work since we need to process A LOT of text
+        struct Matcher
+        {
+            private readonly string prefix;
+            private readonly Regex regex;
+            private readonly int start;
+            private readonly Action<Match> lambda;
+
+            public Matcher(string prefix, string regex, Action<Match> lambda)
+            {
+                this.prefix = prefix;
+                this.regex = new Regex(regex);
+                this.start = prefix.Length;
+                this.lambda = lambda;
+            }
+
+            public bool Matches(ref string text) => text.StartsWith(prefix);
+
+            public void Apply(ref string text)
+            {
+                Match match = regex.Match(text, start);
+                lambda.Invoke(match);
+            }
+        }
+
+        private void ProcessStringForProgressBar(string text)
+        {
+            foreach (Matcher matcher in _matchers)
+            {
+                if (matcher.Matches(ref text))
+                {
+                    matcher.Apply(ref text);
+                    return;
+                }
+            }
+        }
+
+        class StreamState
+        {
+            public enum State
+            {
+                BEGIN,
+                READ_CARRIAGE,
+            };
+
+            public State state;
+            public readonly StringBuilder buffer;
+            public readonly bool isError;
+
+            public StreamState(bool isError)
+            {
+                this.state = State.BEGIN;
+                this.buffer = new StringBuilder();
+                this.isError = isError;
+            }
+
+            public bool HasData() => buffer.Length > 0;
+            public string Fetch() => buffer.ToString();
+            public void Clear() => buffer.Clear();
+            public void Append(char c) => buffer.Append(c);
+
+            public bool Is(State state) => this.state == state;
+            public void Set(State state) => this.state = state;
+        }
+
+        public void AppendToTextBox(string text, Brush color)
+        {
+            if (Application.Current.Dispatcher.CheckAccess())
+            {
+                Run run = new Run(text) { Foreground = color };
+                _paragraph.Inlines.Add(run);
+            }
+            else
+                Dispatcher.Invoke(() =>
+                {
+                    Run run = new Run(text) { Foreground = color };
+                    _paragraph.Inlines.Add(run);
+                });
+        }
+
+        private void UpdateConsole(string text, StreamState state)
+        {
+            /*if (c == '\r') { output.Inlines.Add(@"\r"); file.Write("\\r"); }
+                else if (c == '\n') { output.Inlines.Add(@"\n"); file.Write("\\n\n"); }
+                output.Inlines.Add(""+c);
+                file.Write(c);
+                file.Flush();
+                continue;*/
+
+            if (text != null)
+            {
+                foreach (char c in text)
+                {
+                    switch (c)
+                    {
+                        case '\r' when (state.Is(StreamState.State.BEGIN)):
+                            {
+                                state.Set(StreamState.State.READ_CARRIAGE);
+                                break;
+                            }
+
+                        case '\n' when (state.Is(StreamState.State.READ_CARRIAGE)):
+                            {
+                                if (state.buffer.Length > 0)
+                                {
+                                    string buffer = state.Fetch();
+
+                                    AppendToTextBox(buffer, state.isError ? Brushes.Red : Brushes.White);
+
+                                    if (!state.isError)
+                                        ProcessStringForProgressBar(buffer);
+                                }
+                                _paragraph.Inlines.Add(new LineBreak());
+                                state.Clear();
+                                state.Set(StreamState.State.BEGIN);
+                                break;
+                            }
+
+                        default:
+                            if (state.Is(StreamState.State.READ_CARRIAGE) && state.HasData())
+                            {
+                                if (!(_paragraph.Inlines.LastInline is LineBreak))
+                                    _paragraph.Inlines.Remove(_paragraph.Inlines.LastInline);
+
+                                string buffer = state.Fetch();
+
+                                AppendToTextBox(buffer, state.isError ? Brushes.Red : Brushes.White);
+
+                                if (!state.isError)
+                                    ProcessStringForProgressBar(buffer);
+
+                                state.Clear();
+                            }
+
+                            state.Set(StreamState.State.BEGIN);
+                            state.Append(c);
+                            break;
+
+                    }
+                }
+            }
+        }
+
+        #region EventHandlers
+
+        private void OnWindowClosed(object sender, EventArgs e)
+        {
+            GracefullyTerminateProcess();
+        }
+
+        private void OnWindowLoaded(object sender, EventArgs e)
+        {
+            var hwnd = new WindowInteropHelper(this).Handle;
+            SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
+        }
+
+        void OnProcessExit(object sender, EventArgs e)
+        {
+            Dispatcher.Invoke(() => AbortButton.IsEnabled = false);
+            GracefullyTerminateProcess();
+        }
+
+        private void OnHideButton(object sender, EventArgs e)
+        {
+            ViewModels.LoggerViewModel.WindowVisible = false;
+            //TODO: this should be bound directly to WindowVisible property in two way fashion
+            // we need to study how to properly do it in XAML
+            _mainWindow.ShowLogMenuItem.IsChecked = false;
+        }
+
+        private void OnClearButton(object sender, EventArgs e)
+        {
+            output.Document.Blocks.Clear();
+        }
+        
+        private void OnSaveButton(object sender, EventArgs e)
+        {
+            using (StreamWriter tw = new StreamWriter(File.OpenWrite("console.log")))
+            {
+                foreach (var inline in _paragraph.Inlines)
+                {
+                    if (inline is Run)
+                    {
+                        tw.Write(((Run)(inline)).Text);
+                    }
+                }
+            }
+        }
+
+        private void OnAbortButton(object sender, EventArgs args)
+        {
+            GracefullyTerminateProcess();
+        }
+
+        private void OnStartButton(object sender, EventArgs args)
+        {
+            StartDump("cd e Gam.iso 16");
+        }
+
+        private void OnTextChanged(object sender, TextChangedEventArgs e)
+        {
+            outputViewer.ScrollToBottom();
+        }
+
+        #endregion
+
+    }
+}

DICUI/Windows/MainWindow.xaml

@@ -0,0 +1,131 @@
+<Window x:Class="DICUI.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:local="clr-namespace:DICUI"
+        mc:Ignorable="d"
+        Title="DICUI" Height="450" Width="600" WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize" 
+        LocationChanged="MainWindowLocationChanged" Activated="MainWindowActivated" Closing="MainWindowClosing">
+
+    <Window.Resources>
+        <local:EnumDescriptionConverter x:Key="enumConverter" />
+    </Window.Resources>
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="4*"/>
+            <ColumnDefinition Width="13*"/>
+        </Grid.ColumnDefinitions>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="30"/>
+            <RowDefinition Height="4*"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="1*"/>
+        </Grid.RowDefinitions>
+
+        <StackPanel VerticalAlignment="Top" Grid.ColumnSpan="4">
+            <Menu Width="Auto" Height="20" >
+                <MenuItem Header="_File">
+                    <MenuItem x:Name="AppExit" Header="E_xit" HorizontalAlignment="Left" Width="185" Click="AppExitClick" />
+                </MenuItem>
+                <MenuItem Header="_Tools">
+                    <MenuItem x:Name="OptionsMenuItem" Header="_Options" HorizontalAlignment="Left" Width="185" Click="OptionsClick" />
+                    <MenuItem x:Name="ShowLogMenuItem" Header="Show _Log Window" IsCheckable="true" Width="185" HorizontalAlignment="Left"
+                              DataContext="{Binding Source={x:Static local:ViewModels.LoggerViewModel}}" 
+                              IsChecked="{Binding Path=WindowVisible}"
+                    />
+                </MenuItem>
+                <MenuItem Header="_Help">
+                    <MenuItem x:Name="About" Header="_About" HorizontalAlignment="Left" Width="185" Click="AboutClick" />
+                    <MenuItem x:Name="CheckForUpdatesMenuItem" Header="_Check for Updates" HorizontalAlignment="Left" Width="185" Click="CheckForUpdatesClick" />
+                </MenuItem>
+            </Menu>
+        </StackPanel>
+        <GroupBox Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,5,5.2,5.4" HorizontalAlignment="Stretch" Header="Settings"/>
+        <GroupBox Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,4.6,5.2,4.8" HorizontalAlignment="Stretch" Header="Controls"/>
+        <GroupBox Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,5.2,5.2,4.8" HorizontalAlignment="Stretch" Header="Status"/>
+
+        <Grid Grid.Row="1" Grid.Column="0" Margin="15,25,15.2,10.4" Grid.ColumnSpan="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="2.5*"/>
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition/>
+                <RowDefinition/>
+                <RowDefinition/>
+                <RowDefinition/>
+                <RowDefinition/>
+                <RowDefinition/>
+            </Grid.RowDefinitions>
+
+            <Label 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" SelectionChanged="SystemTypeComboBoxSelectionChanged">
+                <ComboBox.ItemTemplate>
+                    <DataTemplate>
+                        <TextBlock Text="{Binding Path=Name}" Foreground="{Binding Path=Foreground}" />
+                    </DataTemplate>
+                </ComboBox.ItemTemplate>
+            </ComboBox>
+            <ComboBox x:Name="MediaTypeComboBox" Grid.Row="0" Grid.Column="1" Height="22" Width="140" HorizontalAlignment="Right" SelectionChanged="MediaTypeComboBoxSelectionChanged">
+                <ComboBox.ItemTemplate>
+                    <DataTemplate>
+                        <TextBlock Text="{Binding Converter={StaticResource enumConverter}}" />
+                    </DataTemplate>
+                </ComboBox.ItemTemplate>
+            </ComboBox>
+
+            <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center">Output Filename</Label>
+            <TextBox x:Name="OutputFilenameTextBox" Grid.Row="1" Grid.Column="1" Height="22" TextChanged="OutputFilenameTextBoxTextChanged" />
+
+            <Label Grid.Row="2" Grid.Column="0" VerticalAlignment="Center">Output Directory</Label>
+            <TextBox x:Name="OutputDirectoryTextBox" Grid.Row="2" Grid.Column="1" Height="22" Width="345" HorizontalAlignment="Left" TextChanged="OutputDirectoryTextBoxTextChanged" />
+            <Button x:Name="OutputDirectoryBrowseButton" Grid.Row="2" Grid.Column="1" Height="22" Width="50" HorizontalAlignment="Right" Content="Browse" Click="OutputDirectoryBrowseButtonClick"/>
+
+            <Label Grid.Row="3" Grid.Column="0" VerticalAlignment="Center">Drive Letter</Label>
+            <ComboBox x:Name="DriveLetterComboBox" Grid.Row="3" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="Left" SelectionChanged="DriveLetterComboBoxSelectionChanged">
+                <ComboBox.ItemTemplate>
+                    <DataTemplate>
+                        <TextBlock Text="{Binding Path=Letter}" />
+                    </DataTemplate>
+                </ComboBox.ItemTemplate>
+            </ComboBox>
+
+            <Label Grid.Row="4" Grid.Column="0" VerticalAlignment="Center">Drive Speed</Label>
+            <ComboBox x:Name="DriveSpeedComboBox" Grid.Row="4" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="Left" SelectionChanged="DriveSpeedComboBoxSelectionChanged" />
+
+            <Label Grid.Row="5" Grid.Column="0" VerticalAlignment="Center">Parameters</Label>
+            <TextBox x:Name="ParametersTextBox" Grid.Row="5" Grid.Column="1" Height="22" Width="370" HorizontalAlignment="Left" IsEnabled="False" />
+            <CheckBox x:Name="EnableParametersCheckBox" Grid.Row="5" Grid.Column="1" Height="22" HorizontalAlignment="Right" IsChecked="False" Click="EnableParametersCheckBoxClick" />
+        </Grid>
+
+        <Grid Grid.Row="2" Grid.Column="0" Margin="15,19.6,15.2,9.8" Grid.ColumnSpan="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition/>
+            </Grid.RowDefinitions>
+
+            <Button x:Name="StartStopButton" Grid.Row="0" Grid.Column="0" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Start Dumping" Click="StartStopButtonClick" IsEnabled="False" />
+            <Button x:Name="DiskScanButton" Grid.Row="0" Grid.Column="1" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Scan for disks" Click="DiskScanButtonClick" />
+            <Button x:Name="CopyProtectScanButton" Grid.Row="0" Grid.Column="2" Height="22" Width="125" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Scan for protection" Click="CopyProtectScanButtonClick" />
+            <CheckBox x:Name="EjectWhenDoneCheckBox" Grid.Row="0" Grid.Column="3" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Eject When Done" IsChecked="False" />
+        </Grid>
+
+        <Grid Grid.Row="3" Grid.Column="0" Margin="15,20.2,15.2,9.8" Grid.ColumnSpan="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*"/>
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition/>
+            </Grid.RowDefinitions>
+
+            <Label x:Name="StatusLabel" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Waiting for media..." />
+        </Grid>
+    </Grid>
+</Window>

DICUI/Windows/MainWindow.xaml.cs

@@ -0,0 +1,795 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+using WinForms = System.Windows.Forms;
+using DICUI.Data;
+using DICUI.Utilities;
+using DICUI.Web;
+using Newtonsoft.Json.Linq;
+
+namespace DICUI.Windows
+{
+    public partial class MainWindow : Window
+    {
+        // Private UI-related variables
+        private List<Drive> _drives;
+        private MediaType? _currentMediaType;
+        private List<KnownSystemComboBoxItem> _systems;
+        private List<MediaType?> _mediaTypes;
+        private bool _alreadyShown;
+
+        private DumpEnvironment _env;
+
+        // Option related
+        private UIOptions _uiOptions;
+        private OptionsWindow _optionsWindow;
+
+        // User input related
+        private DiscInformationWindow _discInformationWindow;
+
+        private LogWindow _logWindow;
+
+        public MainWindow()
+        {
+            InitializeComponent();
+
+            // Initializes and load Options object
+            _uiOptions = new UIOptions();
+            ViewModels.OptionsViewModel = new OptionsViewModel(_uiOptions);
+
+            _logWindow = new LogWindow(this);
+            ViewModels.LoggerViewModel.SetWindow(_logWindow);
+
+            // Disable buttons until we load fully
+            StartStopButton.IsEnabled = false;
+            DiskScanButton.IsEnabled = false;
+            CopyProtectScanButton.IsEnabled = false;
+
+            if (_uiOptions.OpenLogWindowAtStartup)
+            {
+                this.WindowStartupLocation = WindowStartupLocation.Manual;
+                double combinedHeight = this.Height + _logWindow.Height + Constants.LogWindowMarginFromMainWindow;
+                Rectangle bounds = GetScaledCoordinates(WinForms.Screen.PrimaryScreen.WorkingArea);
+
+                this.Left = bounds.Left + (bounds.Width - this.Width) / 2;
+                this.Top = bounds.Top + (bounds.Height - combinedHeight) / 2;
+            }
+        }
+
+        #region Events
+
+        protected override void OnContentRendered(EventArgs e)
+        {
+            base.OnContentRendered(e);
+
+            if (_alreadyShown)
+                return;
+
+            _alreadyShown = true;
+
+            if (_uiOptions.OpenLogWindowAtStartup)
+            {
+                //TODO: this should be bound directly to WindowVisible property in two way fashion
+                // we need to study how to properly do it in XAML
+                ShowLogMenuItem.IsChecked = true;
+                ViewModels.LoggerViewModel.WindowVisible = true;
+            }
+
+            // Populate the list of systems
+            StatusLabel.Content = "Creating system list, please wait!";
+            PopulateSystems();
+
+            // Populate the list of drives
+            StatusLabel.Content = "Creating drive list, please wait!";
+            PopulateDrives();
+        }
+
+        private void StartStopButtonClick(object sender, RoutedEventArgs e)
+        {
+            // Dump or stop the dump
+            if ((string)StartStopButton.Content == Constants.StartDumping)
+            {
+                StartDumping();
+            }
+            else if ((string)StartStopButton.Content == Constants.StopDumping)
+            {
+                ViewModels.LoggerViewModel.VerboseLogLn("Canceling dumping process...");
+                _env.CancelDumping();
+                CopyProtectScanButton.IsEnabled = true;
+
+                if (EjectWhenDoneCheckBox.IsChecked == true)
+                {
+                    ViewModels.LoggerViewModel.VerboseLogLn($"Ejecting disc in drive {_env.Drive.Letter}");
+                    _env.EjectDisc();
+                }
+
+                if (_uiOptions.ResetDriveAfterDump)
+                {
+                    ViewModels.LoggerViewModel.VerboseLogLn($"Resetting drive {_env.Drive.Letter}");
+                    _env.ResetDrive();
+                }
+            }
+        }
+
+        private void OutputDirectoryBrowseButtonClick(object sender, RoutedEventArgs e)
+        {
+            BrowseFolder();
+            EnsureDiscInformation();
+        }
+
+        private void DiskScanButtonClick(object sender, RoutedEventArgs e)
+        {
+            PopulateDrives();
+        }
+
+        private void CopyProtectScanButtonClick(object sender, RoutedEventArgs e)
+        {
+            ScanAndShowProtection();
+        }
+
+        private void SystemTypeComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            // If we're on a separator, go to the next item and return
+            if ((SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem).IsHeader())
+            {
+                SystemTypeComboBox.SelectedIndex++;
+                return;
+            }
+
+            ViewModels.LoggerViewModel.VerboseLogLn("Changed system to: {0}", (SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem).Name);
+            PopulateMediaType();
+            GetOutputNames(false);
+            EnsureDiscInformation();
+        }
+
+        private void MediaTypeComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            // Only change the media type if the selection and not the list has changed
+            if (e.RemovedItems.Count == 1 && e.AddedItems.Count == 1)
+            {
+                _currentMediaType = MediaTypeComboBox.SelectedItem as MediaType?;
+                SetSupportedDriveSpeed();
+            }
+
+            GetOutputNames(false);
+            EnsureDiscInformation();
+        }
+
+        private void DriveLetterComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            CacheCurrentDiscType();
+            SetCurrentDiscType();
+            GetOutputNames(true);
+            SetSupportedDriveSpeed();
+        }
+
+        private void DriveSpeedComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            EnsureDiscInformation();
+        }
+
+        private void OutputFilenameTextBoxTextChanged(object sender, TextChangedEventArgs e)
+        {
+            EnsureDiscInformation();
+        }
+
+        private void OutputDirectoryTextBoxTextChanged(object sender, TextChangedEventArgs e)
+        {
+            EnsureDiscInformation();
+        }
+
+        private void ProgressUpdated(object sender, Result value)
+        {
+            StatusLabel.Content = value.Message;
+            ViewModels.LoggerViewModel.VerboseLogLn(value.Message);
+        }
+
+        private void MainWindowLocationChanged(object sender, EventArgs e)
+        {
+            if (_logWindow.IsVisible)
+                _logWindow.AdjustPositionToMainWindow();
+        }
+
+        private void MainWindowActivated(object sender, EventArgs e)
+        {
+            if (_logWindow.IsVisible && !this.Topmost)
+            {
+                _logWindow.Topmost = true;
+                _logWindow.Topmost = false;
+            }
+        }
+
+        private void MainWindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            if (_logWindow.IsVisible)
+                _logWindow.Close();
+        }
+
+        private void EnableParametersCheckBoxClick(object sender, RoutedEventArgs e)
+        {
+            if (EnableParametersCheckBox.IsChecked == true)
+                ParametersTextBox.IsEnabled = true;
+            else
+            {
+                ParametersTextBox.IsEnabled = false;
+                ProcessCustomParameters();
+            }
+        }
+
+        // Toolbar Events
+
+        private void AppExitClick(object sender, RoutedEventArgs e)
+        {
+            Application.Current.Shutdown();
+        }
+
+        private void AboutClick(object sender, RoutedEventArgs e)
+        {
+            MessageBox.Show($"darksabre76 - Project Lead / Backend Design"
+                + $"{Environment.NewLine}ReignStumble - Former Project Lead / UI Design"
+                + $"{Environment.NewLine}Jakz - Primary Feature Contributor"
+                + $"{Environment.NewLine}NHellFire - Feature Contributor", "About", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+
+        private void OptionsClick(object sender, RoutedEventArgs e)
+        {
+            // lazy initialization
+            if (_optionsWindow == null)
+            {
+                _optionsWindow = new OptionsWindow(this, _uiOptions);
+                _optionsWindow.Closed += delegate
+                {
+                    _optionsWindow = null;
+                };
+            }
+
+            _optionsWindow.Owner = this;
+            _optionsWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
+            _optionsWindow.Refresh();
+            _optionsWindow.Show();
+        }
+
+        private void CheckForUpdatesClick(object sender, RoutedEventArgs e)
+        {
+            // Get the current internal version
+            var assemblyVersion = Assembly.GetEntryAssembly().GetName().Version;
+            string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}" + (assemblyVersion.MajorRevision != 0 ? $".{assemblyVersion.MajorRevision}" : string.Empty);
+
+            // Get the latest tag from GitHub
+            using (var client = new CookieAwareWebClient())
+            {
+                client.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/DICUI/releases/latest";
+                string latestReleaseJsonString = client.DownloadString(url);
+                var latestReleaseJson = JObject.Parse(latestReleaseJsonString);
+                string latestTag = latestReleaseJson["tag_name"].ToString();
+                string releaseUrl = latestReleaseJson["html_url"].ToString();
+
+                bool different = version != latestTag;
+
+                string message = $"Local version: {version}"
+                    + $"{Environment.NewLine}Remote version: {latestTag}"
+                    + (different
+                        ? $"{Environment.NewLine}The update URL has been added copied to your clipboard"
+                        : $"{Environment.NewLine}You have the newest version!");
+
+                // If we have a new version, put it in the clipboard
+                if (different)
+                    Clipboard.SetText(releaseUrl);
+
+                MessageBox.Show(message, "Version Update Check", MessageBoxButton.OK, different ? MessageBoxImage.Exclamation : MessageBoxImage.Information);
+            }
+        }
+
+        public void OnOptionsUpdated()
+        {
+            PopulateDrives();
+            GetOutputNames(false);
+            SetSupportedDriveSpeed();
+            EnsureDiscInformation();
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Populate media type according to system type
+        /// </summary>
+        private void PopulateMediaType()
+        {
+            KnownSystem? currentSystem = SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem;
+
+            if (currentSystem != null)
+            {
+                _mediaTypes = Validators.GetValidMediaTypes(currentSystem);
+                MediaTypeComboBox.ItemsSource = _mediaTypes;
+
+                MediaTypeComboBox.IsEnabled = _mediaTypes.Count > 1;
+                MediaTypeComboBox.SelectedIndex = (_mediaTypes.IndexOf(_currentMediaType) >= 0 ? _mediaTypes.IndexOf(_currentMediaType) : 0);
+            }
+            else
+            {
+                MediaTypeComboBox.IsEnabled = false;
+                MediaTypeComboBox.ItemsSource = null;
+                MediaTypeComboBox.SelectedIndex = -1;
+            }
+        }
+
+        /// <summary>
+        /// Get a complete list of supported systems and fill the combo box
+        /// </summary>
+        private void PopulateSystems()
+        {
+            var knownSystems = Validators.CreateListOfSystems();
+
+            ViewModels.LoggerViewModel.VerboseLogLn("Populating systems, {0} systems found.", knownSystems.Count);
+
+            Dictionary<KnownSystemCategory, List<KnownSystem?>> mapping = knownSystems
+                .GroupBy(s => s.Category())
+                .ToDictionary(
+                    k => k.Key,
+                    v => v
+                        .OrderBy(s => s.LongName())
+                        .ToList()
+                );
+
+            _systems = new List<KnownSystemComboBoxItem>();
+            _systems.Add(new KnownSystemComboBoxItem(KnownSystem.NONE));
+
+            foreach (var group in mapping)
+            {
+                _systems.Add(new KnownSystemComboBoxItem(group.Key));
+                group.Value.ForEach(system => _systems.Add(new KnownSystemComboBoxItem(system)));
+            }
+
+            SystemTypeComboBox.ItemsSource = _systems;
+            SystemTypeComboBox.SelectedIndex = 0;
+
+            StartStopButton.IsEnabled = false;
+        }
+
+        /// <summary>
+        /// Get a complete list of active disc drives and fill the combo box
+        /// </summary>
+        /// <remarks>TODO: Find a way for this to periodically run, or have it hook to a "drive change" event</remarks>
+        private void PopulateDrives()
+        {
+            ViewModels.LoggerViewModel.VerboseLogLn("Scanning for drives..");
+
+            // Always enable the disk scan
+            DiskScanButton.IsEnabled = true;
+
+            // Populate the list of drives and add it to the combo box
+            _drives = Validators.CreateListOfDrives(_uiOptions.IgnoreFixedDrives);
+            DriveLetterComboBox.ItemsSource = _drives;
+
+            if (DriveLetterComboBox.Items.Count > 0)
+            {
+                // Check for active optical drives first
+                int index = _drives.FindIndex(d => d.MarkedActive && d.InternalDriveType == InternalDriveType.Optical);
+
+                // Then we check for floppy drives
+                if (index == -1)
+                    index = _drives.FindIndex(d => d.MarkedActive && d.InternalDriveType == InternalDriveType.Floppy);
+
+                // Then we try all other drive types
+                if (index == -1)
+                    index = _drives.FindIndex(d => d.MarkedActive);
+
+                // Set the selected index
+                DriveLetterComboBox.SelectedIndex = (index != -1 ? index : 0);
+                StatusLabel.Content = "Valid drive found! Choose your Media Type";
+                                CopyProtectScanButton.IsEnabled = true;
+
+                // Get the current media type
+                if (!_uiOptions.SkipSystemDetection && index != -1)
+                {
+                    ViewModels.LoggerViewModel.VerboseLog("Trying to detect system for drive {0}.. ", _drives[index].Letter);
+                    var currentSystem = Validators.GetKnownSystem(_drives[index]);
+                    ViewModels.LoggerViewModel.VerboseLogLn(currentSystem == null || currentSystem == KnownSystem.NONE ? "unable to detect." : ("detected " + currentSystem.LongName() + "."));
+
+                    if (currentSystem != null && currentSystem != KnownSystem.NONE)
+                    {
+                        int sysIndex = _systems.FindIndex(s => s == currentSystem);
+                        SystemTypeComboBox.SelectedIndex = sysIndex;
+                    }
+                }
+
+                // Only enable the start/stop if we don't have the default selected
+                StartStopButton.IsEnabled = (SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem) != KnownSystem.NONE;
+
+                ViewModels.LoggerViewModel.VerboseLogLn("Found {0} drives: {1}", _drives.Count, string.Join(", ", _drives.Select(d => d.Letter)));
+            }
+            else
+            {
+                DriveLetterComboBox.SelectedIndex = -1;
+                StatusLabel.Content = "No valid drive found!";
+                StartStopButton.IsEnabled = false;
+                CopyProtectScanButton.IsEnabled = false;
+
+                ViewModels.LoggerViewModel.VerboseLogLn("Found no drives");
+            }
+        }
+
+        /// <summary>
+        /// Browse for an output folder
+        /// </summary>
+        private void BrowseFolder()
+        {
+            WinForms.FolderBrowserDialog folderDialog = new WinForms.FolderBrowserDialog { ShowNewFolderButton = false, SelectedPath = System.AppDomain.CurrentDomain.BaseDirectory };
+            WinForms.DialogResult result = folderDialog.ShowDialog();
+
+            if (result == WinForms.DialogResult.OK)
+            {
+                OutputDirectoryTextBox.Text = folderDialog.SelectedPath;
+            }
+        }
+
+        /// <summary>
+        /// Create a DumpEnvironment with all current settings
+        /// </summary>
+        /// <returns>Filled DumpEnvironment instance</returns>
+        private DumpEnvironment DetermineEnvironment()
+        {
+            // Populate the new environment
+            var env = new DumpEnvironment(_uiOptions.Options,
+                OutputDirectoryTextBox.Text,
+                OutputFilenameTextBox.Text,
+                DriveLetterComboBox.SelectedItem as Drive,
+                SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem,
+                MediaTypeComboBox.SelectedItem as MediaType?,
+                ParametersTextBox.Text);
+
+            // Disable automatic reprocessing of the textboxes until we're done
+            OutputDirectoryTextBox.TextChanged -= OutputDirectoryTextBoxTextChanged;
+            OutputFilenameTextBox.TextChanged -= OutputFilenameTextBoxTextChanged;
+
+            OutputDirectoryTextBox.Text = env.OutputDirectory;
+            OutputFilenameTextBox.Text = env.OutputFilename;
+
+            OutputDirectoryTextBox.TextChanged += OutputDirectoryTextBoxTextChanged;
+            OutputFilenameTextBox.TextChanged += OutputFilenameTextBoxTextChanged;
+
+            return env;
+        }
+
+        /// <summary>
+        /// Begin the dumping process using the given inputs
+        /// </summary>
+        private async void StartDumping()
+        {
+            // One last check to determine environment, just in case
+            _env = DetermineEnvironment();
+
+            // If still in custom parameter mode, check that users meant to continue or not
+            if (EnableParametersCheckBox.IsChecked == true)
+            {
+                MessageBoxResult result = MessageBox.Show("It looks like you have custom parameters that have not been saved. Would you like to apply those changes before starting to dump?", "Custom Changes", MessageBoxButton.YesNoCancel, MessageBoxImage.Question);
+                if (result == MessageBoxResult.Yes)
+                {
+                    EnableParametersCheckBox.IsChecked = false;
+                    ParametersTextBox.IsEnabled = false;
+                    ProcessCustomParameters();
+                }
+                else if (result == MessageBoxResult.Cancel)
+                    return;
+                // If "No", then we continue with the current known environment
+            }
+
+            // Fix the output paths
+            _env.FixOutputPaths();
+
+            try
+            {
+                // Validate that the user explicitly wants an inactive drive to be considered for dumping
+                if (!_env.Drive.MarkedActive)
+                {
+                    MessageBoxResult mbresult = MessageBox.Show("The currently selected drive does not appear to contain a disc! Are you sure you want to continue?", "Missing Disc", MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
+                    if (mbresult == MessageBoxResult.No || mbresult == MessageBoxResult.Cancel || mbresult == MessageBoxResult.None)
+                    {
+                        ViewModels.LoggerViewModel.VerboseLogLn("Dumping aborted!");
+                        return;
+                    }
+                }
+
+                // If a complete dump already exists
+                if (_env.FoundAllFiles())
+                {
+                    MessageBoxResult mbresult = MessageBox.Show("A complete dump already exists! Are you sure you want to overwrite?", "Overwrite?", MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
+                    if (mbresult == MessageBoxResult.No || mbresult == MessageBoxResult.Cancel || mbresult == MessageBoxResult.None)
+                    {
+                        ViewModels.LoggerViewModel.VerboseLogLn("Dumping aborted!");
+                        return;
+                    }
+                }
+
+                StartStopButton.Content = Constants.StopDumping;
+                CopyProtectScanButton.IsEnabled = false;
+                StatusLabel.Content = "Beginning dumping process";
+                ViewModels.LoggerViewModel.VerboseLogLn("Starting dumping process..");
+
+                var progress = new Progress<Result>();
+                progress.ProgressChanged += ProgressUpdated;
+                Result result = await _env.Run(progress);
+
+                // If we didn't execute a dumping command we cannot get submission output
+                if (!_env.Parameters.IsDumpingCommand())
+                {
+                    ViewModels.LoggerViewModel.VerboseLogLn("No dumping command was run, submission information will not be gathered.");
+                    StatusLabel.Content = "Execution complete!";
+                    StartStopButton.Content = Constants.StartDumping;
+                    CopyProtectScanButton.IsEnabled = true;
+                    return;
+                }
+
+                if (result)
+                {
+                    // Verify dump output and save it
+                    result = _env.VerifyAndSaveDumpOutput(progress,
+                        EjectWhenDoneCheckBox.IsChecked,
+                        _uiOptions.ResetDriveAfterDump,
+                        (si) =>
+                        {
+                            // lazy initialization
+                            if (_discInformationWindow == null)
+                            {
+                                _discInformationWindow = new DiscInformationWindow(this, si);
+                                _discInformationWindow.Closed += delegate
+                                {
+                                    _discInformationWindow = null;
+                                };
+                            }
+
+                            _discInformationWindow.Owner = this;
+                            _discInformationWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
+                            _discInformationWindow.Refresh();
+                            return _discInformationWindow.ShowDialog();
+                        }
+                    );
+                }
+
+                StatusLabel.Content = result ? "Dumping complete!" : result.Message;
+                ViewModels.LoggerViewModel.VerboseLogLn(result ? "Dumping complete!" : result.Message);
+            }
+            catch
+            {
+                // No-op, we don't care what it was
+            }
+            finally
+            {
+                StartStopButton.Content = Constants.StartDumping;
+                CopyProtectScanButton.IsEnabled = true;
+            }
+        }
+
+        /// <summary>
+        /// Ensure information is consistent with the currently selected disc type
+        /// </summary>
+        private void EnsureDiscInformation()
+        {
+            // Get the current environment information
+            _env = DetermineEnvironment();
+
+            // Take care of null cases
+            if (_env.System == null)
+                _env.System = KnownSystem.NONE;
+            if (_env.Type == null)
+                _env.Type = MediaType.NONE;
+
+            // Get the status to write out
+            Result result = Validators.GetSupportStatus(_env.System, _env.Type);
+            StatusLabel.Content = result.Message;
+
+            // Set the index for the current disc type
+            SetCurrentDiscType();
+
+            StartStopButton.IsEnabled = result && (_drives != null && _drives.Count > 0 ? true : false);
+
+            // If we're in a type that doesn't support drive speeds
+            DriveSpeedComboBox.IsEnabled = _env.Type.DoesSupportDriveSpeed();
+
+            // If input params are not enabled, generate the full parameters from the environment
+            if (!ParametersTextBox.IsEnabled)
+            {
+                string generated = _env.GetFullParameters((int?)DriveSpeedComboBox.SelectedItem);
+                if (generated != null)
+                    ParametersTextBox.Text = generated;
+            }
+        }
+
+        /// <summary>
+        /// Get the default output directory name from the currently selected drive
+        /// </summary>
+        /// <param name="driveChanged">Force an updated name if the drive letter changes</param>
+        private void GetOutputNames(bool driveChanged)
+        {
+            Drive drive = DriveLetterComboBox.SelectedItem as Drive;
+            KnownSystem? systemType = SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem;
+            MediaType? mediaType = MediaTypeComboBox.SelectedItem as MediaType?;
+
+            // Set the output directory, if we changed drives or it's not already
+            if (driveChanged || string.IsNullOrEmpty(OutputDirectoryTextBox.Text))
+                OutputDirectoryTextBox.Text = Path.Combine(_uiOptions.DefaultOutputPath, drive?.VolumeLabel ?? string.Empty);
+
+            // Get the extension for the file for the next two statements
+            string extension = _env.GetExtension(mediaType);
+
+            // Set the output filename, if we changed drives or it's not already
+            if (driveChanged || string.IsNullOrEmpty(OutputFilenameTextBox.Text))
+                OutputFilenameTextBox.Text = (drive?.VolumeLabel ?? systemType.LongName()) + (extension ?? ".bin");
+
+            // If the extension for the file changed, update that automatically
+            else if (Path.GetExtension(OutputFilenameTextBox.Text) != extension)
+                OutputFilenameTextBox.Text = Path.GetFileNameWithoutExtension(OutputFilenameTextBox.Text) + (extension ?? ".bin");
+        }
+
+        /// <summary>
+        /// Scan and show copy protection for the current disc
+        /// </summary>
+        private async void ScanAndShowProtection()
+        {
+            if (_env == null)
+                _env = DetermineEnvironment();
+
+            if (_env.Drive.Letter != default(char))
+            {
+                ViewModels.LoggerViewModel.VerboseLogLn("Scanning for copy protection in {0}", _env.Drive.Letter);
+
+                var tempContent = StatusLabel.Content;
+                StatusLabel.Content = "Scanning for copy protection... this might take a while!";
+                StartStopButton.IsEnabled = false;
+                DiskScanButton.IsEnabled = false;
+                CopyProtectScanButton.IsEnabled = false;
+
+                string protections = await Validators.RunProtectionScanOnPath(_env.Drive.Letter + ":\\");
+
+                // If SmartE is detected on the current disc, remove `/sf` from the flags for DIC only
+                if (_env.InternalProgram == InternalProgram.DiscImageCreator && protections.Contains("SmartE"))
+                {
+                    ((DiscImageCreator.Parameters)_env.Parameters)[DiscImageCreator.Flag.ScanFileProtect] = false;
+                    ViewModels.LoggerViewModel.VerboseLogLn($"SmartE detected, removing {DiscImageCreator.FlagStrings.ScanFileProtect} from parameters");
+                }
+
+                if (!ViewModels.LoggerViewModel.WindowVisible)
+                    MessageBox.Show(protections, "Detected Protection", MessageBoxButton.OK, MessageBoxImage.Information);
+                ViewModels.LoggerViewModel.VerboseLog("Detected the following protections in {0}:\r\n\r\n{1}", _env.Drive.Letter, protections);
+
+                StatusLabel.Content = tempContent;
+                StartStopButton.IsEnabled = true;
+                DiskScanButton.IsEnabled = true;
+                CopyProtectScanButton.IsEnabled = true;
+            }
+        }
+
+        /// <summary>
+        /// Set the drive speed based on reported maximum and user-defined option
+        /// </summary>
+        private void SetSupportedDriveSpeed()
+        {
+            // Set the drive speed list that's appropriate
+            var values = Constants.GetSpeedsForMediaType(_currentMediaType);
+            DriveSpeedComboBox.ItemsSource = values;
+            ViewModels.LoggerViewModel.VerboseLogLn("Supported media speeds: {0}", string.Join(",", values));
+
+            // Set the selected speed
+            int speed = _uiOptions.GetPreferredDumpSpeedForMediaType(_currentMediaType);
+            ViewModels.LoggerViewModel.VerboseLogLn("Setting drive speed to: {0}", speed);
+            DriveSpeedComboBox.SelectedValue = speed;
+        }
+
+        /// <summary>
+        /// Cache the current disc type to internal variable
+        /// </summary>
+        private void CacheCurrentDiscType()
+        {
+            // Get the drive letter from the selected item
+            var drive = DriveLetterComboBox.SelectedItem as Drive;
+            if (drive == null)
+                return;
+
+            // Get the current media type
+            if (!_uiOptions.SkipMediaTypeDetection)
+            {
+                ViewModels.LoggerViewModel.VerboseLog("Trying to detect media type for drive {0}.. ", drive.Letter);
+                _currentMediaType = Validators.GetMediaType(drive);
+                ViewModels.LoggerViewModel.VerboseLogLn(_currentMediaType == null ? "unable to detect." : ("detected " + _currentMediaType.LongName() + "."));
+            }
+        }
+
+        /// <summary>
+        /// Set the current disc type in the combo box
+        /// </summary>
+        private void SetCurrentDiscType()
+        {
+            // If we have an invalid current type, we don't care and return
+            if (_currentMediaType == null || _currentMediaType == MediaType.NONE)
+                return;
+
+            // Now set the selected item, if possible
+            int index = _mediaTypes.FindIndex(kvp => kvp.Value == _currentMediaType);
+            if (index != -1)
+                MediaTypeComboBox.SelectedIndex = index;
+            else
+                StatusLabel.Content = $"Disc of type '{Converters.LongName(_currentMediaType)}' found, but the current system does not support it!";
+        }
+
+        /// <summary>
+        /// Process the current custom parameters back into UI values
+        /// </summary>
+        private void ProcessCustomParameters()
+        {
+            _env.SetParameters(ParametersTextBox.Text);
+            if (_env.Parameters == null)
+                return;
+
+            int driveIndex = _drives.Select(d => d.Letter).ToList().IndexOf(_env.Parameters.InputPath()[0]);
+            if (driveIndex > -1)
+                DriveLetterComboBox.SelectedIndex = driveIndex;
+
+            int driveSpeed = _env.Parameters.GetSpeed() ?? -1;
+            if (driveSpeed > 0)
+                DriveSpeedComboBox.SelectedValue = driveSpeed;
+            else
+                _env.Parameters.SetSpeed((int?)DriveSpeedComboBox.SelectedValue);
+
+            string trimmedPath = _env.Parameters.OutputPath()?.Trim('"') ?? string.Empty;
+            string outputDirectory = Path.GetDirectoryName(trimmedPath);
+            string outputFilename = Path.GetFileName(trimmedPath);
+            if (!string.IsNullOrWhiteSpace(outputDirectory))
+                OutputDirectoryTextBox.Text = outputDirectory;
+            else
+                outputDirectory = OutputDirectoryTextBox.Text;
+            if (!string.IsNullOrWhiteSpace(outputFilename))
+                OutputFilenameTextBox.Text = outputFilename;
+            else
+                outputFilename = OutputFilenameTextBox.Text;
+
+            MediaType? mediaType = _env.Parameters.GetMediaType();
+            int mediaTypeIndex = _mediaTypes.IndexOf(mediaType);
+            if (mediaTypeIndex > -1)
+                MediaTypeComboBox.SelectedIndex = mediaTypeIndex;
+        }
+
+        #endregion
+
+        #region UI Helpers
+
+        /// <summary>
+        /// Get pixel coordinates based on DPI scaling
+        /// </summary>
+        /// <param name="bounds">Rectangle representing the bounds to transform</param>
+        /// <returns>Rectangle representing the scaled bounds</returns>
+        private Rectangle GetScaledCoordinates(Rectangle bounds)
+        {
+            using (Graphics g = Graphics.FromHwnd(IntPtr.Zero))
+            {
+                return new Rectangle(
+                TransformCoordinate(bounds.Left, g.DpiX),
+                TransformCoordinate(bounds.Top, g.DpiY),
+                TransformCoordinate(bounds.Width, g.DpiX),
+                TransformCoordinate(bounds.Height, g.DpiY));
+            }
+        }
+
+        /// <summary>
+        /// Transform an individual coordinate using DPI scaling
+        /// </summary>
+        /// <param name="coord">Current integer coordinate</param>
+        /// <param name="dpi">DPI scaling factor</param>
+        /// <returns>Scaled integer coordinate</returns>
+        private int TransformCoordinate(int coord, float dpi)
+        {
+            return (int)(coord / ((double)dpi / 96));
+        }
+
+        #endregion
+    }
+}

DICUI/Windows/OptionsWindow.xaml

@@ -0,0 +1,221 @@
+<Window x:Class="DICUI.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:local="clr-namespace:DICUI"
+        mc:Ignorable="d"
+        Title="Options" Width="515.132" Height="605">
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="150"/>
+            <RowDefinition Height="150"/>
+            <RowDefinition Height="150"/>
+            <RowDefinition Height="80"/>
+            <RowDefinition Height="40"/>
+        </Grid.RowDefinitions>
+
+        <GroupBox Grid.Column="0" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Paths" />
+
+        <Grid Margin="10,15,10,10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*" />
+                <ColumnDefinition Width="2.0*" />
+                <ColumnDefinition Width="0.2*" />
+
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <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"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=AaruPath}" />
+            <Button x:Name="AaruPathButton" Grid.Row="0" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick" />
+
+            <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="DiscImageCreator Path" />
+            <TextBox x:Name="CreatorPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=CreatorPath}" />
+            <Button x:Name="CreatorPathButton" Grid.Row="1" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick" />
+
+            <!--
+            <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="DD Path" />
+            <TextBox x:Name="DDPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=DDPath}" />
+            <Button x:Name="DDPathButton" Grid.Row="1" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick" />
+            -->
+
+            <Label Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="subdump Path" />
+            <TextBox x:Name="SubDumpPathTextBox" Grid.Row="2" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=SubDumpPath}" />
+            <Button x:Name="SubDumpPathButton" Grid.Row="2" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick"/>
+
+            <Label Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Default Output Path" />
+            <TextBox x:Name="DefaultOutputPathTextBox" Grid.Row="3" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=DefaultOutputPath}" />
+            <Button x:Name="DefaultOutputPathButton" Grid.Row="3" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick" />
+        </Grid>
+
+        <GroupBox Grid.Row="1" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Preferred Dump Speed">
+            <Grid Height="100">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="80"/>
+                    <ColumnDefinition Width="2.0*"/>
+                    <ColumnDefinition Width="40"/>
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition />
+                    <RowDefinition />
+                    <RowDefinition />
+                </Grid.RowDefinitions>
+
+                <Label Grid.Row="0" Grid.Column="0" Content="CD-ROM" />
+                <Slider x:Name="DumpSpeedCDSlider" Grid.Row="0" Grid.Column="1" Minimum="1" Maximum="72" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                        Ticks="{Binding Source={x:Static local:Constants.SpeedsForCDAsCollection}}"
+                        DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                        Value="{Binding Path=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-ROM" />
+                <Slider x:Name="DumpSpeedDVDSlider" Grid.Row="1" Grid.Column="1" Minimum="1" Maximum="24" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                        Ticks="{Binding Source={x:Static local:Constants.SpeedsForDVDAsCollection}}"
+                        DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                        Value="{Binding Path=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="BD-ROM" />
+                <Slider x:Name="DumpSpeedBDSlider" Grid.Row="2" Grid.Column="1" Minimum="1" Maximum="16" IsSnapToTickEnabled="True" TickPlacement="BottomRight"
+                        Ticks="{Binding Source={x:Static local:Constants.SpeedsForBDAsCollection}}"
+                        DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                        Value="{Binding Path=PreferredDumpSpeedBD}"  />
+                <TextBox x:Name="DumpSpeedBDTextBox" Grid.Row="2" 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>
+
+        <GroupBox Grid.Row="2" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Options" Padding="10">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition />
+                    <RowDefinition />
+                    <RowDefinition />
+                </Grid.RowDefinitions>
+
+                <CheckBox Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Content="Quiet Mode"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=QuietMode}"
+                          ToolTip="Disable DiscImageCreator sounds" Margin="0,4"
+                          />
+
+                <CheckBox Grid.Row="0" Grid.Column="1" VerticalAlignment="Center" Content="Paranoid Mode"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=ParanoidMode}"
+                          ToolTip="Enable pedantic and super-safe flags" Margin="0,4"
+                          />
+
+                <Label Grid.Row="0" Grid.Column="2" Content="Reread Tries:" VerticalAlignment="Center" HorizontalAlignment="Right"/>
+                <TextBox Grid.Row="0" Grid.Column="3" VerticalAlignment="Center"
+                             DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                             Text="{Binding Path=RereadAmountForC2}"
+                             ToolTip="Specifies how many rereads are attempted on C2 error"
+                             />
+
+                <CheckBox Grid.Column="0" Grid.Row="1" VerticalAlignment="Center" Content="Protection Scan"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=ScanForProtection}"
+                          ToolTip="Enable automatic checking for copy protection on dumped media" Margin="0,4,0,0"
+                          />
+
+                <CheckBox Grid.Column="1" Grid.Row="1" VerticalAlignment="Center" Content="Skip Type Detect"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=SkipMediaTypeDetection}"
+                          ToolTip="Disable trying to guess media type inserted (may improve performance at startup)" Margin="0,4"
+                          />
+
+                <CheckBox Grid.Row="1" Grid.Column="2" VerticalAlignment="Center" Content="Add Placeholders"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=AddPlaceholders}"
+                          ToolTip="Enable adding placeholder text in the submissioninfo output for required and optional fields" Margin="0,4"
+                          />
+
+                <CheckBox Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Content="Show Disc Info"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=PromptForDiscInformation}"
+                          ToolTip="Enable showing the disc information output after dumping" Margin="0,4"
+                          />
+
+                <CheckBox Grid.Row="2" Grid.Column="1" VerticalAlignment="Center" Content="No Fixed Drives"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=IgnoreFixedDrives}"
+                          ToolTip="Ignore hard drives and other fixed drives" Margin="0,4"
+                          />
+
+                <CheckBox Grid.Row="2" Grid.Column="2" VerticalAlignment="Center" Content="Reset After Dump"
+                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                          IsChecked="{Binding Path=ResetDriveAfterDump}"
+                          ToolTip="Reset disc drives after dumping; useful for some older machines" Margin="0,4"
+                          />
+            </Grid>
+
+        </GroupBox>
+
+        <GroupBox Grid.Row="3" Margin="5,5,5,5" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Header="Redump Login" Padding="10">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1.2*" />
+                </Grid.ColumnDefinitions>
+
+                <Grid.RowDefinitions>
+                    <RowDefinition />
+                </Grid.RowDefinitions>
+
+                <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Username" />
+                <TextBox x:Name="RedumpUsernameTextBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch"
+                    DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}"
+                    Text="{Binding Path=Username}" />
+
+                <Label Grid.Row="0" Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Password" />
+                <PasswordBox x:Name="RedumpPasswordBox" Grid.Row="0" Grid.Column="3" Height="22" HorizontalAlignment="Stretch" PasswordChar="*" />
+
+                <Button x:Name="RedumpLoginTestButton" Grid.Row="0" Grid.Column="5" Height="22" Width="80" Content="Test Login" Click="OnRedumpTestClick" />
+            </Grid>
+        </GroupBox>
+
+        <Grid Height="22" Grid.Row="4" Grid.Column="0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="2*"/>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="1*"/>
+            </Grid.ColumnDefinitions>
+
+            <Button x:Name="AcceptButton" Grid.Row="0" Grid.Column="1" Height="22" Width="80" Content="Accept" Click="OnAcceptClick" />
+            <Button x:Name="CancelButton" Grid.Row="0" Grid.Column="2" Height="22" Width="80" Content="Cancel" Click="OnCancelClick" />
+
+        </Grid>
+    </Grid>
+</Window>

DICUI/Windows/OptionsWindow.xaml.cs

@@ -0,0 +1,138 @@
+using System;
+using System.IO;
+using System.Windows;
+using System.Windows.Forms;
+using DICUI.Web;
+using Button = System.Windows.Controls.Button;
+using TextBox = System.Windows.Controls.TextBox;
+
+namespace DICUI.Windows
+{
+    /// <summary>
+    /// Interaction logic for OptionsWindow.xaml
+    /// </summary>
+    public partial class OptionsWindow : Window
+    {
+        private readonly MainWindow _mainWindow;
+        private readonly UIOptions _uiOptions;
+
+        public OptionsWindow(MainWindow mainWindow, UIOptions options)
+        {
+            InitializeComponent();
+            _mainWindow = mainWindow;
+            _uiOptions = options;
+        }
+
+        private OpenFileDialog CreateOpenFileDialog()
+        {
+            OpenFileDialog dialog = new OpenFileDialog();
+
+            dialog.InitialDirectory = AppDomain.CurrentDomain.BaseDirectory;
+            dialog.Filter = "Executables (*.exe)|*.exe";
+            dialog.FilterIndex = 0;
+            dialog.RestoreDirectory = true;
+
+            return dialog;
+        }
+
+        private FolderBrowserDialog CreateFolderBrowserDialog()
+        {
+            FolderBrowserDialog dialog = new FolderBrowserDialog();
+            return dialog;
+        }
+
+        private TextBox TextBoxForPathSetting(string name)
+        {
+            return FindName(name + "TextBox") as TextBox;
+        }
+
+        private void BrowseForPathClick(object sender, EventArgs e)
+        {
+            Button button = sender as Button;
+            // strips button prefix to obtain the setting name
+            string pathSettingName = button.Name.Substring(0, button.Name.IndexOf("Button"));
+
+            // TODO: hack for now, then we'll see
+            bool shouldBrowseForPath = pathSettingName == "DefaultOutputPath";
+
+            CommonDialog dialog = shouldBrowseForPath ? (CommonDialog)CreateFolderBrowserDialog() : CreateOpenFileDialog();
+            using (dialog)
+            {
+                DialogResult result = dialog.ShowDialog();
+
+                if (result == System.Windows.Forms.DialogResult.OK)
+                {
+                    string path;
+                    bool exists;
+
+                    if (shouldBrowseForPath)
+                    {
+                        path = (dialog as FolderBrowserDialog).SelectedPath;
+                        exists = Directory.Exists(path);
+                    }
+                    else
+                    {
+                        path = (dialog as OpenFileDialog).FileName;
+                        exists = File.Exists(path);
+                    }
+
+                    if (exists)
+                    {
+                        TextBoxForPathSetting(pathSettingName).Text = path;
+                    }
+                    else
+                    {
+                        System.Windows.MessageBox.Show(
+                            "Specified path doesn't exists!",
+                            "Error",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Error
+                        );
+                    }
+                }
+            }
+        }
+
+        public void Refresh()
+        {
+            // Handle non-bindable fields
+            RedumpPasswordBox.Password = _uiOptions.Options.Password;
+        }
+
+        #region Event Handlers
+
+        private void OnAcceptClick(object sender, EventArgs e)
+        {
+            // Handle non-bindable fields
+            _uiOptions.Options.Password = RedumpPasswordBox.Password;
+
+            _uiOptions.Save();
+            Hide();
+
+            _mainWindow.OnOptionsUpdated();
+        }
+
+        private void OnCancelClick(object sender, EventArgs e)
+        {
+            // just hide the window and don't care
+            Hide();
+        }
+
+        /// <summary>
+        /// Test Redump credentials for validity
+        /// </summary>
+        private void OnRedumpTestClick(object sender, EventArgs e)
+        {
+            using (CookieAwareWebClient wc = new CookieAwareWebClient())
+            {
+                RedumpAccess access = new RedumpAccess();
+                if (access.RedumpLogin(wc, RedumpUsernameTextBox.Text, RedumpPasswordBox.Password))
+                    System.Windows.MessageBox.Show("Redump login credentials accepted!", "Success", MessageBoxButton.OK, MessageBoxImage.Information);
+                else
+                    System.Windows.MessageBox.Show("Redump login credentials denied!", "Failure", MessageBoxButton.OK, MessageBoxImage.Error);
+            }
+        }
+
+        #endregion
+    }
+}

MainWindow.xaml

@@ -1,133 +0,0 @@
-<Window x:Class="DICUI.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:local="clr-namespace:DICUI"
-        mc:Ignorable="d"
-        Title="Disc Image Creator GUI" Height="400" Width="600">
-
-    <Grid>
-        <Grid.ColumnDefinitions>
-            <ColumnDefinition Width="4*"/>
-            <ColumnDefinition Width="13*"/>
-        </Grid.ColumnDefinitions>
-        <Grid.RowDefinitions>
-            <RowDefinition Height="4*"/>
-            <RowDefinition Height="1*"/>
-            <RowDefinition Height="1*"/>
-        </Grid.RowDefinitions>
-
-        <GroupBox Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,5,5.2,5.4" HorizontalAlignment="Stretch" Header="Settings"/>
-        <GroupBox Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,4.6,5.2,4.8" HorizontalAlignment="Stretch" Header="Controls"/>
-        <GroupBox Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,5.2,5.2,4.8" HorizontalAlignment="Stretch" Header="Status"/>
-
-        <Grid Grid.Row="0" Grid.Column="0" Margin="15,25,15.2,10.4" Grid.ColumnSpan="2">
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="1*"/>
-                <ColumnDefinition Width="2.5*"/>
-            </Grid.ColumnDefinitions>
-            <Grid.RowDefinitions>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-                <RowDefinition/>
-            </Grid.RowDefinitions>
-
-            <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center">Disc Type</Label>
-            <Label Grid.Row="1" Grid.Column="0" VerticalAlignment="Center">DiscImageCreator Path</Label>
-            <Label Grid.Row="2" Grid.Column="0" VerticalAlignment="Center">Output Filename</Label>
-            <Label Grid.Row="3" Grid.Column="0" VerticalAlignment="Center">Output Directory</Label>
-            <Label Grid.Row="4" Grid.Column="0" VerticalAlignment="Center">Drive Letter</Label>
-            <Label Grid.Row="5" Grid.Column="0" VerticalAlignment="Center">Drive Speed</Label>
-
-            <ComboBox x:Name="cmb_DiscType" Grid.Row="0" Grid.Column="1" Height="22" Text="Bandai Playdia Quick Interactive System" DropDownClosed="cmb_DiscType_DropDownClosed" SelectionChanged="cmb_DiscType_SelectionChanged">
-                <ComboBoxItem Content="Unknown"/>
-                <ComboBoxItem Content="---------- Consoles ----------" IsEnabled="False"/>
-                <ComboBoxItem Content="Bandai Playdia Quick Interactive System"/>
-                <ComboBoxItem Content="Bandai / Apple Pippin"/>
-                <ComboBoxItem Content="Commodore Amiga CD / CD32 / CDTV"/>
-                <ComboBoxItem Content="Mattel HyperScan"/>
-                <ComboBoxItem Content="Microsoft XBOX One"/>
-                <ComboBoxItem Content="NEC PC-Engine / TurboGrafx CD"/>
-                <ComboBoxItem Content="NEC PC-FX / PC-FXGA"/>
-                <ComboBoxItem Content="Panasonic 3DO"/>
-                <ComboBoxItem Content="Philips CD-i"/>
-                <ComboBoxItem Content="Sega CD / Mega CD"/>
-                <ComboBoxItem Content="Sega Saturn"/>
-                <ComboBoxItem Content="SNK Neo Geo CD"/>
-                <ComboBoxItem Content="Sony PlayStation"/>
-                <ComboBoxItem Content="Sony PlayStation 2 (CD-Rom)"/>
-                <ComboBoxItem Content="Sony PlayStation 2 (DVD-Rom)"/>
-                <ComboBoxItem Content="Sony PlayStation 4"/>
-                <ComboBoxItem Content="VTech V.Flash - V.Smile Pro"/>
-                <ComboBoxItem Content="---------- Computers ----------" IsEnabled="False"/>
-                <ComboBoxItem Content="Apple Macintosh (CD-Rom)"/>
-                <ComboBoxItem Content="Apple Macintosh (DVD-Rom)"/>
-                <ComboBoxItem Content="Fujitsu FM Towns series"/>
-                <ComboBoxItem Content="IBM PC Compatible (CD-Rom)"/>
-                <ComboBoxItem Content="IBM PC Compatible (DVD-Rom)"/>
-                <ComboBoxItem Content="NEC PC-88"/>
-                <ComboBoxItem Content="NEC PC-98"/>
-                <ComboBoxItem Content="---------- Arcade ----------" IsEnabled="False"/>
-                <ComboBoxItem Content="Sega Lindbergh"/>
-                <ComboBoxItem Content="---------- Others ----------" IsEnabled="False"/>
-                <ComboBoxItem Content="Audio CD"/>
-                <ComboBoxItem Content="BD-Video"/>
-                <ComboBoxItem Content="DVD-Video"/>
-                <ComboBoxItem Content="PalmOS"/>
-                <ComboBoxItem Content="Photo CD"/>
-                <ComboBoxItem Content="PlayStation GameShark Updates"/>
-                <ComboBoxItem Content="Tomy Kiss-Site"/>
-                <ComboBoxItem Content="Video CD"/>
-            </ComboBox>
-
-            <TextBox x:Name="TXT_DiscImageCreatorPath" Grid.Row="1" Grid.Column="1" Height="22" Width="345" HorizontalAlignment="left" IsEnabled="False" ></TextBox>
-            <Button x:Name="BTN_DiscImageCreatorBrowse" Grid.Row="1" Grid.Column="1" Height="22" Width="50" HorizontalAlignment="Right" Content="Browse" IsEnabled="False"></Button>
-
-            <TextBox x:Name="txt_OutputFilename" Grid.Row="2" Grid.Column="1" Height="22"></TextBox>
-
-            <TextBox x:Name="txt_OutputDirectory" Grid.Row="3" Grid.Column="1" Height="22" Width="345" HorizontalAlignment="left" Text="ISO" ></TextBox>
-            <Button x:Name="BTN_OutputDirectoryBrowse" Grid.Row="3" Grid.Column="1" Height="22" Width="50" HorizontalAlignment="Right" Content="Browse" Click="BTN_OutputDirectoryBrowse_Click" ></Button>
-
-            <ComboBox x:Name="cmb_DriveLetter" Grid.Row="4" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="left"></ComboBox>
-
-            <ComboBox x:Name="cmb_DriveSpeed" Grid.Row="5" Grid.Column="1" Height="22" Width="60" HorizontalAlignment="left"  SelectionChanged="cmb_DriveSpeed_SelectionChanged">
-                <ComboBoxItem Content="4"/>
-                <ComboBoxItem Content="8"/>
-                <ComboBoxItem Content="16"/>
-                <ComboBoxItem Content="48"/>
-                <ComboBoxItem Content="Custom"/>
-            </ComboBox>
-        </Grid>
-
-        <Grid Grid.Row="1" Grid.Column="0" Margin="15,19.6,15.2,9.8" Grid.ColumnSpan="2">
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="1*"/>
-                <ColumnDefinition Width="1*"/>
-            </Grid.ColumnDefinitions>
-            <Grid.RowDefinitions>
-                <RowDefinition/>
-            </Grid.RowDefinitions>
-
-            <Button x:Name="btn_Start" Grid.Row="0" Grid.Column="0" Height="22" Width="150" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Start Dumping" Click="btn_Start_Click" IsEnabled="False" />
-            <Button x:Name="btn_Search" Grid.Row="0" Grid.Column="1" Height="22" Width="150" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Scan for disks" Click="btn_Search_Click" />
-        </Grid>
-
-        <Grid Grid.Row="2" Grid.Column="0" Margin="15,20.2,15.2,9.8" Grid.ColumnSpan="2">
-            <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="1*"/>
-            </Grid.ColumnDefinitions>
-            <Grid.RowDefinitions>
-                <RowDefinition/>
-            </Grid.RowDefinitions>
-
-            <Label x:Name="lbl_Status" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Center" Content="Waiting for CD or DVD..." />
-
-        </Grid>
-
-    </Grid>
-    
-</Window>

MainWindow.xaml.cs

@@ -1,411 +0,0 @@
-using System;
-using System.Linq;
-using System.Windows;
-using System.IO;
-using WinForms = System.Windows.Forms;
-using System.Diagnostics;
-using System.Threading.Tasks;
-
-
-namespace DICUI
-{
-
-    public partial class MainWindow : Window
-    {
-        public String discType;
-        public String processArguments;
-        public String dicPath = "Programs\\DiscImageCreator.exe";
-        public String driveLetter;
-        public String outputDirectory;
-        public String outputFileName;
-        public String driveSpeed;
-        public Boolean isPSX = false;
-        public Boolean isXboneOrPS4 = false;
-
-        public void ScanForDisk()
-        {
-            btn_Search.IsEnabled = false;
-            cmb_DriveLetter.Items.Clear();
-            foreach (var d in DriveInfo.GetDrives().Where(d => d.DriveType == DriveType.CDRom))
-            {
-                if (d.IsReady == true)
-                {
-                    txt_OutputFilename.Text = d.VolumeLabel;
-                    
-                    if (txt_OutputFilename.Text == "")
-                    {
-                        txt_OutputFilename.Text = "unknown";
-                    }
-                    cmb_DriveLetter.Items.Add(d.Name.Replace(":\\", ""));
-                    cmb_DriveLetter.SelectedIndex = 0;
-                    txt_OutputDirectory.Text = "ISO" + "\\" + txt_OutputFilename.Text + "\\";
-                    lbl_Status.Content = "CD or DVD found ! Choose your Disc Type";
-                    btn_Start.IsEnabled = true;
-                    cmb_DriveSpeed.Text = "8";
-                }
-                else
-                {
-                    lbl_Status.Content = "No CD or DVD found !";
-                }
-            btn_Search.IsEnabled = true;
-            }
-        }
-
-        public void BrowseFolder()
-        {
-            WinForms.FolderBrowserDialog folderDialog = new WinForms.FolderBrowserDialog { ShowNewFolderButton = false, SelectedPath = System.AppDomain.CurrentDomain.BaseDirectory };
-            WinForms.DialogResult result = folderDialog.ShowDialog();
-
-            if (result == WinForms.DialogResult.OK)
-            {
-                String sPath = folderDialog.SelectedPath;
-                txt_OutputDirectory.Text = sPath;
-            }
-        }
-
-        public async void StartDumping()
-        {
-
-            driveLetter = cmb_DriveLetter.Text;
-            outputDirectory = txt_OutputDirectory.Text;
-            outputFileName = txt_OutputFilename.Text;
-            driveSpeed = cmb_DriveSpeed.Text;
-            btn_Start.IsEnabled = false;
-
-            switch (Convert.ToString(cmb_DiscType.Text))
-            {
-                #region Consoles
-
-                case "Bandai Playdia Quick Interactive System":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Bandai / Apple Pippin":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Commodore Amiga CD / CD32 / CDTV":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Mattel HyperScan":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Microsoft XBOX":
-                    // Placeholder for later use
-                    break;
-                case "Microsoft XBOX 360":
-                    // Placeholder for later use
-                    break;
-                case "Microsoft XBOX One":
-                    discType = "bd";
-                    processArguments = "";
-                    isXboneOrPS4 = true;
-                    break;
-                case "NEC PC-Engine / TurboGrafx CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "NEC PC-FX / PC-FXGA":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Nintendo GameCube":
-                    // Placeholder for later use
-                    break;
-                case "Nintendo Wii":
-                    // Placeholder for later use
-                    break;
-                case "Nintendo Wii U":
-                    // Placeholder for later use
-                    break;
-                case "Panasonic 3DO":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Philips CD-i":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sega CD / Mega CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sega Dreamcast":
-                    // Placeholder for later use
-                    break;
-                case "Sega Saturn":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "SNK Neo Geo CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sony PlayStation":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    isPSX = true;
-                    break;
-                case "Sony PlayStation 2 (CD-Rom)":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sony PlayStation 2 (DVD-Rom)":
-                    discType = "dvd";
-                    processArguments = "";
-                    break;
-                case "Sony PlayStation 3":
-                    // Placeholder for later use
-                    break;
-                case "Sony PlayStation 4":
-                    discType = "bd";
-                    processArguments = "";
-                    isXboneOrPS4 = true;
-                    break;
-                case "Sony PlayStation Portable":
-                    // No-op - PSP can't be dumped with DIC
-                    break;
-                case "VM Labs NUON":
-                    // Placeholder for later use
-                    break;
-                case "VTech V.Flash - V.Smile Pro":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "ZAPiT Games Game Wave Family Entertainment System":
-                    // Placeholder for later use
-                    break;
-
-                #endregion
-
-                #region Computers
-
-                case "Acorn Archimedes":
-                    // Placeholder for later use
-                    break;
-                case "Apple Macintosh (CD-Rom)":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Apple Macintosh (DVD-Rom)":
-                    discType = "dvd";
-                    processArguments = "";
-                    break;
-                case "Fujitsu FM Towns series":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "IBM PC Compatible (CD-Rom)":
-                    discType = "cd";
-                    processArguments = "/c2 /ns /sf /ss";
-                    break;
-                case "IBM PC Compatible (DVD-Rom)":
-                    discType = "dvd";
-                    processArguments = "";
-                    break;
-                case "NEC PC-88":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "NEC PC-98":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sharp X68000":
-                    // Placeholder for later use
-                    break;
-
-                #endregion
-
-                #region Arcade
-
-                case "Namco / Sega / Nintendo Triforce":
-                    // Placeholder for later use
-                    break;
-                case "Sega Chihiro":
-                    // Placeholder for later use
-                    break;
-                case "Sega Lindbergh":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Sega Naomi":
-                    // Placeholder for later use
-                    break;
-                case "Sega Naomi 2":
-                    // Placeholder for later use
-                    break;
-                case "TAB-Austria Quizard":
-                    // Placeholder for later use
-                    break;
-
-                case "Tandy / Memorex Visual Information System":
-                    // Placeholder for later use
-                    break;
-
-                #endregion
-
-                #region Others
-
-                case "Audio CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "BD-Video":
-                    discType = "bd";
-                    processArguments = "";
-                    break;
-                case "DVD-Video":
-                    discType = "dvd";
-                    break;
-                case "PalmOS":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Philips CD-i Digital Video":
-                    // Placeholder for later use
-                    break;
-                case "Photo CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "PlayStation GameShark Updates":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Tao iKTV":
-                    // Placeholder for later use
-                    break;
-                case "Tomy Kiss-Site":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-                case "Video CD":
-                    discType = "cd";
-                    processArguments = "/c2";
-                    break;
-
-                #endregion
-
-                case "Unknown":
-                default:
-                    discType = "";
-                    processArguments = "";
-                    break;
-            }
-
-            await Task.Run(
-                () =>
-                {
-                    Process process = new Process();
-                    process.StartInfo.FileName = dicPath; // TODO: Make this configurable in UI
-                    process.StartInfo.Arguments = discType + " " + driveLetter + " \"" + outputDirectory + "\\" + outputFileName + "\" " + driveSpeed + " " + processArguments;
-                    Console.WriteLine(process.StartInfo.Arguments);
-                    process.Start();
-                    process.WaitForExit();
-                });
-
-            if (isXboneOrPS4 == true)
-            {
-                // TODO: Add random string / GUID to end of batch file name so that multiple instances can run at once
-                using (StreamWriter writetext = new StreamWriter("XboneOrPS4.bat"))
-                {
-                    writetext.WriteLine("sg_raw.exe -v -r 4100 -R " + driveLetter + ": " + "ad 01 00 00 00 00 00 00 10 04 00 00 -o \"PIC.bin\"");
-                }
-                Process processXboneOrPS4 = new Process();
-                processXboneOrPS4.StartInfo.FileName = "XboneOrPS4.bat";
-                processXboneOrPS4.Start();
-                processXboneOrPS4.WaitForExit();
-            }
-            if (isPSX == true)
-            {
-                // TODO: Add random string / GUID to end of batch file name so that multiple instances can run at once
-                using (StreamWriter writetext = new StreamWriter("PSX.bat"))
-                {
-                    writetext.WriteLine("edccchk" + " " + "\"" + outputDirectory + "\\" + outputFileName + ".bin" + "\" > " + "\"" + outputDirectory + "\\" + "edccchk1.txt");
-                    writetext.WriteLine("edccchk" + " " + "\"" + outputDirectory + "\\" + outputFileName + " (Track 1).bin" + "\" > " + "\"" + outputDirectory + "\\" + "edccchk1.txt");
-                    writetext.WriteLine("edccchk" + " " + "\"" + outputDirectory + "\\" + outputFileName + " (Track 01).bin" + "\" > " + "\"" + outputDirectory + "\\" + "edccchk1.txt");
-                    writetext.WriteLine("psxt001z" + " " + "\"" + outputDirectory + "\\" + outputFileName + ".bin" + "\" > " + "\"" + outputDirectory + "\\" + "psxt001z1.txt");
-                    writetext.WriteLine("psxt001z" + " " + "\"" + outputDirectory + "\\" + outputFileName + " (Track 1).bin" + "\" > " + "\"" + outputDirectory + "\\" + "psxt001z2.txt");
-                    writetext.WriteLine("psxt001z" + " " + "\"" + outputDirectory + "\\" + outputFileName + " (Track 01).bin" + "\" > " + "\"" + outputDirectory + "\\" + "psxt001z3.txt");
-                    writetext.WriteLine("psxt001z" + " " + "--libcrypt " + "\"" + outputDirectory + "\\" + outputFileName + ".sub\" > " + "\"" + outputDirectory + "\\" + "libcrypt.txt");
-                    writetext.WriteLine("psxt001z" + " " + "--libcryptdrvfast " + driveLetter + " > " + "\"" + outputDirectory + "\\" + "libcryptdrv.log");
-                }
-                Process processpsx = new Process();
-                processpsx.StartInfo.FileName = "PSX.bat";
-                processpsx.Start();
-                processpsx.WaitForExit();
-            }
-            btn_Start.IsEnabled = true;
-        }
-
-        public MainWindow()
-        {
-            InitializeComponent();
-            ScanForDisk();
-        }
-
-        private void btn_Start_Click(object sender, RoutedEventArgs e)
-        {
-            StartDumping();  
-        }
-
-        private void BTN_OutputDirectoryBrowse_Click(object sender, RoutedEventArgs e)
-        {
-            BrowseFolder();
-        }
-
-        private void btn_Search_Click(object sender, RoutedEventArgs e)
-        {
-            ScanForDisk();
-        }
-
-
-
-        private void cmb_DiscType_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
-        {
-
-
-            lbl_Status.Content = "Ready to dump";
-        }
-
-        private void cmb_DriveSpeed_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
-        {
-            // TODO: Figure out how to keep the list of items while also allowing the custom input
-            if (cmb_DriveSpeed.SelectedIndex == 4)
-            {
-                cmb_DriveSpeed.Items.Clear();
-                cmb_DriveSpeed.IsEditable = true;
-            }
-        }
-
-        private void cmb_DiscType_DropDownClosed(object sender, EventArgs e)
-        {
-            switch (Convert.ToString(cmb_DiscType.Text))
-            {
-
-                case "Sony PlayStation 4":
-                    cmb_DriveSpeed.Items.Clear();
-                    cmb_DriveSpeed.IsEnabled = false;
-                    break;
-                case "Microsoft XBOX One":
-                    cmb_DriveSpeed.Items.Clear();
-                    cmb_DriveSpeed.IsEnabled = false;
-                    break;
-                default:
-                    cmb_DriveSpeed.IsEnabled = true;
-                    cmb_DriveSpeed.Items.Clear();
-                    cmb_DriveSpeed.Items.Add("4");
-                    cmb_DriveSpeed.Items.Add("8");
-                    cmb_DriveSpeed.Items.Add("16");
-                    cmb_DriveSpeed.Items.Add("48");
-                    cmb_DriveSpeed.Items.Add("Custom");
-                    cmb_DriveSpeed.SelectedIndex = 1;
-                    break;
-            }
-
-        }
-    }
-}

Properties/Resources.Designer.cs

@@ -1,63 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace DICUI.Properties {
-    using System;
-    
-    
-    /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources {
-        
-        private static global::System.Resources.ResourceManager resourceMan;
-        
-        private static global::System.Globalization.CultureInfo resourceCulture;
-        
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Resources() {
-        }
-        
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
-            get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DICUI.Properties.Resources", typeof(Resources).Assembly);
-                    resourceMan = temp;
-                }
-                return resourceMan;
-            }
-        }
-        
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
-            get {
-                return resourceCulture;
-            }
-            set {
-                resourceCulture = value;
-            }
-        }
-    }
-}

Properties/Resources.resx

@@ -1,117 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

README.md

@@ -1,25 +1,58 @@
 # DICUI
-This is my current progress on my C# Disc Image Creator UI.
 
-I'm a hobbyist programmer, so this code might not be optimal, feel free to make your recommendation / Pull request.
+DiscImageCreator/Aaru UI in C#
 
-I would like this project to be a community project, so if you have some time and knowledge to give, I'll be glad to add you to the contributor of this project :)
+[![Build status](https://ci.appveyor.com/api/projects/status/3ldav3v0c373jeqa?svg=true)](https://ci.appveyor.com/project/mnadareski/dicui/build/artifacts)
 
---------------------------------------------------------------------------
-Currently working on the project:
- 
-ReignStumble - Lead Developer
+This is a community project, so if you have some time and knowledge to give, we'll be glad to add you to the contributor of this project :)
 
-darksabre76 - Contributer
+DICUI relies on the following projects:
+- **Aaru** by Claunia - Dumping - [GitHub](https://github.com/aaru-dps/Aaru)
+- **CleanRip** by emu_kidid - Offline dumping - [GitHub](https://github.com/emukidid/cleanrip)
+- **DD for Windows* - Dumping - [Homepage](http://www.chrysocome.net/dd);
+- **DiscImageCreator** by Sarami - Dumping - [GitHub](https://github.com/saramibreak/DiscImageCreator)
+- **BurnOutSharp** - Protection scanning - [GitHub](https://github.com/mnadareski/BurnOutSharp)
+- **UnshieldSharp** - Protection scanning - [GitHub](https://github.com/mnadareski/UnshieldSharp)
 
-NHellFire - Contributer
+**Note:** Both Aaru DiscImageCreator have WIP builds. In general, WIP builds are not supported with new flags or features until they make it into the stable release.
 
-Dizzzy - Concept/Ideas/Beta tester
+## System Requirements
 
- 
---------------------------------------------------------------------------
-2018-05-14
---------------------------------------------------------------------------
-Version 1.01d released:
+Even though this is written in C#, this program can only be used on Windows systems due to one of the base programs, DiscImageCreator, being Windows-only. There is some preliminary support for Linux underway, and we will try to integrate with that when the time comes.
 
-https://github.com/reignstumble/DICUI/releases
+- Windows 7 (newest version of Windows recommended)
+- .NET Framework 4.6.2, .NET Framework 4.7.2, or .NET Core 3.0 Runtimes (.NET Core 3.0 is not currently functional due to a dependency, please do not use it)
+- 128 MB of free RAM
+- As much hard drive space as amount of discs you will be dumping (20+ GB recommended)
+
+Ensure that your operating system is as up-to-date as possible, since some features may rely on those updates.
+
+## Releases
+
+For those who would rather the most recently stable build, ownload the latest release here:
+[Releases Page](https://github.com/SabreTools/DICUI/releases)
+
+For those who like to test the newest features, download the latest AppVeyor WIP build here: [AppVeyor](https://ci.appveyor.com/project/mnadareski/dicui/build/artifacts)
+
+## Changelist
+
+A list of all changes can now be found [here](https://github.com/SabreTools/DICUI/blob/master/CHANGELIST.md).
+
+## Contributors
+
+Here are the talented people who have contributed to the project so far:
+
+- **darksabre76** - Project Lead / Backend Design
+- **ReignStumble** - Former Project Lead / UI Design
+- **Jakz** - Primary Feature Contributor
+- **NHellFire** - Feature Contributor
+
+## Notable Testers
+
+These are the tireless individuals who have dedicated countless hours to help test the many features of DICUI and have worked with the development team closely:
+
+- **Dizzzy/user7** - Concept, ideas, tester
+- **Kludge** - Primary stress tester
+- **ajshell1** - Tester
+- **eientei95** - Tester
+- **VGPC Discord** - Testing and feedback

appveyor.yml

@@ -0,0 +1,71 @@
+# version format
+version: 1.16-{build}
+
+# pull request template
+pull_requests:
+  do_not_increment_build_number: true
+
+# vm template
+image: Visual Studio 2019
+
+# environment variables
+environment:
+  EnableNuGetPackageRestore: true
+
+# msbuild configuration
+platform:
+- Any CPU
+configuration:
+- Debug
+
+# install dependencies
+install:
+- ps: appveyor DownloadFile https://dist.nuget.org/win-x86-commandline/latest/nuget.exe
+
+# pre-build script
+before_build:
+- nuget restore
+
+# build step
+build:
+  verbosity: minimal
+
+# post-build step
+after_build:
+- ps: appveyor DownloadFile https://github.com/aaru-dps/Aaru/releases/download/v5.0.1.2884/aaru-5.0.1.2884-1_windows_x64.zip
+- ps: appveyor DownloadFile http://www.chrysocome.net/downloads/8ab730cd2a29e76ddd89be1f99357942/dd-0.6beta3.zip
+- ps: appveyor DownloadFile https://github.com/saramibreak/DiscImageCreator/files/4426240/DiscImageCreator_20200403.zip
+- ps: appveyor DownloadFile https://archive.org/download/subdump_fua_0x28/subdump_fua_0x28.zip
+- 7z e aaru-5.0.1.2884-1_windows_x64.zip -oDICUI\bin\Debug\net462\Programs\Aaru *
+- 7z e aaru-5.0.1.2884-1_windows_x64.zip -oDICUI\bin\Debug\net472\Programs\Aaru *
+- 7z e aaru-5.0.1.2884-1_windows_x64.zip -oDICUI\bin\Debug\net48\Programs\Aaru *
+- 7z e aaru-5.0.1.2884-1_windows_x64.zip -oDICUI\bin\Debug\netcoreapp3.1\Programs\Aaru *
+- 7z e dd-0.6beta3.zip -oDICUI\bin\Debug\net462\Programs\DD *
+- 7z e dd-0.6beta3.zip -oDICUI\bin\Debug\net472\Programs\DD *
+- 7z e dd-0.6beta3.zip -oDICUI\bin\Debug\net48\Programs\DD *
+- 7z e dd-0.6beta3.zip -oDICUI\bin\Debug\netcoreapp3.1\Programs\DD *
+- 7z e DiscImageCreator_20200403.zip -oDICUI\bin\Debug\net462\Programs\Creator Release_ANSI\*
+- 7z e DiscImageCreator_20200403.zip -oDICUI\bin\Debug\net472\Programs\Creator Release_ANSI\*
+- 7z e DiscImageCreator_20200403.zip -oDICUI\bin\Debug\net48\Programs\Creator Release_ANSI\*
+- 7z e DiscImageCreator_20200403.zip -oDICUI\bin\Debug\netcoreapp3.1\Programs\Creator Release_ANSI\*
+- 7z e subdump_fua_0x28.zip -oDICUI\bin\Debug\net462 *
+- mkdir DICUI\bin\Debug\net462\Programs\Subdump
+- mv DICUI\bin\Debug\net462\subdump_fua_0x28.exe DICUI\bin\Debug\net462\Programs\Subdump\subdump.exe
+- 7z e subdump_fua_0x28.zip -oDICUI\bin\Debug\net472 *
+- mkdir DICUI\bin\Debug\net472\Programs\Subdump
+- mv DICUI\bin\Debug\net472\subdump_fua_0x28.exe DICUI\bin\Debug\net472\Programs\Subdump\subdump.exe
+- 7z e subdump_fua_0x28.zip -oDICUI\bin\Debug\net48 *
+- mkdir DICUI\bin\Debug\net48\Programs\Subdump
+- mv DICUI\bin\Debug\net48\subdump_fua_0x28.exe DICUI\bin\Debug\net462\Programs\Subdump\subdump.exe
+- 7z e subdump_fua_0x28.zip -oDICUI\bin\Debug\netcoreapp3.1 *
+- mkdir DICUI\bin\Debug\netcoreapp3.1\Programs\Subdump
+- mv DICUI\bin\Debug\netcoreapp3.1\subdump_fua_0x28.exe DICUI\bin\Debug\netcoreapp3.1\Programs\Subdump\subdump.exe
+- 7z a DICUI.zip DICUI\bin\Debug\*
+- 7z a DICUI-Check.zip DICUI.Check\bin\Debug\*
+
+# artifact linking
+artifacts:
+- path: DICUI.zip
+  name: DICUI
+- path: DICUI-Check.zip
+  name: DICUI Check