Log Window (#94)

* Split type combobox into system combobox and disc type combobox

* corrected indentation for xaml file

* fixed merge with head

* fixed format

* fixed issues for PR, added KnownSystem.CUSTOM

* removed Updater.cs which ended by error in commit

* fixed GetOuptutName() for new drive/system combobox

* created LogWindow and first tests of output gathering

* integrated all the proof of concept related to stream fetching of DIC output into LogWindow

* working on LogWindow\ncreated more efficient output matching management, improved handling of process termination

* created Tasks file\nmoved some methods there, created DumpEnvironment to manage are arguments

* moved additional methods to Tasks to make it more modular

* changed StartDumping flow to avoid returning if extra tools are not found

* moved main dump workflow into Tasks class

* created specific DumpResult class for better error reporting/management

* fixes

* fixes Dispatcher thread issue with progress bar

* continued refactor
- split EnsureDiscInformation into an additional EnsureCorrectInformationForSystemAndMediaType
- proof of concept of using custom extensions to enum types to give better functionality (and encapsulation)
- changed cmb_MediaType to keep a List<MediaType?> and got rid of Tuple<string, MediaType?>

* restored GetDiscType functionality

* fixed btn_StartStop enabled on EnsureCorrect... error

* fixed whitespace

* fixed indentation

* merged conflicts

* moved log window

* working on LogWindow resize/location behavior

* working on message logging in LogWindow

* added working integration between MenuItem for LogWindow and its visibility status, fixes issues with positioning and visibility, correctly bound Verbose flag to property

* finished integrating LogWindow, added some verbose logs

* added logs

* fixed include order

* added option to show log window at startup, removed useless QuietMode property from MainWindow

DICUI/App.config

@@ -8,5 +8,7 @@
     <add key="preferredDumpSpeedDVD" value="24"/>
     <add key="QuietMode" value="false"/>
     <add key="RereadAmountForC2" value="20"/>
+    <add key="VerboseLogging" value="true"/>
+    <add key="OpenLogWindowAtStartup" value="true"/>
   </appSettings>
 </configuration>

DICUI/DICUI.csproj

@@ -97,6 +97,9 @@
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </ApplicationDefinition>
+    <Compile Include="LogWindow.xaml.cs">
+      <DependentUpon>LogWindow.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Data\Constants.cs" />
     <Compile Include="External\BurnOut\EVORE.cs" />
     <Compile Include="External\iXcomp\IXComp.cs" />
@@ -114,6 +117,10 @@
     <Compile Include="OptionsWindow.xaml.cs">
       <DependentUpon>OptionsWindow.xaml</DependentUpon>
     </Compile>
+    <Page Include="LogWindow.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="MainWindow.xaml">
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>

DICUI/LogWindow.xaml

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

DICUI/LogWindow.xaml.cs

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

DICUI/MainWindow.xaml

@@ -4,10 +4,11 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:DICUI"
+        xmlns:lui="clr-namespace:DICUI.UI"
         xmlns:utilities="clr-namespace:DICUI.Utilities"
         mc:Ignorable="d"
-        x:Name="mainWindow"
-        Title="Disc Image Creator GUI" Height="450" Width="600" WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize">
+        Title="Disc Image Creator GUI" Height="450" Width="600" WindowStartupLocation="CenterScreen" ResizeMode="CanMinimize" 
+        LocationChanged="MainWindowLocationChanged" Activated="MainWindowLocationActivated" Closing="MainWindowClosing">
 
     <Window.Resources>
         <utilities:EnumDescriptionConverter x:Key="enumConverter" />
@@ -32,6 +33,10 @@
                 </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"
+                              DataContext="{Binding Source={x:Static lui:ViewModels.LoggerViewModel}}" 
+                              IsChecked="{Binding Path=WindowVisible}"
+                    />
                 </MenuItem>
                 <MenuItem Header="_Help">
                     <MenuItem x:Name="About" Header="_About" HorizontalAlignment="Left" Width="140" Click="AboutClick"/>

DICUI/MainWindow.xaml.cs

@@ -26,12 +26,10 @@ namespace DICUI
         private Options _options;
         private OptionsWindow _optionsWindow;
 
-        public bool QuietMode { get; set; }
+        private LogWindow _logWindow;
 
         public MainWindow()
         {
-            QuietMode = true;
-
             InitializeComponent();
 
             // Initializes and load Options object
@@ -39,6 +37,9 @@ namespace DICUI
             _options.Load();
             ViewModels.OptionsViewModel = new OptionsViewModel(_options);
 
+            _logWindow = new LogWindow(this);
+            ViewModels.LoggerViewModel.SetWindow(_logWindow);
+
             // Disable buttons until we load fully
             StartStopButton.IsEnabled = false;
             DiskScanButton.IsEnabled = false;
@@ -57,6 +58,14 @@ namespace DICUI
 
             _alreadyShown = true;
 
+            if (_options.OpenLogWindowAtStartup)
+            {
+                //TODO: this should be bound directly to WindowVisible property in two way fashion
+                // we need to study how to properly do it in XAML
+                ShowLogMenuItem.IsChecked = true;
+                ViewModels.LoggerViewModel.WindowVisible = true;
+            }
+
             // Populate the list of systems
             StatusLabel.Content = "Creating system list, please wait!";
             PopulateSystems();
@@ -149,6 +158,27 @@ namespace DICUI
             EnsureDiscInformation();
         }
 
+        private void MainWindowLocationChanged(object sender, EventArgs e)
+        {
+            if (_logWindow.IsVisible)
+                _logWindow.AdjustPositionToMainWindow();
+        }
+
+        private void MainWindowLocationActivated(object sender, EventArgs e)
+        {
+            if (_logWindow.IsVisible)
+            {
+                _logWindow.Topmost = true;
+                this.Topmost = true;
+            }
+        }
+
+        private void MainWindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            if (_logWindow.IsVisible)
+                _logWindow.Close();
+        }
+
         // Toolbar Events
 
         private void AppExitClick(object sender, RoutedEventArgs e)
@@ -224,7 +254,9 @@ namespace DICUI
         {
             _systems = Validators.CreateListOfSystems();
 
-            Dictionary<KnownSystemCategory, List<KnownSystem?>> mapping = _systems
+            ViewModels.LoggerViewModel.VerboseLogLn("Populating systems, {0} systems found.", _systems.Count);
+
+            Dictionary <KnownSystemCategory, List<KnownSystem?>> mapping = _systems
                 .GroupBy(s => s.Category())
                 .ToDictionary(
                     k => k.Key,
@@ -255,6 +287,8 @@ namespace DICUI
         /// <remarks>TODO: Find a way for this to periodically run, or have it hook to a "drive change" event</remarks>
         private void PopulateDrives()
         {
+            ViewModels.LoggerViewModel.VerboseLogLn("Scanning for drives..");
+            
             // Always enable the disk scan
             DiskScanButton.IsEnabled = true;
 
@@ -268,6 +302,8 @@ namespace DICUI
                 StatusLabel.Content = "Valid media found! Choose your Media Type";
                 StartStopButton.IsEnabled = true;
                 CopyProtectScanButton.IsEnabled = true;
+
+                ViewModels.LoggerViewModel.VerboseLogLn("Found {0} drives containing media: {1}", _drives.Count, String.Join(", ", _drives.Select(d => d.Letter)));
             }
             else
             {
@@ -275,6 +311,8 @@ namespace DICUI
                 StatusLabel.Content = "No valid media found!";
                 StartStopButton.IsEnabled = false;
                 CopyProtectScanButton.IsEnabled = false;
+
+                ViewModels.LoggerViewModel.VerboseLogLn("Found no drives contaning valid media.");
             }
         }
 
@@ -334,6 +372,7 @@ namespace DICUI
             StartStopButton.Content = UIElements.StopDumping;
             CopyProtectScanButton.IsEnabled = false;
             StatusLabel.Content = "Beginning dumping process";
+            ViewModels.LoggerViewModel.VerboseLogLn("Starting dumping process..");
 
             Result result = await _env.StartDumping();
 
@@ -468,6 +507,8 @@ namespace DICUI
             if (speed == -1)
                 return;
 
+            ViewModels.LoggerViewModel.VerboseLogLn("Determined max drive speed for {0}: {0}.", _env.Drive.Letter, speed);
+
             // Choose the lower of the two speeds between the allowed speeds and the user-defined one
             int chosenSpeed = Math.Min(
                 AllowedSpeeds.GetForMediaType(_currentMediaType).Where(s => s <= speed).Last(),
@@ -489,7 +530,11 @@ namespace DICUI
 
             // Get the current optical disc type
             if (!_options.SkipMediaTypeDetection)
+            {
+                ViewModels.LoggerViewModel.VerboseLog("Trying to detect media type for drive {0}.. ", drive.Letter);
                 _currentMediaType = Validators.GetDiscType(drive.Letter);
+                ViewModels.LoggerViewModel.VerboseLogLn(_currentMediaType != null ? "unable to detect." : ("detected " + _currentMediaType.Name() + "."));
+            }
         }
 
         /// <summary>

DICUI/Options.cs

@@ -20,6 +20,9 @@ namespace DICUI
 
         public bool SkipMediaTypeDetection { get; set; }
 
+        public bool VerboseLogging { get; set; }
+        public bool OpenLogWindowAtStartup { get; set; }
+
         public void Save()
         {
             Configuration configFile = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
@@ -51,6 +54,8 @@ namespace DICUI
             this.ParanoidMode = Boolean.TryParse(ConfigurationManager.AppSettings["ParanoidMode"], out bool paranoidMode) ? paranoidMode : false;
             this.SkipMediaTypeDetection = Boolean.TryParse(ConfigurationManager.AppSettings["SkipMediaTypeDetection"], out bool skipMediaTypeDetection) ? skipMediaTypeDetection : false;
             this.RereadAmountForC2 = Int32.TryParse(ConfigurationManager.AppSettings["RereadAmountForC2"], out int rereadAmountForC2) ? rereadAmountForC2 : 20;
+            this.VerboseLogging = Boolean.TryParse(ConfigurationManager.AppSettings["VerboseLogging"], out bool verboseLogging) ? verboseLogging : true;
+            this.OpenLogWindowAtStartup = Boolean.TryParse(ConfigurationManager.AppSettings["OpenLogWindowAtStartup"], out bool openLogWindowAtStartup) ? openLogWindowAtStartup : true;
         }
 
 

DICUI/UI/ViewModels.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
 
 namespace DICUI.UI
 {
@@ -42,11 +44,63 @@ namespace DICUI.UI
                     _options.RereadAmountForC2 = result;
             }
         }
+
+        public bool VerboseLogging
+        {
+            get { return _options.VerboseLogging; }
+            set
+            {
+                _options.VerboseLogging = value;
+                _options.Save();
+            }
+        }
+
+        public bool OpenLogWindowAtStartup
+        {
+            get { return _options.OpenLogWindowAtStartup; }
+            set
+            {
+                _options.OpenLogWindowAtStartup = value;
+                _options.Save();
+            }
+        }
+    }
+
+    public class LoggerViewModel
+    {
+        private LogWindow _logWindow;
+
+        public void SetWindow(LogWindow logWindow) => _logWindow = logWindow;
+
+        public bool WindowVisible
+        {
+            get => _logWindow != null ? _logWindow.IsVisible : false;
+            set
+            {
+                if (value)
+                {
+                    _logWindow.AdjustPositionToMainWindow();
+                    _logWindow.Show();
+                }
+                else
+                    _logWindow.Hide();
+            }
+        }
+
+        public void VerboseLog(string text)
+        {
+            if (ViewModels.OptionsViewModel.VerboseLogging)
+                _logWindow.AppendToTextBox(text, Brushes.Yellow);
+        }
+
+        public void VerboseLog(string format, params object[] args) => VerboseLog(string.Format(format, args));
+        public void VerboseLogLn(string format, params object[] args) => VerboseLog(string.Format(format, args) + "\n");
     }
 
     public static class ViewModels
     {
         public static OptionsViewModel OptionsViewModel { get; set; }
+        public static LoggerViewModel LoggerViewModel { get; set; } = new LoggerViewModel();
     }
 
 }

DICUI/Utilities/Converters.cs

@@ -1,9 +1,13 @@
 using System;
+using System.ComponentModel;
 using System.Globalization;
 using System.Windows.Data;
+using System.Windows.Data;
+using System.Reflection;
 using IMAPI2;
 using DICUI.Data;
 
+
 namespace DICUI.Utilities
 {
     /// <summary>

DICUI/Utilities/DumpEnvironment.cs

@@ -8,6 +8,7 @@ using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using System.Windows;
 using DICUI.Data;
+using DICUI.UI;
 
 namespace DICUI.Utilities
 {
@@ -80,6 +81,8 @@ namespace DICUI.Utilities
         /// </summary>
         public async void EjectDisc()
         {
+            ViewModels.LoggerViewModel.VerboseLogLn("Ejecting Disc..");
+            
             // Validate that the required program exists
             if (!File.Exists(DICPath))
                 return;
@@ -327,6 +330,8 @@ namespace DICUI.Utilities
         /// </summary>
         private void ExecuteDiskImageCreator()
         {
+            ViewModels.LoggerViewModel.VerboseLogLn("Launching DiskImageCreator process.");
+
             dicProcess = new Process()
             {
                 StartInfo = new ProcessStartInfo()