Update to 1.16

* First part of cleanup

* Second part of cleanup

* Second part of cleanup, part two

* Second part of cleanup, part three

* Second part of cleanup, part four

* Third part of cleanup

* Fourth part of cleanup (nw)

* Rebranding

* Aaru-fication

* Try to fix .NET Core builds

* Strip out CD Check for false positives

* Update DIC to 20200403

* Add .NET 4.8 to automated builds

* Address a couple of TODOs

* Typo

* Aaru is up to date

* Fix AppVeyor

* Add new systems (fixes #196)

* Fix build

Co-authored-by: Matt Nadareski <mnadareski@mparticle.com>

CHANGELIST.md

@@ -1,4 +1,30 @@
+### 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
@@ -8,15 +34,18 @@
 - 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

DICUI.Check/App.config

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

DICUI.Check/DICUI.Check.csproj

@@ -1,59 +1,21 @@
-<?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')" />
+<Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{8CFDE289-E171-4D49-A40D-5293265C1253}</ProjectGuid>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <OutputType>Exe</OutputType>
-    <RootNamespace>DICUI.Check</RootNamespace>
-    <AssemblyName>DICUI.Check</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <Deterministic>true</Deterministic>
+    <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>AnyCPU</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>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Program.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
+
   <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>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+
 </Project>

DICUI.Check/Program.cs

@@ -39,10 +39,10 @@ namespace DICUI.Check
             {
                 DisplayHelp("Invalid number of arguments");
                 return;
-            }            
+            }
 
             // Check the MediaType
-            var mediaType = Converters.StringToMediaType(args[0].Trim('"'));
+            var mediaType = Converters.ToMediaType(args[0].Trim('"'));
             if (mediaType == MediaType.NONE)
             {
                 DisplayHelp($"{args[0]} is not a recognized media type");
@@ -50,21 +50,38 @@ namespace DICUI.Check
             }
 
             // Check the KnownSystem
-            var knownSystem = Converters.StringToKnownSystem(args[1].Trim('"'));
+            var knownSystem = Converters.ToKnownSystem(args[1].Trim('"'));
             if (knownSystem == KnownSystem.NONE)
             {
                 DisplayHelp($"{args[1]} is not a recognized system");
                 return;
             }
 
-            // Check for Redump login credentials
+            // Check for additional flags
             string username = null, password = null;
+            string internalProgram = "DiscImageCreator";
             int startIndex = 2;
-            if (args[2] == "-c" || args[2] == "--credentials")
+            for (; startIndex < args.Length; startIndex++)
             {
-                username = args[3];
-                password = args[4];
-                startIndex = 5;
+                // Redump login
+                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];
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
             }
 
             // Make a new Progress object
@@ -92,6 +109,8 @@ namespace DICUI.Check
                     System = knownSystem,
                     Type = mediaType,
                     ScanForProtection = false,
+                    PromptForDiscInformation = false,
+                    InternalProgram = Converters.ToInternalProgram(internalProgram),
 
                     Username = username,
                     Password = password,
@@ -114,7 +133,7 @@ namespace DICUI.Check
                 Console.WriteLine(error);
 
             Console.WriteLine("Usage:");
-            Console.WriteLine("DICUI.Check.exe <mediatype> <system> [-c username password] </path/to/output.bin> ...");
+            Console.WriteLine("DICUI.Check.exe <mediatype> <system> [options] </path/to/output.bin> ...");
             Console.WriteLine();
             Console.WriteLine(@"Common Media Types:\r\n
 bd / bluray     - BD-ROM
@@ -136,6 +155,10 @@ 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:\r\n
+-c username password    - Redump credentials
+-u                      - Check for Aaru");
         }
 
         /// <summary>

DICUI.Check/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // 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")]
+[assembly: AssemblyFileVersion("1.16.0.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/DICUI.Library.csproj

@@ -1,90 +1,16 @@
-<?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')" />
+<Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{51AB0928-13F9-44BF-A407-B6957A43A056}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>DICUI</RootNamespace>
-    <AssemblyName>DICUI.Library</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <Deterministic>true</Deterministic>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
+
+  <PropertyGroup Condition="'$(TargetFramework)'!='netcoreapp2.1' AND '$(TargetFramework)'!='netcoreapp3.1'">
+    <DefineConstants>NET_FRAMEWORK</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="BurnOutSharp, Version=1.3.7.1, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\BurnOutSharp.1.3.7.1\lib\net461\BurnOutSharp.dll</HintPath>
-    </Reference>
-    <Reference Include="LessIO, Version=0.5.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\LessIO.0.5.0\lib\net40\LessIO.dll</HintPath>
-    </Reference>
-    <Reference Include="libmspackn, Version=0.8.0.0, Culture=neutral, processorArchitecture=x86">
-      <HintPath>..\packages\libmspack4n.0.8.0\lib\net40\libmspackn.dll</HintPath>
-    </Reference>
-    <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.12.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
-    </Reference>
-    <Reference Include="PresentationFramework" />
-    <Reference Include="System" />
-    <Reference Include="System.Configuration" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Management" />
-    <Reference Include="System.Runtime.Serialization" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xml" />
-    <Reference Include="UnshieldSharp, Version=1.4.2.2, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\UnshieldSharp.1.4.2.2\lib\net461\UnshieldSharp.dll</HintPath>
-    </Reference>
-    <Reference Include="zlib.net, Version=1.0.3.0, Culture=neutral, PublicKeyToken=47d7877cb3620160">
-      <HintPath>..\packages\zlib.net.1.0.4.0\lib\zlib.net.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Data\Constants.cs" />
-    <Compile Include="Data\Enumerations.cs" />
-    <Compile Include="Data\SubmissionInfo.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Utilities\Converters.cs" />
-    <Compile Include="Utilities\Drive.cs" />
-    <Compile Include="Utilities\DumpEnvironment.cs" />
-    <Compile Include="Utilities\Extensions.cs" />
-    <Compile Include="Utilities\Parameters.cs" />
-    <Compile Include="Utilities\Result.cs" />
-    <Compile Include="Utilities\Validators.cs" />
-    <Compile Include="Web\CookieAwareWebClient.cs">
-      <SubType>Component</SubType>
-    </Compile>
-    <Compile Include="Web\RedumpAccess.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="mspack.dll">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-  <ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'!='netcoreapp2.1' AND '$(TargetFramework)'!='netcoreapp3.1'">
     <COMReference Include="IMAPI2">
       <Guid>{2735412F-7F64-5B0F-8F00-5D77AFBE261E}</Guid>
       <VersionMajor>1</VersionMajor>
@@ -104,8 +30,15 @@
       <EmbedInteropTypes>True</EmbedInteropTypes>
     </COMReference>
   </ItemGroup>
+
   <ItemGroup>
-    <None Include="packages.config" />
+    <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>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>
+
+  <ItemGroup>
+    <Reference Include="System.Management" />
+  </ItemGroup>
+
+</Project>

DICUI.Library/Data/BaseParameters.cs

@@ -0,0 +1,255 @@
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace DICUI.Data
+{
+    public abstract class BaseParameters
+    {
+        /// <summary>
+        /// Path to the executable
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// Program that this set of parameters represents
+        /// </summary>
+        public InternalProgram InternalProgram { get; set; }
+
+        /// <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>
+        /// 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>
+        /// 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

@@ -1,66 +1,5 @@
 namespace DICUI.Data
 {
-    /// <summary>
-    /// Top-level commands for DiscImageCreator
-    /// </summary>
-    public static class DICCommandStrings
-    {
-        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 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 DICFlagStrings
-    {
-        public const string AddOffset = "/a";
-        public const string AMSF = "/p";
-        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 MCN = "/m";
-        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";
-    }
-
     /// <summary>
     /// Template field values for submission info
     /// </summary>

DICUI.Library/Data/Enumerations.cs

@@ -18,69 +18,6 @@
         AddOns = 11,
     }
 
-    /// <summary>
-    /// Supported DIC commands
-    /// </summary>
-    public enum DICCommand
-    {
-        NONE = 0,
-        Audio,
-        BluRay,
-        Close,
-        CompactDisc,
-        Data,
-        DigitalVideoDisc,
-        DriveSpeed,
-        Eject,
-        Floppy,
-        GDROM,
-        MDS,
-        Merge,
-        Reset,
-        SACD,
-        Start,
-        Stop,
-        Sub,
-        Swap,
-        XBOX,
-        XBOXSwap,
-        XGD2Swap,
-        XGD3Swap,
-    }
-
-    /// <summary>
-    /// Supported DIC flags
-    /// </summary>
-    public enum DICFlag
-    {
-        NONE = 0,
-        AddOffset,
-        AMSF,
-        BEOpcode,
-        C2Opcode,
-        CopyrightManagementInformation,
-        D8Opcode,
-        DisableBeep,
-        ForceUnitAccess,
-        MCN,
-        MultiSession,
-        NoFixSubP,
-        NoFixSubQ,
-        NoFixSubQLibCrypt,
-        NoFixSubRtoW,
-        NoFixSubQSecuROM,
-        NoSkipSS,
-        Raw,
-        Reverse,
-        ScanAntiMod,
-        ScanFileProtect,
-        ScanSectorProtect,
-        SeventyFour,
-        SkipSector,
-        SubchannelReadLevel,
-        VideoNow,
-    }
-
     /// <summary>
     /// Dump status for Redump
     /// </summary>
@@ -92,6 +29,29 @@
         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,
+
+        DiscImageCreator,
+        Aaru,
+        DD, // TODO: Currently unimplemented
+    }
+
     /// <summary>
     /// Known systems
     /// </summary>
@@ -224,6 +184,7 @@
         AUSCOMSystem1,
         BallyGameMagic,
         CapcomCPSystemIII,
+        funworldPhotoPlay,
         GlobalVRVarious,
         GlobalVRVortek,
         GlobalVRVortekV3,
@@ -288,6 +249,7 @@
         PhotoCD,
         PlayStationGameSharkUpdates,
         RainbowDisc,
+        SegaPrologue21,
         SuperAudioCD,
         TaoiKTV,
         TomyKissSite,
@@ -354,6 +316,16 @@
         Ukrainian,
     }
 
+    /// <summary>
+    /// All possible language selections
+    /// </summary>
+    public enum LanguageSelection
+    {
+        BiosSettings,
+        LanguageSelector,
+        OptionsMenu,
+    }
+
     /// <summary>
     /// Known media types
     /// </summary>
@@ -406,6 +378,84 @@
         // Unsorted Formats
         Cartridge,
         CED,
+        CompactFlash,
+        MMC,
+        SDCard,
+        FlashDrive,
+    }
+
+    /// <summary>
+    /// Media types according to https://docs.microsoft.com/en-us/previous-versions/windows/desktop/cimwin32a/win32-physicalmedia
+    /// </summary>
+    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>
@@ -519,6 +569,7 @@
         France,
         FranceSpain,
         Germany,
+        GreaterChina,
         Greece,
         Hungary,
         India,
@@ -549,10 +600,12 @@
         Turkey,
         UnitedArabEmirates,
         UK,
+        UKAustralia,
         Ukraine,
         USA,
         USAAsia,
         USABrazil,
+        USACanada,
         USAEurope,
         USAJapan,
         World,

DICUI.Library/Data/SubmissionInfo.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
+using System.Net;
 using DICUI.Utilities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
@@ -10,16 +11,253 @@ namespace DICUI.Data
 {
     public class SubmissionInfo
     {
-        #region Common disc info
+        /// <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
+    {
         // TODO: Name not defined
         [JsonProperty(PropertyName = "d_system", Required = Required.AllowNull)]
-        [JsonConverter(typeof(StringEnumConverter))]
+        [JsonConverter(typeof(KnownSystemConverter))]
         public KnownSystem? System { get; set; }
 
         // TODO: Name not defined
+        // TODO: Have this convert to a new `RedumpMedia?` if possible, for submission
         [JsonProperty(PropertyName = "d_media", Required = Required.AllowNull)]
-        [JsonConverter(typeof(StringEnumConverter))]
+        [JsonConverter(typeof(MediaTypeConverter))]
         public MediaType? Media { get; set; }
 
         [JsonProperty(PropertyName = "d_title", Required = Required.AllowNull)]
@@ -38,15 +276,16 @@ namespace DICUI.Data
         public Category? Category { get; set; }
 
         [JsonProperty(PropertyName = "d_region", Required = Required.AllowNull)]
-        [JsonConverter(typeof(StringEnumConverter))]
+        [JsonConverter(typeof(RegionConverter))]
         public Region? Region { get; set; }
 
         [JsonProperty(PropertyName = "d_languages", Required = Required.AllowNull)]
+        [JsonConverter(typeof(LanguagesConverter))]
         public Language?[] Languages { get; set; }
 
-        // "Bios settings", "Language selector", "Options menu"
-        [JsonProperty(PropertyName = "d_languages_selection", NullValueHandling = NullValueHandling.Ignore)]
-        public string[] LanguageSelection { 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; }
@@ -116,11 +355,13 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_contents", NullValueHandling = NullValueHandling.Ignore)]
         public string Contents { get; set; }
+    }
 
-        #endregion
-
-        #region Version and Editions
-
+    /// <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; }
 
@@ -132,28 +373,34 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_editions_text", NullValueHandling = NullValueHandling.Ignore)]
         public string OtherEditions { get; set; }
+    }
 
-        #endregion
-
-        #region EDC (PSX-only)
-
+    /// <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; }
+    }
 
-        #endregion
-
-        #region Parent/Clone relationship
-
+    /// <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; }
+    }
 
-        #endregion
-
-        #region Extras
-
+    /// <summary>
+    /// Extras section of New Disc form
+    /// </summary>
+    public class ExtrasSection
+    {
         [JsonProperty(PropertyName = "d_pvd", NullValueHandling = NullValueHandling.Ignore)]
         public string PVD { get; set; }
 
@@ -174,11 +421,13 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_ssranges", NullValueHandling = NullValueHandling.Ignore)]
         public string SecuritySectorRanges { get; set; }
+    }
 
-        #endregion
-
-        #region Copy protection
-
+    /// <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; }
 
@@ -193,11 +442,13 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_securom", NullValueHandling = NullValueHandling.Ignore)]
         public string SecuROMData { get; set; }
+    }
 
-        #endregion
-
-        #region Dumpers and Status (Moderator only)
-
+    /// <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; }
 
@@ -206,11 +457,13 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_dumpers_text", NullValueHandling = NullValueHandling.Ignore)]
         public string OtherDumpers { get; set; }
+    }
 
-        #endregion
-
-        #region Tracks and write offsets (CD,GD-baed)
-
+    /// <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; }
 
@@ -222,11 +475,13 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_offset_text", NullValueHandling = NullValueHandling.Ignore)]
         public string OtherWriteOffsets { get; set; }
+    }
 
-        #endregion
-
-        #region Size & Checksum (DVD,BD,UMD-based)
-
+    /// <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; }
 
@@ -241,207 +496,5 @@ namespace DICUI.Data
 
         [JsonProperty(PropertyName = "d_sha1", NullValueHandling = NullValueHandling.Ignore)]
         public string SHA1 { get; set; }
-
-        #endregion
-
-        #region Nonstandard Information
-
-        [JsonIgnore]
-        public List<int> MatchedIDs { get; set; }
-
-        [JsonIgnore]
-        public DateTime? Added { get; set; }
-
-        [JsonIgnore]
-        public DateTime? LastModified { get; set; }
-
-        #endregion
-
-        #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 = match.Groups[1].Value;
-
-                // If we have parenthesis, title is everything before the first one
-                int firstParenLocation = title.IndexOf(" (");
-                if (firstParenLocation >= 0)
-                {
-                    this.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.DiscNumberLetter = subMatch.Remove(0, "Disc ".Length);
-
-                        // Disc title
-                        else
-                            this.DiscTitle = subMatch;
-                    }
-                }
-                // Otherwise, leave the title as-is
-                else
-                {
-                    this.Title = title;
-                }
-            }
-
-            // Foreign Title
-            match = foreignTitleRegex.Match(discData);
-            if (match.Success)
-                this.ForeignTitleNonLatin = match.Groups[1].Value;
-            else
-                this.ForeignTitleNonLatin = null;
-
-            // Category
-            match = categoryRegex.Match(discData);
-            if (match.Success)
-                this.Category = Converters.StringToCategory(match.Groups[1].Value);
-            else
-                this.Category = Data.Category.Games;
-
-            // Region
-            match = regionRegex.Match(discData);
-            if (match.Success)
-                this.Region = Converters.StringToRegion(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.StringToLanguage(submatch.Groups[1].Value));
-
-                this.Languages = tempLanguages.ToArray();
-            }
-
-            // Serial
-            match = serialRegex.Match(discData);
-            if (match.Success)
-                this.Serial = 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.ErrorsCount) && match.Groups[1].Value != this.ErrorsCount)
-                    this.ErrorsCount = match.Groups[1].Value;
-            }
-
-            // Version
-            match = versionRegex.Match(discData);
-            if (match.Success)
-                this.Version = match.Groups[1].Value;
-
-            // Edition
-            match = editionRegex.Match(discData);
-            if (match.Success)
-                this.OtherEditions = 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.Dumpers.Length > 0)
-                {
-                    foreach (string dumper in this.Dumpers)
-                        tempDumpers.Add(dumper);
-                }
-
-                foreach (Match submatch in matches)
-                    tempDumpers.Add(submatch.Groups[1].Value);
-
-                this.Dumpers = tempDumpers.ToArray();
-            }
-
-            // Barcode
-            match = barcodeRegex.Match(discData);
-            if (match.Success)
-                this.Barcode = match.Groups[1].Value;
-
-            // Comments
-            match = commentsRegex.Match(discData);
-            if (match.Success)
-            {
-                this.Comments = match.Groups[1].Value
-                    .Replace("<br />", "\n")
-                    .Replace("<b>ISBN</b>", "[T:ISBN]") + "\n";
-            }
-
-            // Contents
-            match = contentsRegex.Match(discData);
-            if (match.Success)
-            {
-                this.Contents = match.Groups[1].Value
-                       .Replace("<br />", "\n")
-                       .Replace("</div>", "");
-                this.Contents = Regex.Replace(this.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);
-        }
     }
 }

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,327 @@
+using System;
+using System.IO;
+using DICUI.Data;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+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

@@ -32,6 +32,6 @@ using System.Runtime.InteropServices;
 // 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.13")]
-[assembly: AssemblyFileVersion("1.13.0.0")]
+[assembly: AssemblyVersion("1.16")]
+[assembly: AssemblyFileVersion("1.16.0.0")]
 [assembly: InternalsVisibleTo("DICUI.Test")]

DICUI.Library/Utilities/Converters.cs

@@ -1,5 +1,11 @@
-using IMAPI2;
+using System;
+using System.IO;
 using DICUI.Data;
+#if NET_FRAMEWORK
+using IMAPI2;
+#endif
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace DICUI.Utilities
 {
@@ -8,34 +14,20 @@ namespace DICUI.Utilities
         #region Cross-enumeration conversions
 
         /// <summary>
-        /// Get the most common known system for a given MediaType
+        /// Convert drive type to internal version, if possible
         /// </summary>
-        /// <param name="baseCommand">DICCommand value to check</param>
-        /// <returns>KnownSystem if possible, null on error</returns>
-        public static KnownSystem? ToKnownSystem(this DICCommand baseCommand)
+        /// <param name="driveType">DriveType value to check</param>
+        /// <returns>InternalDriveType, if possible, null on error</returns>
+        public static InternalDriveType? ToInternalDriveType(this DriveType driveType)
         {
-            switch (baseCommand)
+            switch(driveType)
             {
-                case DICCommand.Audio:
-                    return KnownSystem.AudioCD;
-                case DICCommand.CompactDisc:
-                case DICCommand.Data:
-                case DICCommand.DigitalVideoDisc:
-                case DICCommand.Floppy:
-                    return KnownSystem.IBMPCCompatible;
-                case DICCommand.GDROM:
-                case DICCommand.Swap:
-                    return KnownSystem.SegaDreamcast;
-                case DICCommand.BluRay:
-                    return KnownSystem.SonyPlayStation3;
-                case DICCommand.SACD:
-                    return KnownSystem.SuperAudioCD;
-                case DICCommand.XBOX:
-                case DICCommand.XBOXSwap:
-                    return KnownSystem.MicrosoftXBOX;
-                case DICCommand.XGD2Swap:
-                case DICCommand.XGD3Swap:
-                    return KnownSystem.MicrosoftXBOX360;
+                case DriveType.CDRom:
+                    return InternalDriveType.Optical;
+                case DriveType.Fixed:
+                    return InternalDriveType.HardDisk;
+                case DriveType.Removable:
+                    return InternalDriveType.Removable;
                 default:
                     return null;
             }
@@ -46,7 +38,7 @@ namespace DICUI.Utilities
         /// </summary>
         /// <param name="system">Redump system value to check</param>
         /// <returns>KnownSystem if possible, null on error</returns>
-        public static KnownSystem? ToKnownSystem(this RedumpSystem system)
+        public static KnownSystem? ToKnownSystem(this RedumpSystem? system)
         {
             switch (system)
             {
@@ -206,75 +198,84 @@ namespace DICUI.Utilities
             }
         }
 
-        /// <summary>
-        /// Get the MediaType associated with a given base command
-        /// </summary>
-        /// <param name="baseCommand">DICCommand 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(this DICCommand baseCommand)
-        {
-            switch (baseCommand)
-            {
-                case DICCommand.Audio:
-                case DICCommand.CompactDisc:
-                case DICCommand.Data:
-                case DICCommand.SACD:
-                    return MediaType.CDROM;
-                case DICCommand.GDROM:
-                case DICCommand.Swap:
-                    return MediaType.GDROM;
-                case DICCommand.DigitalVideoDisc:
-                case DICCommand.XBOX:
-                case DICCommand.XBOXSwap:
-                case DICCommand.XGD2Swap:
-                case DICCommand.XGD3Swap:
-                    return MediaType.DVD;
-                case DICCommand.BluRay:
-                    return MediaType.BluRay;
-
-                // Non-optical
-                case DICCommand.Floppy:
-                    return MediaType.FloppyDisk;
-                default:
-                    return null;
-            }
-        }
-
+#if NET_FRAMEWORK
         /// <summary>
         /// Convert IMAPI physical media type to a MediaType
         /// </summary>
         /// <param name="type">IMAPI_MEDIA_PHYSICAL_TYPE value to check</param>
         /// <returns>MediaType if possible, null on error</returns>
-        public static MediaType? ToMediaType(IMAPI_MEDIA_PHYSICAL_TYPE type)
+        public static MediaType? IMAPIToMediaType(this IMAPI_MEDIA_PHYSICAL_TYPE type)
+        {
+           switch (type)
+           {
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN:
+                   return MediaType.NONE;
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW:
+                   return MediaType.CDROM;
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER:
+                   return MediaType.DVD;
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM:
+                   return MediaType.HDDVD;
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR:
+               case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE:
+                   return MediaType.BluRay;
+               default:
+                   return null;
+           }
+        }
+#endif
+
+        /// <summary>
+        /// Convert physical media type to a MediaType
+        /// </summary>
+        /// <param name="type">PhsyicalMediaType value to check</param>
+        /// <returns>MediaType if possible, null on error</returns>
+        public static MediaType? ToMediaType(this PhysicalMediaType type)
         {
             switch (type)
             {
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN:
+                case PhysicalMediaType.Unknown:
                     return MediaType.NONE;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_CDRW:
+
+                // CD-based media
+                case PhysicalMediaType.CDROM:
+                case PhysicalMediaType.CDROMXA:
+                case PhysicalMediaType.CDI: // TODO: Make this separate at some point (CD-I/CD-I Ready?)
+                case PhysicalMediaType.CDRecordable:
+                case PhysicalMediaType.CDRW:
+                case PhysicalMediaType.CDDA:
+                case PhysicalMediaType.CDPlus: // TODO: Make this separate at some point (Enhanced CD?)
                     return MediaType.CDROM;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDRAM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSR_DUALLAYER:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHRW:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDDASHR_DUALLAYER:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DISK:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_DVDPLUSRW_DUALLAYER:
+
+                // DVD-based media
+                case PhysicalMediaType.DVD:
+                case PhysicalMediaType.DVDPlusRW:
+                case PhysicalMediaType.DVDRAM:
+                case PhysicalMediaType.DVDROM:
+                case PhysicalMediaType.DVDVideo: // TODO: Make this separate at some point (DVD-Video?)
+                case PhysicalMediaType.DVDRecordable:
+                case PhysicalMediaType.DVDMinusRW:
+                case PhysicalMediaType.DVDAudio: // TODO: Make this separate at some point (DVD-Audio?)
+                case PhysicalMediaType.DVD5: // TODO: Make this separate at some point (DVD-5?)
+                case PhysicalMediaType.DVD9: // TODO: Make this separate at some point (DVD-9?)
+                case PhysicalMediaType.DVD10: // TODO: Make this separate at some point (DVD-10?)
+                case PhysicalMediaType.DVD18: // TODO: Make this separate at some point (DVD-18?)
                     return MediaType.DVD;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_HDDVDRAM:
-                    return MediaType.HDDVD;
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDROM:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDR:
-                case IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_BDRE:
-                    return MediaType.BluRay;
+
                 default:
                     return null;
             }
@@ -285,7 +286,7 @@ namespace DICUI.Utilities
         /// </summary>
         /// <param name="system">KnownSystem value to check</param>
         /// <returns>RedumpSystem if possible, null on error</returns>
-        public static RedumpSystem? ToRedumpSystem(this KnownSystem system)
+        public static RedumpSystem? ToRedumpSystem(this KnownSystem? system)
         {
             switch (system)
             {
@@ -434,40 +435,6 @@ namespace DICUI.Utilities
             }
         }
 
-        /// <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(this MediaType? type)
-        {
-            switch (type)
-            {
-                case MediaType.CDROM:
-                case MediaType.GDROM:
-                case MediaType.Cartridge:
-                    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
@@ -508,132 +475,6 @@ namespace DICUI.Utilities
             }
         }
 
-        /// <summary>
-        /// Get the string representation of the DICCommand enum values
-        /// </summary>
-        /// <param name="command">DICCommand value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(this DICCommand command)
-        {
-            switch (command)
-            {
-                case DICCommand.Audio:
-                    return DICCommandStrings.Audio;
-                case DICCommand.BluRay:
-                    return DICCommandStrings.BluRay;
-                case DICCommand.Close:
-                    return DICCommandStrings.Close;
-                case DICCommand.CompactDisc:
-                    return DICCommandStrings.CompactDisc;
-                case DICCommand.Data:
-                    return DICCommandStrings.Data;
-                case DICCommand.DigitalVideoDisc:
-                    return DICCommandStrings.DigitalVideoDisc;
-                case DICCommand.DriveSpeed:
-                    return DICCommandStrings.DriveSpeed;
-                case DICCommand.Eject:
-                    return DICCommandStrings.Eject;
-                case DICCommand.Floppy:
-                    return DICCommandStrings.Floppy;
-                case DICCommand.GDROM:
-                    return DICCommandStrings.GDROM;
-                case DICCommand.MDS:
-                    return DICCommandStrings.MDS;
-                case DICCommand.Merge:
-                    return DICCommandStrings.Merge;
-                case DICCommand.Reset:
-                    return DICCommandStrings.Reset;
-                case DICCommand.SACD:
-                    return DICCommandStrings.SACD;
-                case DICCommand.Start:
-                    return DICCommandStrings.Start;
-                case DICCommand.Stop:
-                    return DICCommandStrings.Stop;
-                case DICCommand.Sub:
-                    return DICCommandStrings.Sub;
-                case DICCommand.Swap:
-                    return DICCommandStrings.Swap;
-                case DICCommand.XBOX:
-                    return DICCommandStrings.XBOX;
-                case DICCommand.XBOXSwap:
-                    return DICCommandStrings.XBOXSwap;
-                case DICCommand.XGD2Swap:
-                    return DICCommandStrings.XGD2Swap;
-                case DICCommand.XGD3Swap:
-                    return DICCommandStrings.XGD3Swap;
-
-                case DICCommand.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the DICFlag enum values
-        /// </summary>
-        /// <param name="command">DICFlag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(this DICFlag flag)
-        {
-            switch (flag)
-            {
-                case DICFlag.AddOffset:
-                    return DICFlagStrings.AddOffset;
-                case DICFlag.AMSF:
-                    return DICFlagStrings.AMSF;
-                case DICFlag.BEOpcode:
-                    return DICFlagStrings.BEOpcode;
-                case DICFlag.C2Opcode:
-                    return DICFlagStrings.C2Opcode;
-                case DICFlag.CopyrightManagementInformation:
-                    return DICFlagStrings.CopyrightManagementInformation;
-                case DICFlag.D8Opcode:
-                    return DICFlagStrings.D8Opcode;
-                case DICFlag.DisableBeep:
-                    return DICFlagStrings.DisableBeep;
-                case DICFlag.ForceUnitAccess:
-                    return DICFlagStrings.ForceUnitAccess;
-                case DICFlag.MCN:
-                    return DICFlagStrings.MCN;
-                case DICFlag.MultiSession:
-                    return DICFlagStrings.MultiSession;
-                case DICFlag.NoFixSubP:
-                    return DICFlagStrings.NoFixSubP;
-                case DICFlag.NoFixSubQ:
-                    return DICFlagStrings.NoFixSubQ;
-                case DICFlag.NoFixSubQLibCrypt:
-                    return DICFlagStrings.NoFixSubQLibCrypt;
-                case DICFlag.NoFixSubRtoW:
-                    return DICFlagStrings.NoFixSubRtoW;
-                case DICFlag.NoFixSubQSecuROM:
-                    return DICFlagStrings.NoFixSubQSecuROM;
-                case DICFlag.NoSkipSS:
-                    return DICFlagStrings.NoSkipSS;
-                case DICFlag.Raw:
-                    return DICFlagStrings.Raw;
-                case DICFlag.Reverse:
-                    return DICFlagStrings.Reverse;
-                case DICFlag.ScanAntiMod:
-                    return DICFlagStrings.ScanAntiMod;
-                case DICFlag.ScanFileProtect:
-                    return DICFlagStrings.ScanFileProtect;
-                case DICFlag.ScanSectorProtect:
-                    return DICFlagStrings.ScanSectorProtect;
-                case DICFlag.SeventyFour:
-                    return DICFlagStrings.SeventyFour;
-                case DICFlag.SkipSector:
-                    return DICFlagStrings.SkipSector;
-                case DICFlag.SubchannelReadLevel:
-                    return DICFlagStrings.SubchannelReadLevel;
-                case DICFlag.VideoNow:
-                    return DICFlagStrings.VideoNow;
-
-                case DICFlag.NONE:
-                default:
-                    return "";
-            }
-        }
-
         /// <summary>
         /// Get the string representation of the KnownSystem enum values
         /// </summary>
@@ -759,6 +600,8 @@ namespace DICUI.Utilities
                     return "Bally Game Magic";
                 case KnownSystem.CapcomCPSystemIII:
                     return "Capcom CP System III";
+                case KnownSystem.funworldPhotoPlay:
+                    return "funworld Photo Play";
                 case KnownSystem.GlobalVRVarious:
                     return "Global VR PC-based Systems";
                 case KnownSystem.GlobalVRVortek:
@@ -878,6 +721,8 @@ namespace DICUI.Utilities
                     return "PlayStation GameShark Updates";
                 case KnownSystem.RainbowDisc:
                     return "Rainbow Disc";
+                case KnownSystem.SegaPrologue21:
+                    return "Sega Prologue 21";
                 case KnownSystem.SuperAudioCD:
                     return "Super Audio CD";
                 case KnownSystem.TaoiKTV:
@@ -1007,6 +852,26 @@ namespace DICUI.Utilities
             }
         }
 
+        /// <summary>
+        /// Get the string representation of the LanguageSelection enum values
+        /// </summary>
+        /// <param name="lang">LanguageSelection value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this LanguageSelection? langSelect)
+        {
+            switch (langSelect)
+            {
+                case LanguageSelection.BiosSettings:
+                    return "Bios settings";
+                case LanguageSelection.LanguageSelector:
+                    return "Language selector";
+                case LanguageSelection.OptionsMenu:
+                    return "Options menu";
+                default:
+                    return string.Empty;
+            }
+        }
+
         /// <summary>
         /// Get the string representation of the MediaType enum values
         /// </summary>
@@ -1315,6 +1180,8 @@ namespace DICUI.Utilities
                     return "France, Spain";
                 case Region.Germany:
                     return "Germany";
+                case Region.GreaterChina:
+                    return "Greater China";
                 case Region.Greece:
                     return "Greece";
                 case Region.Hungary:
@@ -1375,6 +1242,8 @@ namespace DICUI.Utilities
                     return "United Arab Emirates";
                 case Region.UK:
                     return "UK";
+                case Region.UKAustralia:
+                    return "UK, Australia";
                 case Region.Ukraine:
                     return "Ukraine";
                 case Region.USA:
@@ -1383,6 +1252,8 @@ namespace DICUI.Utilities
                     return "USA, Asia";
                 case Region.USABrazil:
                     return "USA, Brazil";
+                case Region.USACanada:
+                    return "USA, Canada";
                 case Region.USAEurope:
                     return "USA, Europe";
                 case Region.USAJapan:
@@ -1542,6 +1413,8 @@ namespace DICUI.Utilities
                     return "game magic";
                 case KnownSystem.CapcomCPSystemIII:
                     return "cps3";
+                case KnownSystem.funworldPhotoPlay:
+                    return "fpp";
                 case KnownSystem.GlobalVRVarious:
                     return "globalvr";
                 case KnownSystem.GlobalVRVortek:
@@ -1661,6 +1534,8 @@ namespace DICUI.Utilities
                     return "gameshark";
                 case KnownSystem.RainbowDisc:
                     return "rainbow";
+                case KnownSystem.SegaPrologue21:
+                    return "pl21";
                 case KnownSystem.SuperAudioCD:
                     return "sacd";
                 case KnownSystem.TaoiKTV:
@@ -2072,6 +1947,8 @@ namespace DICUI.Utilities
                     return "F,S";
                 case Region.Germany:
                     return "G";
+                case Region.GreaterChina:
+                    return "GC";
                 case Region.Greece:
                     return "Gr";
                 case Region.Hungary:
@@ -2132,6 +2009,8 @@ namespace DICUI.Utilities
                     return "Ae";
                 case Region.UK:
                     return "Uk";
+                case Region.UKAustralia:
+                    return "Uk,Au";
                 case Region.Ukraine:
                     return "Ue";
                 case Region.USA:
@@ -2140,6 +2019,8 @@ namespace DICUI.Utilities
                     return "U,A";
                 case Region.USABrazil:
                     return "U,B";
+                case Region.USACanada:
+                    return "U,Ca";
                 case Region.USAEurope:
                     return "U,E";
                 case Region.USAJapan:
@@ -2158,9 +2039,9 @@ namespace DICUI.Utilities
         /// <summary>
         /// Get the Category enum value for a given string
         /// </summary>
-        /// <param name="sys">String value to convert</param>
+        /// <param name="category">String value to convert</param>
         /// <returns>Category represented by the string, if possible</returns>
-        public static Category StringToCategory(string category)
+        public static Category ToCategory(string category)
         {
             switch (category.ToLowerInvariant())
             {
@@ -2193,12 +2074,38 @@ namespace DICUI.Utilities
             }
         }
 
+        /// <summary>
+        /// Get the InternalProgram enum value for a given string
+        /// </summary>
+        /// <param name="internalProgram">String value to convert</param>
+        /// <returns>InternalProgram represented by the string, if possible</returns>
+        public static InternalProgram ToInternalProgram(string internalProgram)
+        {
+            switch (internalProgram.ToLowerInvariant())
+            {
+                case "aaru":
+                case "chef":
+                case "dichef":
+                case "discimagechef":
+                    return InternalProgram.Aaru;
+                case "creator":
+                case "dic":
+                case "dicreator":
+                case "discimagecreator":
+                    return InternalProgram.DiscImageCreator;
+                case "dd":
+                    return InternalProgram.DD;
+                default:
+                    return InternalProgram.NONE;
+            }
+        }
+
         /// <summary>
         /// Get the KnownSystem enum value for a given string
         /// </summary>
         /// <param name="sys">String value to convert</param>
         /// <returns>KnownSystem represented by the string, if possible</returns>
-        public static KnownSystem StringToKnownSystem(string sys)
+        public static KnownSystem? ToKnownSystem(string sys)
         {
             switch (sys)
             {
@@ -2584,6 +2491,11 @@ namespace DICUI.Utilities
                 case "capcom cp system 3":
                 case "capcom cp system iii":
                     return KnownSystem.CapcomCPSystemIII;
+                case "fpp":
+                case "funworldphotoplay":
+                case "funworld photoplay":
+                case "funworld photo play":
+                    return KnownSystem.funworldPhotoPlay;
                 case "globalvr":
                 case "global vr":
                 case "global vr pc-based systems":
@@ -2881,6 +2793,13 @@ namespace DICUI.Utilities
                 case "rainbowdisc":
                 case "rainbow disc":
                     return KnownSystem.RainbowDisc;
+                case "pl21":
+                case "prologue21":
+                case "prologue 21":
+                case "segaprologue21":
+                case "sega prologue21":
+                case "sega prologue 21":
+                    return KnownSystem.SegaPrologue21;
                 case "sacd":
                 case "superaudiocd":
                 case "super audio cd":
@@ -2910,9 +2829,9 @@ namespace DICUI.Utilities
         /// <summary>
         /// Get the Language enum value for a given string
         /// </summary>
-        /// <param name="sys">String value to convert</param>
+        /// <param name="lang">String value to convert</param>
         /// <returns>Language represented by the string, if possible</returns>
-        public static Language? StringToLanguage(string lang)
+        public static Language? ToLanguage(string lang)
         {
             switch (lang)
             {
@@ -2998,7 +2917,7 @@ namespace DICUI.Utilities
         /// </summary>
         /// <param name="type">String value to convert</param>
         /// <returns>MediaType represented by the string, if possible</returns>
-        public static MediaType StringToMediaType(string type)
+        public static MediaType ToMediaType(string type)
             {
                 switch (type.ToLowerInvariant())
                 {
@@ -3169,9 +3088,9 @@ namespace DICUI.Utilities
         /// <summary>
         /// Get the Region enum value for a given string
         /// </summary>
-        /// <param name="type">String value to convert</param>
+        /// <param name="region">String value to convert</param>
         /// <returns>Region represented by the string, if possible</returns>
-        public static Region? StringToRegion(string region)
+        public static Region? ToRegion(string region)
         {
             switch (region)
             {
@@ -3219,6 +3138,8 @@ namespace DICUI.Utilities
                     return Region.FranceSpain;
                 case "G":
                     return Region.Germany;
+                case "GC":
+                    return Region.GreaterChina;
                 case "Gr":
                     return Region.Greece;
                 case "H":
@@ -3279,6 +3200,8 @@ namespace DICUI.Utilities
                     return Region.UnitedArabEmirates;
                 case "Uk":
                     return Region.UK;
+                case "Uk,Au":
+                    return Region.UKAustralia;
                 case "Ue":
                     return Region.Ukraine;
                 case "U":
@@ -3287,6 +3210,8 @@ namespace DICUI.Utilities
                     return Region.USAAsia;
                 case "U,B":
                     return Region.USABrazil;
+                case "U,Ca":
+                    return Region.USACanada;
                 case "U,E":
                     return Region.USAEurope;
                 case "U,J":
@@ -3300,4 +3225,111 @@ namespace DICUI.Utilities
 
         #endregion
     }
-}
+
+    /// <summary>
+    /// Serialize KnownSystem enum values
+    /// </summary>
+    public class KnownSystemConverter : JsonConverter<KnownSystem?>
+    {
+        public override bool CanRead { get { return false; } }
+
+        public override KnownSystem? ReadJson(JsonReader reader, Type objectType, KnownSystem? existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void WriteJson(JsonWriter writer, KnownSystem? value, JsonSerializer serializer)
+        {
+            JToken t = JToken.FromObject(value.ToRedumpSystem()?.ShortName() ?? value.ShortName());
+            t.WriteTo(writer);
+        }
+    }
+
+    /// <summary>
+    /// Serialize Language enum values
+    /// </summary>
+    public class LanguagesConverter : JsonConverter<Language?[]>
+    {
+        public override bool CanRead { get { return false; } }
+
+        public override Language?[] ReadJson(JsonReader reader, Type objectType, Language?[] existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void WriteJson(JsonWriter writer, Language?[] value, JsonSerializer serializer)
+        {
+            JArray array = new JArray();
+            foreach (var val in value)
+            {
+                JToken t = JToken.FromObject(val.ShortName());
+                array.Add(t);
+            }
+
+            array.WriteTo(writer);
+        }
+    }
+
+    /// <summary>
+    /// Serialize Language enum values
+    /// </summary>
+    public class LanguageSelectionConverter : JsonConverter<LanguageSelection?[]>
+    {
+        public override bool CanRead { get { return false; } }
+
+        public override LanguageSelection?[] ReadJson(JsonReader reader, Type objectType, LanguageSelection?[] existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void WriteJson(JsonWriter writer, LanguageSelection?[] value, JsonSerializer serializer)
+        {
+            JArray array = new JArray();
+            foreach (var val in value)
+            {
+                JToken t = JToken.FromObject(val.LongName());
+                array.Add(t);
+            }
+
+            array.WriteTo(writer);
+        }
+    }
+
+    /// <summary>
+    /// Serialize MediaType enum values
+    /// </summary>
+    public class MediaTypeConverter : JsonConverter<MediaType?>
+    {
+        public override bool CanRead { get { return false; } }
+
+        public override MediaType? ReadJson(JsonReader reader, Type objectType, MediaType? existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void WriteJson(JsonWriter writer, MediaType? value, JsonSerializer serializer)
+        {
+            JToken t = JToken.FromObject(value.ShortName());
+            t.WriteTo(writer);
+        }
+    }
+
+    /// <summary>
+    /// Serialize Region enum values
+    /// </summary>
+    public class RegionConverter : JsonConverter<Region?>
+    {
+        public override bool CanRead { get { return false; } }
+
+        public override Region? ReadJson(JsonReader reader, Type objectType, Region? existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void WriteJson(JsonWriter writer, Region? value, JsonSerializer serializer)
+        {
+            JToken t = JToken.FromObject(value.ShortName());
+            t.WriteTo(writer);
+        }
+    }
+}

DICUI.Library/Utilities/Drive.cs

@@ -1,4 +1,7 @@
-namespace DICUI.Utilities
+using System.IO;
+using DICUI.Data;
+
+namespace DICUI.Utilities
 {
     /// <summary>
     /// Represents information for a single drive
@@ -6,47 +9,55 @@
     public class Drive
     {
         /// <summary>
-        /// Windows drive letter
+        /// Represents drive type
         /// </summary>
-        public char Letter { get; private set; }
+        public InternalDriveType? InternalDriveType { get; set; }
 
         /// <summary>
-        /// Represents if it is a floppy drive
+        /// DriveInfo object representing the drive, if possible
         /// </summary>
-        public bool IsFloppy { get; private set; }
+        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; private set; }
+        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; private set; }
+        public bool MarkedActive { get { return DriveInfo.IsReady; } }
 
-        private Drive(char letter, string volumeLabel, bool isFloppy, bool markedActive)
+        public Drive(InternalDriveType? driveType, DriveInfo driveInfo)
         {
-            this.Letter = letter;
-            this.IsFloppy = isFloppy;
-            this.VolumeLabel = volumeLabel;
-            this.MarkedActive = markedActive;
+            this.InternalDriveType = driveType;
+            this.DriveInfo = driveInfo;
         }
-
-        /// <summary>
-        /// Create a new Floppy drive instance
-        /// </summary>
-        /// <param name="letter">Drive letter to use</param>
-        /// <returns>Drive object for a Floppy drive</returns>
-        public static Drive Floppy(char letter) => new Drive(letter, null, true, true);
-
-        /// <summary>
-        /// Create a new Optical drive instance
-        /// </summary>
-        /// <param name="letter">Drive letter to use</param>
-        /// <param name="volumeLabel">Media label, if it exists</param>
-        /// <param name="active">True if the drive is marked active, false otherwise</param>
-        /// <returns>Drive object for an Optical drive</returns>
-        public static Drive Optical(char letter, string volumeLabel, bool active) => new Drive(letter, volumeLabel, false, active);
     }
 }

DICUI.Library/Utilities/Extensions.cs

@@ -188,6 +188,15 @@ namespace DICUI.Utilities
             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>

DICUI.Library/Utilities/Validators.cs

@@ -5,8 +5,10 @@ using System.Linq;
 using System.Management;
 using System.Threading.Tasks;
 using BurnOutSharp;
-using IMAPI2;
 using DICUI.Data;
+#if NET_FRAMEWORK
+using IMAPI2;
+#endif
 
 namespace DICUI.Utilities
 {
@@ -236,6 +238,7 @@ namespace DICUI.Utilities
                     types.Add(MediaType.CDROM);
                     types.Add(MediaType.DVD);
                     types.Add(MediaType.FloppyDisk);
+                    types.Add(MediaType.HardDisk);
                     break;
 
                 // https://en.wikipedia.org/wiki/Amiga
@@ -254,6 +257,7 @@ namespace DICUI.Utilities
                     types.Add(MediaType.CDROM);
                     types.Add(MediaType.DVD);
                     types.Add(MediaType.FloppyDisk);
+                    types.Add(MediaType.HardDisk);
                     break;
 
                 // https://en.wikipedia.org/wiki/PC-8800_series
@@ -316,6 +320,11 @@ namespace DICUI.Utilities
                     types.Add(MediaType.CDROM);
                     break;
 
+                // UNKNOWN
+                case KnownSystem.funworldPhotoPlay:
+                    types.Add(MediaType.CDROM);
+                    break;
+
                 // UNKNOWN
                 case KnownSystem.GlobalVRVarious:
                     types.Add(MediaType.CDROM);
@@ -647,6 +656,11 @@ namespace DICUI.Utilities
                     types.Add(MediaType.CDROM);
                     break;
 
+                // https://segaretro.org/Prologue_21
+                case KnownSystem.SegaPrologue21:
+                    types.Add(MediaType.CDROM);
+                    break;
+
                 // https://en.wikipedia.org/wiki/Super_Audio_CD
                 case KnownSystem.SuperAudioCD:
                     types.Add(MediaType.CDROM);
@@ -693,16 +707,28 @@ namespace DICUI.Utilities
         /// <summary>
         /// Create a list of active drives matched to their volume labels
         /// </summary>
+        /// <param name="ignoreFixedDrives">Ture to ignore fixed drives from population, false otherwise</param>
         /// <returns>Active drives, matched to labels, if possible</returns>
         /// <remarks>
         /// https://stackoverflow.com/questions/3060796/how-to-distinguish-between-usb-and-floppy-devices?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
         /// https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx
         /// </remarks>
-        public static List<Drive> CreateListOfDrives()
+        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
         {
-            var drives = new List<Drive>();
+            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
+            if (!ignoreFixedDrives)
+            {
+                desiredDriveTypes.Add(DriveType.Fixed);
+                desiredDriveTypes.Add(DriveType.Removable);
+            }
 
-            // Get the floppy drives
+            // Get all supported drive types
+            var drives = DriveInfo.GetDrives()
+                .Where(d => desiredDriveTypes.Contains(d.DriveType))
+                .Select(d => new Drive(Converters.ToInternalDriveType(d.DriveType), d))
+                .ToList();
+
+            // Get the floppy drives and set the flag from removable
             try
             {
                 ManagementObjectSearcher searcher =
@@ -716,7 +742,7 @@ namespace DICUI.Utilities
                     if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
                     {
                         char devId = queryObj["DeviceID"].ToString()[0];
-                        drives.Add(Drive.Floppy(devId));
+                        drives.ForEach(d => { if (d.Letter == devId) { d.InternalDriveType = InternalDriveType.Floppy; } });
                     }
                 }
             }
@@ -725,14 +751,7 @@ namespace DICUI.Utilities
                 // No-op
             }
 
-            // Get the optical disc drives
-            List<Drive> discDrives = DriveInfo.GetDrives()
-                .Where(d => d.DriveType == DriveType.CDRom)
-                .Select(d => Drive.Optical(d.Name[0], (d.IsReady ? (string.IsNullOrWhiteSpace(d.VolumeLabel) ? "disc" : d.VolumeLabel) : Template.DiscNotDetected), d.IsReady))                
-                .ToList();
-
-            // Add the two lists together and order
-            drives.AddRange(discDrives);
+            // Order the drives by drive letter
             drives = drives.OrderBy(i => i.Letter).ToList();
 
             return drives;
@@ -741,38 +760,42 @@ namespace DICUI.Utilities
         /// <summary>
         /// Get the current media type from drive letter
         /// </summary>
-        /// <param name="driveLetter"></param>
+        /// <param name="drive"></param>
         /// <returns></returns>
         /// <remarks>
         /// https://stackoverflow.com/questions/11420365/detecting-if-disc-is-in-dvd-drive
         /// </remarks>
-        public static MediaType? GetMediaType(char? driveLetter)
+        public static MediaType? GetMediaType(Drive drive)
         {
-            // Get the DeviceID from the current drive letter
+            // Take care of the non-optical stuff first
+            // TODO: See if any of these can be more granular, like Optical is
+            if (drive.InternalDriveType == InternalDriveType.Floppy)
+                return MediaType.FloppyDisk;
+            else if (drive.InternalDriveType == InternalDriveType.HardDisk)
+                return MediaType.HardDisk;
+            else if (drive.InternalDriveType == InternalDriveType.Removable)
+                return MediaType.FlashDrive;
+
+            // Get the DeviceID and MediaType from the current drive letter
             string deviceId = null;
+            ushort mediaType = 0;
             try
             {
-                ManagementObjectSearcher searcher =
-                    new ManagementObjectSearcher("root\\CIMV2",
-                    "SELECT * FROM Win32_CDROMDrive WHERE Id = '" + driveLetter + ":\'");
+                // Get the device ID first
+                var searcher = new ManagementObjectSearcher(
+                    "root\\CIMV2",
+                    $"SELECT * FROM Win32_CDROMDrive WHERE Id = '{drive.Letter}:\'");
 
-                var collection = searcher.Get();
-                foreach (ManagementObject queryObj in collection)
+                foreach (ManagementObject queryObj in searcher.Get())
+                {
                     deviceId = (string)queryObj["DeviceID"];
-            }
-            catch
-            {
-                // We don't care what the error was
-                return null;
-            }
+                }
 
-            // If we got no valid device, we don't care and just return
-            if (deviceId == null)
-                return null;
+                // If we got no valid device, we don't care and just return
+                if (deviceId == null)
+                    return null;
 
-            // Get all relevant disc information
-            try
-            {
+#if NET_FRAMEWORK
                 MsftDiscMaster2 discMaster = new MsftDiscMaster2();
                 deviceId = deviceId.ToLower().Replace('\\', '#');
                 string id = null;
@@ -793,33 +816,55 @@ namespace DICUI.Utilities
                 dataWriter.Recorder = recorder;
                 var media = dataWriter.CurrentPhysicalMediaType;
                 if (media != IMAPI_MEDIA_PHYSICAL_TYPE.IMAPI_MEDIA_TYPE_UNKNOWN)
-                    return Converters.ToMediaType(media);
+                    return media.IMAPIToMediaType();
+
+                return null;
+#else
+                // Now try to get the physical media associated
+                searcher = new ManagementObjectSearcher(
+                    "root\\CIMV2",
+                    $"SELECT * FROM Win32_PhysicalMedia");
+                    //$"SELECT * FROM Win32_PhysicalMedia WHERE Name = '{deviceId}'");
+
+                foreach (ManagementObject queryObj in searcher.Get())
+                {
+                    deviceId = (string)queryObj["Tag"];
+                    mediaType = (ushort)queryObj["MediaType"];
+                }
+
+                return ((PhysicalMediaType)mediaType).ToMediaType();
+#endif
+
             }
             catch
             {
-                // We don't care what the error is
+                // We don't care what the error was
+                return null;
             }
-
-            return null;
         }
 
         /// <summary>
-        /// Get the current system from drive letter
+        /// Get the current system from drive
         /// </summary>
-        /// <param name="driveLetter"></param>
+        /// <param name="drive"></param>
         /// <returns></returns>
-        public static KnownSystem? GetKnownSystem(char? driveLetter)
+        public static KnownSystem? GetKnownSystem(Drive drive)
         {
-            // If no letter is provided, then we can't do anything
-            if (driveLetter == null)
+            // If drive or drive letter are provided, we can't do anything
+            if (drive?.Letter == null)
                 return null;
 
-            string drivePath = $"{driveLetter}:\\";
+            string drivePath = $"{drive.Letter}:\\";
 
             // If we can't read the media in that drive, we can't do anything
             if (!Directory.Exists(drivePath))
                 return null;
 
+            // We're going to assume for floppies, HDDs, and removable drives
+            // TODO: Try to be smarter about this
+            if (drive.InternalDriveType != InternalDriveType.Optical)
+                return KnownSystem.IBMPCCompatible;
+
             // Sega Dreamcast
             if (File.Exists(Path.Combine(drivePath, "IP.BIN")))
             {
@@ -854,9 +899,9 @@ namespace DICUI.Utilities
                 // If we have a weird disc, just assume PS1
                 return KnownSystem.SonyPlayStation;
             }
-            
+
             // Sony PlayStation 4
-            if (File.Exists(Path.Combine(drivePath, "PSLogo.ico")))
+            if (drive.VolumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
             {
                 return KnownSystem.SonyPlayStation4;
             }
@@ -888,6 +933,10 @@ namespace DICUI.Utilities
                 case MediaType.CDROM:
                 case MediaType.DVD:
                 case MediaType.FloppyDisk:
+                case MediaType.HardDisk:
+                case MediaType.CompactFlash:
+                case MediaType.SDCard:
+                case MediaType.FlashDrive:
                 case MediaType.HDDVD:
                     return Result.Success("{0} ready to dump", type.LongName());
 
@@ -928,11 +977,12 @@ namespace DICUI.Utilities
                 if (found == null || found.Count == 0)
                     return "None found";
 
-                return string.Join("\n", found.Select(kvp => kvp.Key + ": " + kvp.Value).ToArray());
+                // Strip out "CD Check" instances due to false positives
+                return string.Join("\n", found.Where(kvp => !kvp.Value.Equals("CD Check", StringComparison.OrdinalIgnoreCase)).Select(kvp => kvp.Key + ": " + kvp.Value).ToArray());
             }
-            catch
+            catch (Exception ex)
             {
-                return "Path could not be scanned!";
+                return $"Path could not be scanned! {ex}";
             }
         }
     }

DICUI.Library/Web/CookieAwareWebClient.cs

@@ -27,7 +27,7 @@ namespace DICUI.Web
         public string GetLastFilename()
         {
             // Try to extract the filename from the Content-Disposition header
-            if (!String.IsNullOrEmpty(this.ResponseHeaders["Content-Disposition"]))
+            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/packages.config

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="BurnOutSharp" version="1.3.7.1" targetFramework="net461" />
-  <package id="LessIO" version="0.5.0" targetFramework="net461" />
-  <package id="libmspack4n" version="0.8.0" targetFramework="net461" />
-  <package id="Newtonsoft.Json" version="12.0.2" targetFramework="net461" />
-  <package id="UnshieldSharp" version="1.4.2.2" targetFramework="net461" />
-  <package id="zlib.net" version="1.0.4.0" targetFramework="net461" />
-</packages>

DICUI.Test/DICUI.Test.csproj

@@ -1,83 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.props" Condition="Exists('..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.props')" />
-  <Import Project="..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.props" Condition="Exists('..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.props')" />
-  <Import Project="..\packages\xunit.runner.visualstudio.2.3.1\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.3.1\build\net20\xunit.runner.visualstudio.props')" />
-  <Import Project="..\packages\xunit.runner.console.2.3.1\build\xunit.runner.console.props" Condition="Exists('..\packages\xunit.runner.console.2.3.1\build\xunit.runner.console.props')" />
-  <Import Project="..\packages\xunit.core.2.3.1\build\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.3.1\build\xunit.core.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{7CC064D2-38AB-4A05-8519-28660DE4562A}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>DICUI.Test</RootNamespace>
-    <AssemblyName>DICUI.Test</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">15.0</VisualStudioVersion>
-    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
-    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
-    <IsCodedUITest>False</IsCodedUITest>
-    <TestProjectType>UnitTest</TestProjectType>
-    <NuGetPackageImportStamp>
-    </NuGetPackageImportStamp>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <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' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="Microsoft.VisualStudio.CodeCoverage.Shim, Version=15.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.CodeCoverage.15.8.0\lib\net45\Microsoft.VisualStudio.CodeCoverage.Shim.dll</HintPath>
-    </Reference>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.abstractions.2.0.1\lib\net35\xunit.abstractions.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.assert, Version=2.3.1.3858, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.assert.2.3.1\lib\netstandard1.1\xunit.assert.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.core, Version=2.3.1.3858, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.core.2.3.1\lib\netstandard1.1\xunit.core.dll</HintPath>
-    </Reference>
-    <Reference Include="xunit.execution.desktop, Version=2.3.1.3858, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
-      <HintPath>..\packages\xunit.extensibility.execution.2.3.1\lib\net452\xunit.execution.desktop.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="UI\AllowedSpeedsTest.cs" />
-    <Compile Include="Utilities\DumpEnvironmentTest.cs" />
-    <Compile Include="ResultTest.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Utilities\DriveTest.cs" />
-    <Compile Include="Utilities\ConvertersTest.cs" />
-    <Compile Include="Utilities\KnownSystemExtensionsTest.cs" />
-    <Compile Include="Utilities\MediaTypeExtensionsTest.cs" />
-    <Compile Include="Utilities\ParametersTest.cs" />
-    <Compile Include="Utilities\ValidatorsTest.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="packages.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <Analyzer Include="..\packages\xunit.analyzers.0.10.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
-  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\DICUI.Library\DICUI.Library.csproj">
       <Project>{51ab0928-13f9-44bf-a407-b6957a43a056}</Project>
@@ -88,22 +15,19 @@
       <Name>DICUI</Name>
     </ProjectReference>
   </ItemGroup>
-  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\xunit.core.2.3.1\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.3.1\build\xunit.core.props'))" />
-    <Error Condition="!Exists('..\packages\xunit.core.2.3.1\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.3.1\build\xunit.core.targets'))" />
-    <Error Condition="!Exists('..\packages\xunit.runner.console.2.3.1\build\xunit.runner.console.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.console.2.3.1\build\xunit.runner.console.props'))" />
-    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.3.1\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.3.1\build\net20\xunit.runner.visualstudio.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.targets'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.props'))" />
-    <Error Condition="!Exists('..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.targets'))" />
-  </Target>
-  <Import Project="..\packages\xunit.core.2.3.1\build\xunit.core.targets" Condition="Exists('..\packages\xunit.core.2.3.1\build\xunit.core.targets')" />
-  <Import Project="..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.targets" Condition="Exists('..\packages\Microsoft.CodeCoverage.15.8.0\build\netstandard1.0\Microsoft.CodeCoverage.targets')" />
-  <Import Project="..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.targets" Condition="Exists('..\packages\Microsoft.NET.Test.Sdk.15.8.0\build\net45\Microsoft.Net.Test.Sdk.targets')" />
-</Project>
+
+  <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/Properties/AssemblyInfo.cs

@@ -1,20 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("DICUI.Test")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("DICUI.Test")]
-[assembly: AssemblyCopyright("Copyright ©  2018")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-[assembly: ComVisible(false)]
-
-[assembly: Guid("7cc064d2-38ab-4a05-8519-28660de4562a")]
-
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]

DICUI.Test/Utilities/ConvertersTest.cs

@@ -8,50 +8,50 @@ namespace DICUI.Test.Utilities
     public class ConvertersTest
     {
         [Theory]
-        [InlineData(DICCommand.Audio, MediaType.CDROM)]
-        [InlineData(DICCommand.BluRay, MediaType.BluRay)]
-        [InlineData(DICCommand.Close, null)]
-        [InlineData(DICCommand.CompactDisc, MediaType.CDROM)]
-        [InlineData(DICCommand.Data, MediaType.CDROM)]
-        [InlineData(DICCommand.DigitalVideoDisc, MediaType.DVD)]
-        [InlineData(DICCommand.Eject, null)]
-        [InlineData(DICCommand.Floppy, MediaType.FloppyDisk)]
-        [InlineData(DICCommand.GDROM, MediaType.GDROM)]
-        [InlineData(DICCommand.MDS, null)]
-        [InlineData(DICCommand.Reset, null)]
-        [InlineData(DICCommand.SACD, MediaType.CDROM)]
-        [InlineData(DICCommand.Start, null)]
-        [InlineData(DICCommand.Stop, null)]
-        [InlineData(DICCommand.Sub, null)]
-        [InlineData(DICCommand.Swap, MediaType.GDROM)]
-        [InlineData(DICCommand.XBOX, MediaType.DVD)]
-        public void BaseCommandToMediaTypeTest(DICCommand command, MediaType? expected)
+        [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 = command.ToMediaType();
+            MediaType? actual = DiscImageCreator.Converters.ToMediaType(command);
             Assert.Equal(expected, actual);
         }
 
         [Theory]
-        [InlineData(DICCommand.Audio, KnownSystem.AudioCD)]
-        [InlineData(DICCommand.BluRay, KnownSystem.SonyPlayStation3)]
-        [InlineData(DICCommand.Close, null)]
-        [InlineData(DICCommand.CompactDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DICCommand.Data, KnownSystem.IBMPCCompatible)]
-        [InlineData(DICCommand.DigitalVideoDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DICCommand.Eject, null)]
-        [InlineData(DICCommand.Floppy, KnownSystem.IBMPCCompatible)]
-        [InlineData(DICCommand.GDROM, KnownSystem.SegaDreamcast)]
-        [InlineData(DICCommand.MDS, null)]
-        [InlineData(DICCommand.Reset, null)]
-        [InlineData(DICCommand.SACD, KnownSystem.SuperAudioCD)]
-        [InlineData(DICCommand.Start, null)]
-        [InlineData(DICCommand.Stop, null)]
-        [InlineData(DICCommand.Sub, null)]
-        [InlineData(DICCommand.Swap, KnownSystem.SegaDreamcast)]
-        [InlineData(DICCommand.XBOX, KnownSystem.MicrosoftXBOX)]
-        public void BaseCommandToKnownSystemTest(DICCommand command, KnownSystem? expected)
+        [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 = Converters.ToKnownSystem(command);
+            KnownSystem? actual = DiscImageCreator.Converters.ToKnownSystem(command);
             Assert.Equal(expected, actual);
         }
 
@@ -65,7 +65,7 @@ namespace DICUI.Test.Utilities
         [InlineData(MediaType.NONE, null)]
         public void MediaTypeToExtensionTest(MediaType? mediaType, string expected)
         {
-            string actual = Converters.Extension(mediaType);
+            string actual = DiscImageCreator.Converters.Extension(mediaType);
             Assert.Equal(expected, actual);
         }
 

DICUI.Test/Utilities/DriveTest.cs

@@ -1,15 +0,0 @@
-using DICUI.Utilities;
-using Xunit;
-
-namespace DICUI.Test.Utilities
-{
-    public class DriveTest
-    {
-        [Fact]
-        public void DriveConstructorsTest()
-        {
-            Assert.True(Drive.Floppy('a').IsFloppy);
-            Assert.False(Drive.Optical('d', "test", true).IsFloppy);
-        }
-    }
-}

DICUI.Test/Utilities/DumpEnvironmentTest.cs

@@ -1,4 +1,5 @@
-using DICUI.Data;
+using System.IO;
+using DICUI.Data;
 using DICUI.Utilities;
 using Xunit;
 
@@ -17,8 +18,10 @@ namespace DICUI.Test
         {
             var env = new DumpEnvironment
             {
-                DICParameters = new Parameters(parameters),
-                Drive = isFloppy ? Drive.Floppy(letter) : Drive.Optical(letter, "", true),
+                Parameters = new DiscImageCreator.Parameters(parameters),
+                Drive = isFloppy
+                    ? new Drive(InternalDriveType.Floppy, new DriveInfo(letter.ToString()))
+                    : new Drive(InternalDriveType.Optical, new DriveInfo(letter.ToString())),
                 Type = mediaType,
             };
 
@@ -31,10 +34,10 @@ namespace DICUI.Test
         [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")]
+        [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 env = new DumpEnvironment

DICUI.Test/Utilities/MediaTypeExtensionsTest.cs

@@ -26,7 +26,7 @@ namespace DICUI.Test.Utilities
         [InlineData(MediaType.NONE, null)]
         public void ExtensionTest(MediaType? mediaType, string expected)
         {
-            string actual = mediaType.Extension();
+            string actual = DiscImageCreator.Converters.Extension(mediaType);
 
             Assert.Equal(expected, actual);
         }

DICUI.Test/Utilities/ParametersTest.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using DICUI.Data;
+using DICUI.DiscImageCreator;
 using DICUI.Utilities;
 using Xunit;
 
@@ -9,39 +10,39 @@ namespace DICUI.Test.Utilities
     public class ParametersTest
     {
         [Theory]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.CDROM, DICCommand.CompactDisc)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.DVD, DICCommand.XBOX)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.LaserDisc, DICCommand.NONE)]
-        [InlineData(KnownSystem.SegaNu, MediaType.BluRay, DICCommand.BluRay)]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.FloppyDisk, DICCommand.Floppy)]
-        [InlineData(KnownSystem.RawThrillsVarious, MediaType.GDROM, DICCommand.NONE)]
-        public void ParametersFromSystemAndTypeTest(KnownSystem? knownSystem, MediaType? mediaType, DICCommand expected)
+        [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)
         {
-            Parameters actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, true, -1);
-            Assert.Equal(expected, actual.Command);
+            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 DICFlag[] { DICFlag.Raw })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 20, null, new DICFlag[] { })]
+        [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 DICFlag[] { DICFlag.C2Opcode, DICFlag.NoFixSubQSecuROM, DICFlag.ScanFileProtect, DICFlag.ScanSectorProtect, DICFlag.SubchannelReadLevel })]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new DICFlag[] { DICFlag.C2Opcode, DICFlag.NoFixSubQSecuROM, DICFlag.ScanFileProtect })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, true, 500, null, new DICFlag[] { DICFlag.CopyrightManagementInformation, DICFlag.ScanFileProtect })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new DICFlag[] { DICFlag.CopyrightManagementInformation })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 500, null, new DICFlag[] { })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new DICFlag[] { })]
+        [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 DICFlag[] { DICFlag.C2Opcode })]
-        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new DICFlag[] { DICFlag.C2Opcode })]
+        [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, DICFlag[] expected)
+        public void ParametersFromOptionsTest(KnownSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, Flag[] expected)
         {
-            Parameters actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, paranoid, rereadC2);
+            var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, paranoid, false, rereadC2);
 
-            HashSet<DICFlag> expectedSet = new HashSet<DICFlag>(expected ?? new DICFlag[0]);
-            HashSet<DICFlag> actualSet = new HashSet<DICFlag>(actual.Keys ?? new DICFlag[0]);
+            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]);
@@ -50,23 +51,6 @@ namespace DICUI.Test.Utilities
             Assert.Equal(subchannelLevel, actual.SubchannelReadLevelValue);
         }
 
-        [Theory]
-        [InlineData(null, null, null, null, null)]
-        [InlineData("", null, null, null, null)]
-        [InlineData("cd F test.bin 8 /c2 20", MediaType.CDROM, KnownSystem.IBMPCCompatible, "F", "test.bin")]
-        [InlineData("fd A blah\\test.img", MediaType.FloppyDisk, KnownSystem.IBMPCCompatible, "A", "blah\\test.img")]
-        [InlineData("dvd X super\\blah\\test.iso 8 /raw", MediaType.NintendoGameCubeGameDisc, KnownSystem.NintendoGameCube, "X", "super\\blah\\test.iso")]
-        [InlineData("stop D", null, null, "D", null)]
-        public void DetermineFlagsTest(string parameters, MediaType? expectedMediaType, KnownSystem? expectedKnownSystem, string expectedDriveLetter, string expectedPath)
-        {
-            Parameters actualParams = new Parameters(parameters);
-            bool actual = actualParams.DetermineFlags(out MediaType? actualMediaType, out KnownSystem? actualKnownSystem, out string actualDriveLetter, out string actualPath);
-            Assert.Equal(expectedMediaType, actualMediaType);
-            Assert.Equal(expectedKnownSystem, actualKnownSystem);
-            Assert.Equal(expectedDriveLetter, actualDriveLetter);
-            Assert.Equal(expectedPath, actualPath);
-        }
-
         [Theory]
         [InlineData(null, false)]
         [InlineData("", false)]
@@ -78,7 +62,7 @@ namespace DICUI.Test.Utilities
         [InlineData("ls", false)]
         public void ValidateParametersTest(string parameters, bool expected)
         {
-            Parameters actual = new Parameters(parameters);
+            var actual = new Parameters(parameters);
             Assert.Equal(expected, actual.IsValid());
         }
     }

DICUI.Test/packages.config

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Microsoft.CodeCoverage" version="15.8.0" targetFramework="net461" />
-  <package id="Microsoft.NET.Test.Sdk" version="15.8.0" targetFramework="net461" />
-  <package id="xunit" version="2.3.1" targetFramework="net461" />
-  <package id="xunit.abstractions" version="2.0.1" targetFramework="net461" />
-  <package id="xunit.analyzers" version="0.10.0" targetFramework="net461" />
-  <package id="xunit.assert" version="2.3.1" targetFramework="net461" />
-  <package id="xunit.core" version="2.3.1" targetFramework="net461" />
-  <package id="xunit.extensibility.core" version="2.3.1" targetFramework="net461" />
-  <package id="xunit.extensibility.execution" version="2.3.1" targetFramework="net461" />
-  <package id="xunit.runner.console" version="2.3.1" targetFramework="net461" developmentDependency="true" />
-  <package id="xunit.runner.visualstudio" version="2.3.1" targetFramework="net461" developmentDependency="true" />
-</packages>

DICUI.sln

@@ -11,6 +11,13 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI.Library", "DICUI.Libr
 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
 		Debug|Any CPU = Debug|Any CPU

DICUI/App.config

@@ -1,12 +1,16 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <appSettings>
-    <add key="DICPath" value="Programs\DiscImageCreator.exe"/>
-    <add key="SubDumpPath" value="subdump.exe"/>
+    <add key="AaruPath" value="Programs\Aaru\Aaru.exe"/>
+    <add key="CreatorPath" value="Programs\Creator\DiscImageCreator.exe"/>
+    <add key="SubDumpPath" value="Programs\Subdump\subdump.exe"/>
     <add key="DefaultOutputPath" value="ISO"/>
-    <add key="PreferredDumpSpeedCD" value="72"/>
+    <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"/>
@@ -15,8 +19,12 @@
     <add key="RereadAmountForC2" value="20"/>
     <add key="VerboseLogging" value="true"/>
     <add key="OpenLogWindowAtStartup" value="true"/>
-    <add key="AddPlaceholders" 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>
-</configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/></startup></configuration>

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

@@ -1,153 +1,28 @@
-<?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')" />
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{7B1B75EB-8940-466F-BD51-76471A57F9BE}</ProjectGuid>
+    <TargetFrameworks>net462;net472;net48;netcoreapp3.1</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <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>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </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>
+    <UseWindowsForms>true</UseWindowsForms>
+    <UseWPF>true</UseWPF>
+    <Prefer32Bit>true</Prefer32Bit>
     <ApplicationIcon>Icon.ico</ApplicationIcon>
   </PropertyGroup>
-  <PropertyGroup>
-    <ManifestCertificateThumbprint>654CEE5FEAF46C8C1C369D7ED34DA157828A8D2F</ManifestCertificateThumbprint>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ManifestKeyFile>WpfApp1_TemporaryKey.pfx</ManifestKeyFile>
-  </PropertyGroup>
-  <PropertyGroup>
-    <GenerateManifests>true</GenerateManifests>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignManifests>false</SignManifests>
-  </PropertyGroup>
-  <PropertyGroup />
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Configuration" />
-    <Reference Include="System.Drawing" />
-    <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.Xaml">
-      <RequiredTargetFramework>4.0</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="WindowsBase" />
-    <Reference Include="PresentationCore" />
-    <Reference Include="PresentationFramework" />
-  </ItemGroup>
-  <ItemGroup>
-    <ApplicationDefinition Include="App.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </ApplicationDefinition>
-    <Compile Include="Constants.cs" />
-    <Compile Include="EnumDescriptionConverter.cs" />
-    <Compile Include="MediaTypeComboBoxItem.cs" />
-    <Compile Include="Options.cs" />
-    <Compile Include="Windows\LogWindow.xaml.cs">
-      <DependentUpon>LogWindow.xaml</DependentUpon>
-    </Compile>
-    <Compile Include="Windows\OptionsWindow.xaml.cs">
-      <DependentUpon>OptionsWindow.xaml</DependentUpon>
-    </Compile>
-    <Compile Include="KnownSystemComboBoxItem.cs" />
-    <Compile Include="ViewModels.cs" />
-    <Page Include="Windows\LogWindow.xaml">
-      <SubType>Designer</SubType>
-      <Generator>MSBuild:Compile</Generator>
-    </Page>
-    <Page Include="Windows\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="Windows\MainWindow.xaml.cs">
-      <DependentUpon>MainWindow.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-    <Page Include="Windows\OptionsWindow.xaml">
-      <SubType>Designer</SubType>
-      <Generator>MSBuild:Compile</Generator>
-    </Page>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Properties\AssemblyInfo.cs">
-      <SubType>Code</SubType>
-    </Compile>
-  </ItemGroup>
+
   <ItemGroup>
     <None Include="App.config" />
   </ItemGroup>
+
   <ItemGroup>
-    <BootstrapperPackage Include=".NETFramework,Version=v4.6.1">
-      <Visible>False</Visible>
-      <ProductName>Microsoft .NET Framework 4.6.1 %28x86 and x64%29</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="Icon.ico" />
+    <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>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+
 </Project>

DICUI/EnumDescriptionConverter.cs

@@ -13,14 +13,13 @@ namespace DICUI
     {
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            if (value is DICCommand)
-                return ((DICCommand)value).LongName();
-            else if (value is DICFlag)
-                return ((DICFlag)value).LongName();
-            else if (value is MediaType?)
+            // Common
+            if (value is MediaType?)
                 return ((MediaType?)value).LongName();
             else if (value is KnownSystem?)
                 return ((KnownSystem?)value).LongName();
+
+            // Default
             else
                 return "";
         }

DICUI/Options.cs

@@ -9,9 +9,12 @@ namespace DICUI
     public class Options
     {
         public string DefaultOutputPath { get; private set; }
-        public string DICPath { get; private set; }
+        public string AaruPath { get; private set; }
+        public string CreatorPath { get; private set; }
         public string SubDumpPath { get; private set; }
 
+        public string InternalProgram { get; set; }
+
         public int PreferredDumpSpeedCD { get; set; }
         public int PreferredDumpSpeedDVD { get; set; }
         public int PreferredDumpSpeedBD { get; set; }
@@ -21,6 +24,9 @@ namespace DICUI
         public bool ScanForProtection { get; set; }
         public int RereadAmountForC2 { get; set; }
         public bool AddPlaceholders { get; set; }
+        public bool PromptForDiscInformation { get; set; }
+        public bool IgnoreFixedDrives { get; set; }
+        public bool ResetDriveAfterDump { get; set; }
 
         public bool SkipMediaTypeDetection { get; set; }
         public bool SkipSystemDetection { get; set; }
@@ -38,13 +44,13 @@ namespace DICUI
             //TODO: reflection is used
             //TODO: is remove needed, doesn't the value get directly overridden
             Array.ForEach(
-                GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance), 
+                GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance),
                 p => {
                     configFile.AppSettings.Settings.Remove(p.Name);
                     configFile.AppSettings.Settings.Add(p.Name, Convert.ToString(p.GetValue(this)));
                 }
             );
-            
+
             configFile.Save(ConfigurationSaveMode.Modified);
         }
 
@@ -53,9 +59,11 @@ namespace DICUI
             Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
 
             //TODO: hardcoded, we should find a better way
-            this.DICPath = GetStringSetting(configFile, "DICPath", "Programs\\DiscImageCreator.exe");
-            this.SubDumpPath = GetStringSetting(configFile, "SubDumpPath", "subdump.exe");
+            this.AaruPath = GetStringSetting(configFile, "AaruPath", "Programs\\Aaru\\Aaru.exe");
+            this.CreatorPath = GetStringSetting(configFile, "CreatorPath", "Programs\\Creator\\DiscImageCreator.exe");
+            this.SubDumpPath = GetStringSetting(configFile, "SubDumpPath", "Programs\\Subdump\\subdump.exe");
             this.DefaultOutputPath = GetStringSetting(configFile, "DefaultOutputPath", "ISO");
+            this.InternalProgram = GetStringSetting(configFile, "InternalProgram", Data.InternalProgram.DiscImageCreator.ToString());
 
             this.PreferredDumpSpeedCD = GetInt32Setting(configFile, "PreferredDumpSpeedCD", 72);
             this.PreferredDumpSpeedDVD = GetInt32Setting(configFile, "PreferredDumpSpeedDVD", 24);
@@ -70,6 +78,9 @@ namespace DICUI
             this.VerboseLogging = GetBooleanSetting(configFile, "VerboseLogging", true);
             this.OpenLogWindowAtStartup = GetBooleanSetting(configFile, "OpenLogWindowAtStartup", true);
             this.AddPlaceholders = GetBooleanSetting(configFile, "AddPlaceholders", true);
+            this.PromptForDiscInformation = GetBooleanSetting(configFile, "PromptForDiscInformation", true);
+            this.IgnoreFixedDrives = GetBooleanSetting(configFile, "IgnoreFixedDrives", false);
+            this.ResetDriveAfterDump = GetBooleanSetting(configFile, "ResetDriveAfterDump", false);
 
             this.Username = GetStringSetting(configFile, "Username", "");
             this.Password = GetStringSetting(configFile, "Password", "");

DICUI/Properties/AssemblyInfo.cs

@@ -12,7 +12,7 @@ using System.Windows;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("DICUI")]
-[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -51,8 +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.13")]
-[assembly: AssemblyFileVersion("1.13.0.0")]
+[assembly: AssemblyVersion("1.16")]
+[assembly: AssemblyFileVersion("1.16.0.0")]
 
 // Anything marked as internal can be used by the test methods
 [assembly: InternalsVisibleTo("DICUI.Test")]

DICUI/ViewModels.cs

@@ -13,6 +13,12 @@ namespace DICUI
             this._options = options;
         }
 
+        public string InternalProgram
+        {
+            get { return _options.InternalProgram; }
+            set { _options.InternalProgram = value; }
+        }
+
         public bool QuietMode
         {
             get { return _options.QuietMode; }
@@ -31,6 +37,40 @@ namespace DICUI
             set { _options.ScanForProtection = value; }
         }
 
+        public string RereadAmountForC2
+        {
+            get { return Convert.ToString(_options.RereadAmountForC2); }
+            set
+            {
+                if (Int32.TryParse(value, out int result))
+                    _options.RereadAmountForC2 = result;
+            }
+        }
+
+        public bool AddPlaceholders
+        {
+            get { return _options.AddPlaceholders; }
+            set { _options.AddPlaceholders = value; }
+        }
+
+        public bool PromptForDiscInformation
+        {
+            get { return _options.PromptForDiscInformation; }
+            set { _options.PromptForDiscInformation = value; }
+        }
+
+        public bool IgnoreFixedDrives
+        {
+            get { return _options.IgnoreFixedDrives; }
+            set { _options.IgnoreFixedDrives = value; }
+        }
+
+        public bool ResetDriveAfterDump
+        {
+            get { return _options.ResetDriveAfterDump; }
+            set { _options.ResetDriveAfterDump = value; }
+        }
+
         public bool SkipMediaTypeDetection
         {
             get { return _options.SkipMediaTypeDetection; }
@@ -43,16 +83,6 @@ namespace DICUI
             set { _options.SkipSystemDetection = value; }
         }
 
-        public string RereadAmountForC2
-        {
-            get { return Convert.ToString(_options.RereadAmountForC2); }
-            set
-            {
-                if (Int32.TryParse(value, out int result))
-                    _options.RereadAmountForC2 = result;
-            }
-        }
-
         public bool VerboseLogging
         {
             get { return _options.VerboseLogging; }
@@ -72,6 +102,18 @@ namespace DICUI
                 _options.Save();
             }
         }
+
+        public string Username
+        {
+            get { return _options.Username; }
+            set { _options.Username = value; }
+        }
+
+        public string Password
+        {
+            get { return _options.Password; }
+            set { _options.Password = value; }
+        }
     }
 
     public class 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

@@ -28,7 +28,8 @@
             <Grid.ColumnDefinitions>
                 <ColumnDefinition />
                 <ColumnDefinition />
-                <ColumnDefinition Width="4*"/>
+                <ColumnDefinition Width="3*"/>
+                <ColumnDefinition />
                 <ColumnDefinition />
                 <ColumnDefinition />
             </Grid.ColumnDefinitions>
@@ -45,6 +46,7 @@
             />
             <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>
         

DICUI/Windows/LogWindow.xaml.cs

@@ -192,12 +192,12 @@ namespace DICUI.Windows
         // this is used to optimize the work since we need to process A LOT of text
         struct Matcher
         {
-            private readonly String prefix;
+            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)
+            public Matcher(string prefix, string regex, Action<Match> lambda)
             {
                 this.prefix = prefix;
                 this.regex = new Regex(regex);
@@ -363,6 +363,20 @@ namespace DICUI.Windows
         {
             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)
         {

DICUI/Windows/MainWindow.xaml

@@ -5,7 +5,7 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:DICUI"
         mc:Ignorable="d"
-        Title="Disc Image Creator GUI" Height="450" Width="600" WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize" 
+        Title="DICUI" Height="450" Width="600" WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize" 
         LocationChanged="MainWindowLocationChanged" Activated="MainWindowActivated" Closing="MainWindowClosing">
 
     <Window.Resources>
@@ -27,17 +27,18 @@
         <StackPanel VerticalAlignment="Top" Grid.ColumnSpan="4">
             <Menu Width="Auto" Height="20" >
                 <MenuItem Header="_File">
-                    <MenuItem x:Name="AppExit" Header="E_xit" HorizontalAlignment="Left" Width="140" Click="AppExitClick" />
+                    <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="140" Click="OptionsClick"/>
-                    <MenuItem x:Name="ShowLogMenuItem" Header="Show _Log Window" IsCheckable="true" HorizontalAlignment="Left"
+                    <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="140" Click="AboutClick"/>
+                    <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>

DICUI/Windows/MainWindow.xaml.cs

@@ -3,11 +3,14 @@ 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
 {
@@ -26,6 +29,9 @@ namespace DICUI.Windows
         private Options _options;
         private OptionsWindow _optionsWindow;
 
+        // User input related
+        private DiscInformationWindow _discInformationWindow;
+
         private LogWindow _logWindow;
 
         public MainWindow()
@@ -102,6 +108,12 @@ namespace DICUI.Windows
                     ViewModels.LoggerViewModel.VerboseLogLn($"Ejecting disc in drive {_env.Drive.Letter}");
                     _env.EjectDisc();
                 }
+
+                if (_options.ResetDriveAfterDump)
+                {
+                    ViewModels.LoggerViewModel.VerboseLogLn($"Resetting drive {_env.Drive.Letter}");
+                    _env.ResetDrive();
+                }
             }
         }
 
@@ -132,6 +144,7 @@ namespace DICUI.Windows
 
             ViewModels.LoggerViewModel.VerboseLogLn("Changed system to: {0}", (SystemTypeComboBox.SelectedItem as KnownSystemComboBoxItem).Name);
             PopulateMediaType();
+            GetOutputNames(false);
             EnsureDiscInformation();
         }
 
@@ -144,7 +157,7 @@ namespace DICUI.Windows
                 SetSupportedDriveSpeed();
             }
 
-            GetOutputNames();
+            GetOutputNames(false);
             EnsureDiscInformation();
         }
 
@@ -152,7 +165,7 @@ namespace DICUI.Windows
         {
             CacheCurrentDiscType();
             SetCurrentDiscType();
-            GetOutputNames();
+            GetOutputNames(true);
             SetSupportedDriveSpeed();
         }
 
@@ -218,11 +231,10 @@ namespace DICUI.Windows
 
         private void AboutClick(object sender, RoutedEventArgs e)
         {
-            MessageBox.Show($"ReignStumble - Project Lead / UI Design{Environment.NewLine}" +
-                $"darksabre76 - Project Co-Lead / Backend Design{Environment.NewLine}" +
-                $"Jakz - Feature Contributor{Environment.NewLine}" +
-                $"NHellFire - Feature Contributor{Environment.NewLine}" +
-                $"Dizzzy - Concept/Ideas/Beta tester{Environment.NewLine}", "About", MessageBoxButton.OK, MessageBoxImage.Information);
+            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)
@@ -243,9 +255,44 @@ namespace DICUI.Windows
             _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()
         {
-            GetOutputNames();
+            PopulateDrives();
+            GetOutputNames(false);
             SetSupportedDriveSpeed();
             EnsureDiscInformation();
         }
@@ -322,21 +369,32 @@ namespace DICUI.Windows
             DiskScanButton.IsEnabled = true;
 
             // Populate the list of drives and add it to the combo box
-            _drives = Validators.CreateListOfDrives();
+            _drives = Validators.CreateListOfDrives(_options.IgnoreFixedDrives);
             DriveLetterComboBox.ItemsSource = _drives;
 
             if (DriveLetterComboBox.Items.Count > 0)
             {
-                int index = _drives.FindIndex(d => d.MarkedActive);
+                // 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 optical disc type
+                // Get the current media type
                 if (!_options.SkipSystemDetection && index != -1)
                 {
                     ViewModels.LoggerViewModel.VerboseLog("Trying to detect system for drive {0}.. ", _drives[index].Letter);
-                    var currentSystem = Validators.GetKnownSystem(_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)
@@ -349,7 +407,7 @@ namespace DICUI.Windows
                 // 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)));
+                ViewModels.LoggerViewModel.VerboseLogLn("Found {0} drives: {1}", _drives.Count, string.Join(", ", _drives.Select(d => d.Letter)));
             }
             else
             {
@@ -387,7 +445,7 @@ namespace DICUI.Windows
             {
                 // Paths to tools
                 SubdumpPath = _options.SubDumpPath,
-                DICPath = _options.DICPath,
+                InternalProgram = Converters.ToInternalProgram(_options.InternalProgram),
 
                 OutputDirectory = OutputDirectoryTextBox.Text,
                 OutputFilename = OutputFilenameTextBox.Text,
@@ -395,13 +453,12 @@ namespace DICUI.Windows
                 // Get the currently selected options
                 Drive = DriveLetterComboBox.SelectedItem as Drive,
 
-                DICParameters = new Parameters(ParametersTextBox.Text),
-
                 QuietMode = _options.QuietMode,
                 ParanoidMode = _options.ParanoidMode,
                 ScanForProtection = _options.ScanForProtection,
                 RereadAmountC2 = _options.RereadAmountForC2,
                 AddPlaceholders = _options.AddPlaceholders,
+                PromptForDiscInformation = _options.PromptForDiscInformation,
 
                 Username = _options.Username,
                 Password = _options.Password,
@@ -410,8 +467,18 @@ namespace DICUI.Windows
                 Type = MediaTypeComboBox.SelectedItem as MediaType?,
             };
 
-            // Fix the output paths
-            env.FixOutputPaths();
+            // Set parameters and path accordingly
+            env.SetParameters(ParametersTextBox.Text);
+            switch (env.InternalProgram)
+            {
+                case InternalProgram.Aaru:
+                    env.Parameters.Path = _options.AaruPath;
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    env.Parameters.Path = _options.CreatorPath;
+                    break;
+            }
 
             // Disable automatic reprocessing of the textboxes until we're done
             OutputDirectoryTextBox.TextChanged -= OutputDirectoryTextBoxTextChanged;
@@ -449,11 +516,14 @@ namespace DICUI.Windows
                 // If "No", then we continue with the current known environment
             }
 
+            // Fix the output paths
+            _env.FixOutputPaths();
+
             try
             {
-                // Check for the firmware first
+                // Check for the firmware first for DiscImageCreator
                 // TODO: Remove this (and method) once DIC end-to-end logging becomes a thing
-                if (!await _env.DriveHasLatestFimrware())
+                if (_env.InternalProgram == InternalProgram.DiscImageCreator && !await _env.DriveHasLatestFimrware())
                 {
                     MessageBox.Show($"DiscImageCreator has reported that drive {_env.Drive.Letter} is not updated to the most recent firmware. Please update the firmware for your drive and try again.", "Outdated Firmware", MessageBoxButton.OK, MessageBoxImage.Error);
                     return;
@@ -488,7 +558,52 @@ namespace DICUI.Windows
 
                 var progress = new Progress<Result>();
                 progress.ProgressChanged += ProgressUpdated;
-                Result result = await _env.StartDumping(progress);
+                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)
+                {
+                    // TODO: Remove Aaru handling when irrelevant
+                    if (_env.InternalProgram == InternalProgram.Aaru)
+                    {
+                        ViewModels.LoggerViewModel.VerboseLogLn("Aaru does not support split tracks or DiscImageCreator-compatible outputs");
+                        ViewModels.LoggerViewModel.VerboseLogLn("No automatic submission information will be gathered for this disc");
+                    }
+                    else
+                    {
+                        // Verify dump output and save it
+                        result = _env.VerifyAndSaveDumpOutput(progress,
+                            EjectWhenDoneCheckBox.IsChecked,
+                            _options.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);
@@ -502,12 +617,6 @@ namespace DICUI.Windows
                 StartStopButton.Content = Constants.StartDumping;
                 CopyProtectScanButton.IsEnabled = true;
             }
-
-            if (EjectWhenDoneCheckBox.IsChecked == true)
-            {
-                ViewModels.LoggerViewModel.VerboseLogLn($"Ejecting disc in drive {_env.Drive.Letter}");
-                _env.EjectDisc();
-            }
         }
 
         /// <summary>
@@ -548,14 +657,36 @@ namespace DICUI.Windows
         /// <summary>
         /// Get the default output directory name from the currently selected drive
         /// </summary>
-        private void GetOutputNames()
+        /// <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?;
 
-            OutputDirectoryTextBox.Text = Path.Combine(_options.DefaultOutputPath, drive?.VolumeLabel ?? string.Empty);
-            OutputFilenameTextBox.Text = (drive?.VolumeLabel ?? "disc") + (mediaType.Extension() ?? ".bin");
+            // Set the output directory, if we changed drives or it's not already
+            if (driveChanged || string.IsNullOrEmpty(OutputDirectoryTextBox.Text))
+                OutputDirectoryTextBox.Text = Path.Combine(_options.DefaultOutputPath, drive?.VolumeLabel ?? string.Empty);
+
+            // Get the extension for the file for the next two statements
+            string extension = null;
+            switch (_env.InternalProgram)
+            {
+                case InternalProgram.Aaru:
+                    extension = Aaru.Converters.Extension(mediaType);
+                    break;
+                case InternalProgram.DiscImageCreator:
+                    extension = DiscImageCreator.Converters.Extension(mediaType);
+                    break;
+            }
+
+            // 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>
@@ -577,6 +708,14 @@ namespace DICUI.Windows
                 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);
@@ -620,16 +759,9 @@ namespace DICUI.Windows
                     break;
             }
 
-            // Choose the lower of the two speeds between the allowed speeds and the user-defined one
-            // TODO: Inform more users about setting preferences in the settings so this comparison doesn't need to happen
-            int chosenSpeed = Math.Min(
-                values.Where(s => s <= values[values.Count / 2]).Last(),
-                preferred
-            );
-
             // Set the selected speed
-            ViewModels.LoggerViewModel.VerboseLogLn("Setting drive speed to: {0}", chosenSpeed);
-            DriveSpeedComboBox.SelectedValue = chosenSpeed;
+            ViewModels.LoggerViewModel.VerboseLogLn("Setting drive speed to: {0}", preferred);
+            DriveSpeedComboBox.SelectedValue = preferred;
         }
 
         /// <summary>
@@ -638,15 +770,15 @@ namespace DICUI.Windows
         private void CacheCurrentDiscType()
         {
             // Get the drive letter from the selected item
-            Drive drive = DriveLetterComboBox.SelectedItem as Drive;
-            if (drive == null || drive.IsFloppy)
+            var drive = DriveLetterComboBox.SelectedItem as Drive;
+            if (drive == null)
                 return;
 
-            // Get the current optical disc type
+            // Get the current media type
             if (!_options.SkipMediaTypeDetection)
             {
                 ViewModels.LoggerViewModel.VerboseLog("Trying to detect media type for drive {0}.. ", drive.Letter);
-                _currentMediaType = Validators.GetMediaType(drive.Letter);
+                _currentMediaType = Validators.GetMediaType(drive);
                 ViewModels.LoggerViewModel.VerboseLogLn(_currentMediaType == null ? "unable to detect." : ("detected " + _currentMediaType.LongName() + "."));
             }
         }
@@ -673,31 +805,33 @@ namespace DICUI.Windows
         /// </summary>
         private void ProcessCustomParameters()
         {
-            _env.DICParameters = new Parameters(ParametersTextBox.Text);
+            _env.SetParameters(ParametersTextBox.Text);
+            if (_env.Parameters == null)
+                return;
 
-            int driveIndex = _drives.Select(d => d.Letter).ToList().IndexOf(_env.DICParameters.DriveLetter[0]);
+            int driveIndex = _drives.Select(d => d.Letter).ToList().IndexOf(_env.Parameters.InputPath()[0]);
             if (driveIndex > -1)
                 DriveLetterComboBox.SelectedIndex = driveIndex;
 
-            int driveSpeed = _env.DICParameters.DriveSpeed ?? -1;
+            int driveSpeed = _env.Parameters.GetSpeed() ?? -1;
             if (driveSpeed > 0)
                 DriveSpeedComboBox.SelectedValue = driveSpeed;
             else
-                _env.DICParameters.DriveSpeed = (int?)DriveSpeedComboBox.SelectedValue;
+                _env.Parameters.SetSpeed((int?)DriveSpeedComboBox.SelectedValue);
 
-            string trimmedPath = _env.DICParameters.Filename?.Trim('"') ?? string.Empty;
+            string trimmedPath = _env.Parameters.OutputPath()?.Trim('"') ?? string.Empty;
             string outputDirectory = Path.GetDirectoryName(trimmedPath);
             string outputFilename = Path.GetFileName(trimmedPath);
-            if (!String.IsNullOrWhiteSpace(outputDirectory))
+            if (!string.IsNullOrWhiteSpace(outputDirectory))
                 OutputDirectoryTextBox.Text = outputDirectory;
             else
                 outputDirectory = OutputDirectoryTextBox.Text;
-            if (!String.IsNullOrWhiteSpace(outputFilename))
+            if (!string.IsNullOrWhiteSpace(outputFilename))
                 OutputFilenameTextBox.Text = outputFilename;
             else
                 outputFilename = OutputFilenameTextBox.Text;
 
-            MediaType? mediaType = _env.DICParameters.Command.ToMediaType();
+            MediaType? mediaType = _env.Parameters.GetMediaType();
             int mediaTypeIndex = _mediaTypes.IndexOf(mediaType);
             if (mediaTypeIndex > -1)
                 MediaTypeComboBox.SelectedIndex = mediaTypeIndex;

DICUI/Windows/OptionsWindow.xaml

@@ -5,13 +5,13 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:DICUI"
         mc:Ignorable="d"
-        Title="Options" Height="580" Width="515.132">
+        Title="Options" Width="515.132" Height="605">
 
     <Grid>
         <Grid.RowDefinitions>
-            <RowDefinition />
             <RowDefinition Height="150"/>
-            <RowDefinition Height="100"/>
+            <RowDefinition Height="150"/>
+            <RowDefinition Height="150"/>
             <RowDefinition Height="80"/>
             <RowDefinition Height="40"/>
         </Grid.RowDefinitions>
@@ -29,19 +29,24 @@
                 <RowDefinition/>
                 <RowDefinition/>
                 <RowDefinition/>
+                <RowDefinition/>
             </Grid.RowDefinitions>
 
-            <Label Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="DiscImageCreator Path" />
-            <TextBox x:Name="DICPathTextBox" Grid.Row="0" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
-            <Button x:Name="DICPathButton" Grid.Row="0" Grid.Column="2" Height="22" Width="22" Content="..." Click="BrowseForPathClick" />
+            <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" />
+            <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="subdump Path" />
-            <TextBox x:Name="SubDumpPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
-            <Button x:Name="SubDumpPathButton" 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="DiscImageCreator Path" />
+            <TextBox x:Name="CreatorPathTextBox" Grid.Row="1" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
+            <Button x:Name="CreatorPathButton" 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="Default Output Path" />
-            <TextBox x:Name="DefaultOutputPathTextBox" Grid.Row="2" Grid.Column="1" Height="22" HorizontalAlignment="Stretch" />
-            <Button x:Name="DefaultOutputPathButton" Grid.Row="2" 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" />
+            <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" />
+            <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">
@@ -86,49 +91,62 @@
                 <Grid.RowDefinitions>
                     <RowDefinition />
                     <RowDefinition />
+                    <RowDefinition />
                 </Grid.RowDefinitions>
 
-
-                <CheckBox Grid.Column="0" VerticalAlignment="Center" Content="Quiet Mode" 
-                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
-                          IsChecked="{Binding Path=QuietMode}" 
-                          ToolTip="Disable DiscImageCreator sounds" 
+                <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.Column="1" VerticalAlignment="Center" Content="Paranoid Mode" 
-                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+
+                <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" 
+                          ToolTip="Enable pedantic and super-safe flags" Margin="0,4"
                           />
-                <Grid Grid.Column="2" Grid.ColumnSpan="2" Grid.Row="0">
-                    <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="2*"/>
-                        <ColumnDefinition />
-                    </Grid.ColumnDefinitions>
 
-                    <Label Grid.Column="0" Content="C2 Reread Tries:" />
-                    <TextBox Grid.Column="1" VerticalAlignment="Center"
+                <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"
                              />
-                </Grid>
 
-                <CheckBox Grid.Column="0" Grid.Row="1" Grid.ColumnSpan="2" VerticalAlignment="Top" Content="Protection Scan" 
-                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+                <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" Grid.ColumnSpan="2" VerticalAlignment="Center" Content="Skip Media Type Detection" 
-                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+                <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)" 
+                          ToolTip="Disable trying to guess media type inserted (may improve performance at startup)" Margin="0,4"
                           />
 
-                <CheckBox Grid.Column="3" Grid.Row="1" VerticalAlignment="Center" Content="Add Placeholders" 
-                          DataContext="{Binding Source={x:Static local:ViewModels.OptionsViewModel}}" 
+                <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" 
+                          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>
 
@@ -141,6 +159,7 @@
                     <ColumnDefinition Width="1*" />
                     <ColumnDefinition Width="1*" />
                     <ColumnDefinition Width="1*" />
+                    <ColumnDefinition Width="1.2*" />
                 </Grid.ColumnDefinitions>
 
                 <Grid.RowDefinitions>
@@ -149,12 +168,14 @@
 
                 <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" />
-                
+
                 <Label Grid.Row="0" Grid.Column="2" VerticalAlignment="Center" HorizontalAlignment="Right" Content="Password" />
-                <TextBox x:Name="RedumpPasswordTextBox" Grid.Row="0" Grid.Column="3" Height="22" HorizontalAlignment="Stretch" />
+                <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*"/>

DICUI/Windows/OptionsWindow.xaml.cs

@@ -2,6 +2,7 @@
 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;
 
@@ -19,7 +20,7 @@ namespace DICUI.Windows
         {
             InitializeComponent();
             _mainWindow = mainWindow;
-            _options = options;      
+            _options = options;
         }
 
         private OpenFileDialog CreateOpenFileDialog()
@@ -42,7 +43,7 @@ namespace DICUI.Windows
 
         private string[] PathSettings()
         {
-            string[] pathSettings = { "DefaultOutputPath", "DICPath", "SubDumpPath" };
+            string[] pathSettings = { "AaruPath", "CreatorPath", "DefaultOutputPath", "SubDumpPath" };
             return pathSettings;
         }
 
@@ -105,7 +106,7 @@ namespace DICUI.Windows
             DumpSpeedBDSlider.Value = _options.PreferredDumpSpeedBD;
 
             RedumpUsernameTextBox.Text = _options.Username;
-            RedumpPasswordTextBox.Text = _options.Password;
+            RedumpPasswordBox.Password = _options.Password;
         }
 
         #region Event Handlers
@@ -119,7 +120,7 @@ namespace DICUI.Windows
             _options.PreferredDumpSpeedBD = Convert.ToInt32(DumpSpeedBDSlider.Value);
 
             _options.Username = RedumpUsernameTextBox.Text;
-            _options.Password = RedumpPasswordTextBox.Text;
+            _options.Password = RedumpPasswordBox.Password;
 
             _options.Save();
             Hide();
@@ -133,6 +134,18 @@ namespace DICUI.Windows
             Hide();
         }
 
+        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
     }
 }

README.md

@@ -1,21 +1,25 @@
 # DICUI
 
-DiscImageCreator UI in C#
+DiscImageCreator/Aaru UI in C#
 
 [![Build status](https://ci.appveyor.com/api/projects/status/3ldav3v0c373jeqa?svg=true)](https://ci.appveyor.com/project/mnadareski/dicui/build/artifacts)
 
 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 :)
 
-We are using DiscImageCreator (DIC), created by Sarami, and we would like to thanks him for his great software. The latest release of DIC can be found on [the GitHub page](https://github.com/saramibreak/DiscImageCreator)
+DICUI relies on the following projects:
+- **DiscImageCreator** by Sarami - Dumping - [GitHub](https://github.com/saramibreak/DiscImageCreator)
+- **Aaru** by Claunia - Dumping - [GitHub](https://github.com/aaru-dps/Aaru)
+- **BurnOutSharp** - Protection scanning - [GitHub](https://github.com/mnadareski/BurnOutSharp)
+- **UnshieldSharp** - Protection scanning - [GitHub](https://github.com/mnadareski/UnshieldSharp)
 
-This project relies on two open-source code ports to help perform copy protection scanning: [BurnOutSharp](https://github.com/mnadareski/BurnOutSharp) and [UnshieldSharp](https://github.com/mnadareski/UnshieldSharp)
+**Note:** Both DiscImageCreator and Aaru have WIP builds. In general, WIP builds are not supported with new flags or features until they make it into the stable release.
 
 ## System Requirements
 
-Even though this is written in C#, this program can only be used on Windows systems due to the base program, DiscImageCreator, being Windows-only. There is some preliminary support for Linux underway, and we will try to integrate with that when the time comes.
+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.
 
 - Windows 7 (newest version of Windows recommended)
-- .NET Framework 4.6.1 Runtimes
+- .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)
 

appveyor.yml

@@ -1,12 +1,12 @@
 # version format
-version: 1.12-{build}
+version: 1.16-{build}
 
 # pull request template
 pull_requests:
   do_not_increment_build_number: true
 
 # vm template
-image: Visual Studio 2017
+image: Visual Studio 2019
 
 # environment variables
 environment:
@@ -32,11 +32,29 @@ build:
 
 # post-build step
 after_build:
-- ps: appveyor DownloadFile https://github.com/saramibreak/DiscImageCreator/files/3341769/DiscImageCreator_20190627.zip
-- ps: appveyor DownloadFile http://www.rawdump.net/tools/subdump_fua_0x28.zip
-- 7z e DiscImageCreator_20190627.zip -oDICUI\bin\Debug\Programs Release_ANSI\*
-- 7z e subdump_fua_0x28.zip -oDICUI\bin\Debug *
-- mv DICUI\bin\Debug\subdump_fua_0x28.exe DICUI\bin\Debug\subdump.exe
+- ps: appveyor DownloadFile https://github.com/aaru-dps/Aaru/releases/download/v5.0.0.2879/aaru-5.0.0.2879-1_windows_x64.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.0.2879-1_windows_x64.zip -oDICUI\bin\Debug\net462\Programs\Aaru *
+- 7z e aaru-5.0.0.2879-1_windows_x64.zip -oDICUI\bin\Debug\net472\Programs\Aaru *
+- 7z e aaru-5.0.0.2879-1_windows_x64.zip -oDICUI\bin\Debug\net48\Programs\Aaru *
+- 7z e aaru-5.0.0.2879-1_windows_x64.zip -oDICUI\bin\Debug\netcoreapp3.0\Programs\Aaru *
+- 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.0\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.0 *
+- mkdir DICUI\bin\Debug\netcoreapp3.0\Programs\Subdump
+- mv DICUI\bin\Debug\netcoreapp3.0\subdump_fua_0x28.exe DICUI\bin\Debug\netcoreapp3.0\Programs\Subdump\subdump.exe
 - 7z a DICUI.zip DICUI\bin\Debug\*
 - 7z a DICUI-Check.zip DICUI.Check\bin\Debug\*
 
@@ -45,4 +63,4 @@ artifacts:
 - path: DICUI.zip
   name: DICUI
 - path: DICUI-Check.zip
-  name: DICUI Check
+  name: DICUI Check