From 00a7c4f3517492778b8387a4dfc2e2f1f0315bef Mon Sep 17 00:00:00 2001
From: SpoinkyNL <spoinky.nl@gmail.com>
Date: Mon, 24 Oct 2016 23:30:10 +0200
Subject: [PATCH] Added markdown support to the changelog display Added live
 log to the debug window

---
 Artemis/Artemis/App.xaml                      |    1 +
 Artemis/Artemis/Artemis.csproj                |   21 +
 .../Artemis/Controls/Log/LoggingControl.xaml  |   27 +
 .../Controls/Log/LoggingControl.xaml.cs       |   37 +
 .../Artemis/Controls/Log/MemoryEventTarget.cs |   20 +
 Artemis/Artemis/Dialogs/MarkdownDialog.xaml   |   53 +
 .../Artemis/Dialogs/MarkdownDialog.xaml.cs    |   28 +
 .../Artemis/Services/MetroDialogService.cs    |   16 +
 Artemis/Artemis/Styles/MarkdownStyles.xaml    |   57 +
 Artemis/Artemis/Utilities/Logging.cs          |   29 +-
 .../Artemis/Utilities/Markdown/Markdown.cs    | 1051 +++++++++++++++++
 .../Markdown/TextToFlowDocumentConverter.cs   |   62 +
 Artemis/Artemis/Utilities/Updater.cs          |    8 +-
 Artemis/Artemis/ViewModels/DebugViewModel.cs  |   20 +-
 Artemis/Artemis/Views/DebugView.xaml          |   15 +-
 15 files changed, 1433 insertions(+), 12 deletions(-)
 create mode 100644 Artemis/Artemis/Controls/Log/LoggingControl.xaml
 create mode 100644 Artemis/Artemis/Controls/Log/LoggingControl.xaml.cs
 create mode 100644 Artemis/Artemis/Controls/Log/MemoryEventTarget.cs
 create mode 100644 Artemis/Artemis/Dialogs/MarkdownDialog.xaml
 create mode 100644 Artemis/Artemis/Dialogs/MarkdownDialog.xaml.cs
 create mode 100644 Artemis/Artemis/Styles/MarkdownStyles.xaml
 create mode 100644 Artemis/Artemis/Utilities/Markdown/Markdown.cs
 create mode 100644 Artemis/Artemis/Utilities/Markdown/TextToFlowDocumentConverter.cs

diff --git a/Artemis/Artemis/App.xaml b/Artemis/Artemis/App.xaml
index e13bd017f..1b093a2b3 100644
--- a/Artemis/Artemis/App.xaml
+++ b/Artemis/Artemis/App.xaml
@@ -21,6 +21,7 @@
                     Source="pack://application:,,,/MahApps.Metro;component/Styles/Accents/BaseDark.xaml" />
                 <ResourceDictionary Source="/Resources/Icons.xaml" />
                 <ResourceDictionary Source="Styles/ColorBox.xaml" />
+                <ResourceDictionary Source="Styles/MarkdownStyles.xaml" />
             </ResourceDictionary.MergedDictionaries>
             <converters:MilliSecondTimespanConverter x:Key="MilliSecondTimespanConverter" />
         </ResourceDictionary>
diff --git a/Artemis/Artemis/Artemis.csproj b/Artemis/Artemis/Artemis.csproj
index abd596e18..bce65305f 100644
--- a/Artemis/Artemis/Artemis.csproj
+++ b/Artemis/Artemis/Artemis.csproj
@@ -303,6 +303,10 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ArtemisBootstrapper.cs" />
+    <Compile Include="Controls\Log\LoggingControl.xaml.cs">
+      <DependentUpon>LoggingControl.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Controls\Log\MemoryEventTarget.cs" />
     <Compile Include="DAL\ProfileProvider.cs" />
     <Compile Include="DAL\SettingsProvider.cs" />
     <Compile Include="DeviceProviders\Corsair\CorsairMice.cs" />
@@ -313,6 +317,9 @@
     <Compile Include="DeviceProviders\Logitech\G810.cs" />
     <Compile Include="DeviceProviders\Logitech\LogitechGeneric.cs" />
     <Compile Include="DeviceProviders\Logitech\LogitechKeyboard.cs" />
+    <Compile Include="Dialogs\MarkdownDialog.xaml.cs">
+      <DependentUpon>MarkdownDialog.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Events\EffectChangedEventArgs.cs" />
     <Compile Include="Events\EnabledChangedEventArgs.cs" />
     <Compile Include="Events\KeyboardChangedEventArgs.cs" />
@@ -511,6 +518,8 @@
     <Compile Include="Utilities\Keyboard\KeyboardHook.cs" />
     <Compile Include="Utilities\Logging.cs" />
     <Compile Include="Utilities\DataReaders\PipeServer.cs" />
+    <Compile Include="Utilities\Markdown\Markdown.cs" />
+    <Compile Include="Utilities\Markdown\TextToFlowDocumentConverter.cs" />
     <Compile Include="Utilities\Memory\GamePointer.cs" />
     <Compile Include="Utilities\Keyboard\KeyboardRectangle.cs" />
     <Compile Include="Utilities\Memory\Memory.cs" />
@@ -686,6 +695,14 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <Page Include="Controls\Log\LoggingControl.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Dialogs\MarkdownDialog.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Modules\Effects\Bubbles\BubblesView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
@@ -746,6 +763,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Styles\MarkdownStyles.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\DebugView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
diff --git a/Artemis/Artemis/Controls/Log/LoggingControl.xaml b/Artemis/Artemis/Controls/Log/LoggingControl.xaml
new file mode 100644
index 000000000..b1ded7610
--- /dev/null
+++ b/Artemis/Artemis/Controls/Log/LoggingControl.xaml
@@ -0,0 +1,27 @@
+<UserControl x:Class="Artemis.Controls.Log.LoggingControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             mc:Ignorable="d"
+             d:DesignHeight="300" d:DesignWidth="300"
+             DataContext="{Binding RelativeSource={RelativeSource Self}}">
+   
+    <Grid>
+        <!--<TextBox IsReadOnly="True" AcceptsReturn="True"  Height="Auto" HorizontalAlignment="Stretch" Name="dgLog" VerticalAlignment="Stretch" Width="Auto"/>-->
+        <ListView ItemsSource="{Binding LogCollection}" Name="logView">
+            <ListView.View>
+                <GridView>
+                    <GridView.Columns>
+                        <!--<GridViewColumn DisplayMemberBinding="{Binding LoggerName}" Header="Logger"/>-->
+                        <GridViewColumn DisplayMemberBinding="{Binding Level}" Header="Level" />
+                        <GridViewColumn DisplayMemberBinding="{Binding TimeStamp, StringFormat=HH:mm:ss.ffffff}" Header="Time" />
+                        <GridViewColumn DisplayMemberBinding="{Binding FormattedMessage}" Width="600" Header="Message" />
+                        <GridViewColumn DisplayMemberBinding="{Binding Exception}" Width="Auto" Header="Exception" />
+                    </GridView.Columns>
+                </GridView>
+            </ListView.View>
+        </ListView>
+        <!--<ListBox Height="Auto" HorizontalAlignment="Stretch" Name="dgLog" VerticalAlignment="Stretch" Width="Auto" />-->
+    </Grid>
+</UserControl>
\ No newline at end of file
diff --git a/Artemis/Artemis/Controls/Log/LoggingControl.xaml.cs b/Artemis/Artemis/Controls/Log/LoggingControl.xaml.cs
new file mode 100644
index 000000000..cf771ba2d
--- /dev/null
+++ b/Artemis/Artemis/Controls/Log/LoggingControl.xaml.cs
@@ -0,0 +1,37 @@
+using System.Collections.ObjectModel;
+using System.Windows.Controls;
+using Artemis.Utilities;
+using NLog;
+
+namespace Artemis.Controls.Log
+{
+    /// <summary>
+    ///     Interaction logic for LoggingControl.xaml
+    /// </summary>
+    public partial class LoggingControl : UserControl
+    {
+        public LoggingControl()
+        {
+            LogCollection = new ObservableCollection<LogEventInfo>();
+
+            InitializeComponent();
+
+            // init memory queue
+            Logging.ClearLoggingEvent();
+            Logging.MemoryEvent += EventReceived;
+        }
+
+        public static ObservableCollection<LogEventInfo> LogCollection { get; set; }
+
+        private async void EventReceived(LogEventInfo message)
+        {
+            await Dispatcher.InvokeAsync(() =>
+            {
+                if (LogCollection.Count >= 50)
+                    LogCollection.RemoveAt(LogCollection.Count - 1);
+
+                LogCollection.Add(message);
+            });
+        }
+    }
+}
\ No newline at end of file
diff --git a/Artemis/Artemis/Controls/Log/MemoryEventTarget.cs b/Artemis/Artemis/Controls/Log/MemoryEventTarget.cs
new file mode 100644
index 000000000..acbe7690e
--- /dev/null
+++ b/Artemis/Artemis/Controls/Log/MemoryEventTarget.cs
@@ -0,0 +1,20 @@
+using System;
+using NLog;
+using NLog.Targets;
+
+namespace Artemis.Controls.Log
+{
+    public class MemoryEventTarget : Target
+    {
+        public event Action<LogEventInfo> EventReceived;
+
+        /// <summary>
+        ///     Notifies listeners about new event
+        /// </summary>
+        /// <param name="logEvent">The logging event.</param>
+        protected override void Write(LogEventInfo logEvent)
+        {
+            EventReceived?.Invoke(logEvent);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Artemis/Artemis/Dialogs/MarkdownDialog.xaml b/Artemis/Artemis/Dialogs/MarkdownDialog.xaml
new file mode 100644
index 000000000..8a9587fe5
--- /dev/null
+++ b/Artemis/Artemis/Dialogs/MarkdownDialog.xaml
@@ -0,0 +1,53 @@
+<dialogs:CustomDialog x:Class="Artemis.Dialogs.MarkdownDialog"
+                      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                      xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                      xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+                      xmlns:dialogs="clr-namespace:MahApps.Metro.Controls.Dialogs;assembly=MahApps.Metro"
+                      xmlns:dialogs1="clr-namespace:Artemis.Dialogs"
+                      xmlns:markdown="clr-namespace:Artemis.Utilities.Markdown"
+                      xmlns:system="clr-namespace:System;assembly=mscorlib"
+                      mc:Ignorable="d"
+                      d:DesignHeight="300" d:DesignWidth="300">
+    <dialogs:CustomDialog.Resources>
+        <markdown:Markdown x:Key="Markdown"
+                           DocumentStyle="{StaticResource DocumentStyle}"
+                           Heading1Style="{StaticResource H1Style}"
+                           Heading2Style="{StaticResource H2Style}"
+                           Heading3Style="{StaticResource H3Style}"
+                           Heading4Style="{StaticResource H4Style}"
+                           LinkStyle="{StaticResource LinkStyle}"
+                           ImageStyle="{StaticResource ImageStyle}"
+                           SeparatorStyle="{StaticResource SeparatorStyle}"
+                           AssetPathRoot="{x:Static system:Environment.CurrentDirectory}" />
+
+        <markdown:TextToFlowDocumentConverter x:Key="TextToFlowDocumentConverter"
+                                              Markdown="{StaticResource Markdown}" />
+    </dialogs:CustomDialog.Resources>
+    <Grid Margin="0 10 0 0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <FlowDocumentScrollViewer
+            HorizontalScrollBarVisibility="Disabled"
+            VerticalScrollBarVisibility="Auto"
+            Margin="-15 -15 0 0"
+            FontSize="{Binding DialogMessageFontSize, RelativeSource={RelativeSource AncestorType=dialogs:MessageDialog, Mode=FindAncestor}, UpdateSourceTrigger=PropertyChanged}"
+            Foreground="{Binding Foreground, RelativeSource={RelativeSource AncestorType=dialogs:MessageDialog, Mode=FindAncestor}, UpdateSourceTrigger=PropertyChanged}"
+            Document="{Binding Markdown, RelativeSource={RelativeSource AncestorType=dialogs1:MarkdownDialog, Mode=FindAncestor}, Converter={StaticResource TextToFlowDocumentConverter}, UpdateSourceTrigger=PropertyChanged}" IsSelectionEnabled="False" />
+
+        <StackPanel Grid.Row="1"
+                    Height="85"
+                    HorizontalAlignment="Right"
+                    Orientation="Horizontal">
+            <Button x:Name="PART_AffirmativeButton"
+                    Height="35"
+                    MinWidth="80"
+                    Margin="0 0 5 0"
+                    Content="Alrighty, let's go!"
+                    Style="{DynamicResource AccentedDialogSquareButton}" />
+        </StackPanel>
+    </Grid>
+</dialogs:CustomDialog>
\ No newline at end of file
diff --git a/Artemis/Artemis/Dialogs/MarkdownDialog.xaml.cs b/Artemis/Artemis/Dialogs/MarkdownDialog.xaml.cs
new file mode 100644
index 000000000..8c31b6ec9
--- /dev/null
+++ b/Artemis/Artemis/Dialogs/MarkdownDialog.xaml.cs
@@ -0,0 +1,28 @@
+using System.Windows;
+using System.Windows.Input;
+
+namespace Artemis.Dialogs
+{
+    /// <summary>
+    ///     Interaction logic for MarkdownDialog.xaml
+    /// </summary>
+    public partial class MarkdownDialog
+    {
+        public static readonly DependencyProperty MarkdownProperty = DependencyProperty.Register("Markdown",
+            typeof(string), typeof(MarkdownDialog), new PropertyMetadata(default(string)));
+
+        public MarkdownDialog()
+        {
+            InitializeComponent();
+
+            CommandBindings.Add(new CommandBinding(NavigationCommands.GoToPage,
+                (sender, e) => System.Diagnostics.Process.Start((string) e.Parameter)));
+        }
+
+        public string Markdown
+        {
+            get { return (string) GetValue(MarkdownProperty); }
+            set { SetValue(MarkdownProperty, value); }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Artemis/Artemis/Services/MetroDialogService.cs b/Artemis/Artemis/Services/MetroDialogService.cs
index 04465596e..c40f76583 100644
--- a/Artemis/Artemis/Services/MetroDialogService.cs
+++ b/Artemis/Artemis/Services/MetroDialogService.cs
@@ -23,6 +23,8 @@
 using System.Linq;
 using System.Threading.Tasks;
 using System.Windows;
+using Artemis.Dialogs;
+using Artemis.Styles;
 using Caliburn.Micro;
 using MahApps.Metro.Controls;
 using MahApps.Metro.Controls.Dialogs;
@@ -53,6 +55,20 @@ namespace Artemis.Services
             Execute.OnUIThread(() => GetActiveWindow().ShowMessageAsync(title, message));
         }
 
+        public void ShowMarkdownDialog(string title, string markdown)
+        {
+            if (GetActiveWindow() == null)
+                return;
+
+            var dialog = new MarkdownDialog
+            {
+                Markdown = markdown,
+                Title = title
+            };
+
+            Execute.OnUIThread(() => GetActiveWindow().ShowMetroDialogAsync(dialog));
+        }
+
         public override async Task<bool?> ShowQuestionMessageBox(string title, string message)
         {
             if (GetActiveWindow() == null)
diff --git a/Artemis/Artemis/Styles/MarkdownStyles.xaml b/Artemis/Artemis/Styles/MarkdownStyles.xaml
new file mode 100644
index 000000000..d863be5e0
--- /dev/null
+++ b/Artemis/Artemis/Styles/MarkdownStyles.xaml
@@ -0,0 +1,57 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:local="clr-namespace:Artemis.Styles">
+    <Style TargetType="FlowDocument" x:Key="DocumentStyle">
+        <Setter Property="FontFamily" Value="{StaticResource DefaultFont}" />
+        <Setter Property="Foreground" Value="{StaticResource LabelTextBrush}" />
+        <Setter Property="FontSize" Value="{StaticResource NormalFontSize}" />
+        <Setter Property="TextAlignment" Value="Left" />
+    </Style>
+
+    <Style x:Key="H1Style" TargetType="Paragraph">
+        <Setter Property="FontSize" Value="42" />
+        <Setter Property="Foreground" Value="{StaticResource LabelTextBrush}" />
+        <Setter Property="FontFamily" Value="{StaticResource HeaderFontFamily}" />
+        <Setter Property="Margin" Value="0" />
+    </Style>
+
+    <Style x:Key="H2Style" TargetType="Paragraph">
+        <Setter Property="FontSize" Value="20" />
+        <Setter Property="Foreground" Value="{StaticResource LabelTextBrush}" />
+        <Setter Property="FontFamily" Value="{StaticResource HeaderFontFamily}" />
+        <Setter Property="Margin" Value="0" />
+    </Style>
+
+    <Style x:Key="H3Style" TargetType="Paragraph">
+        <Setter Property="FontSize" Value="20" />
+        <Setter Property="Foreground" Value="{StaticResource LabelTextBrush}" />
+        <Setter Property="FontFamily" Value="{StaticResource HeaderFontFamily}" />
+        <Setter Property="Margin" Value="0" />
+    </Style>
+
+    <Style x:Key="H4Style" TargetType="Paragraph">
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="Foreground" Value="{StaticResource LabelTextBrush}" />
+        <Setter Property="FontFamily" Value="{StaticResource HeaderFontFamily}" />
+        <Setter Property="Margin" Value="0" />
+    </Style>
+
+    <Style x:Key="LinkStyle" TargetType="Hyperlink">
+        <Setter Property="Foreground" Value="{StaticResource AccentColorBrush}" />
+    </Style>
+
+    <Style x:Key="ImageStyle" TargetType="Image">
+        <Setter Property="RenderOptions.BitmapScalingMode" Value="NearestNeighbor" />
+        <Style.Triggers>
+            <Trigger Property="Tag" Value="imageright">
+                <Setter Property="Margin" Value="20,0,0,0" />
+            </Trigger>
+        </Style.Triggers>
+    </Style>
+
+    <Style x:Key="SeparatorStyle" TargetType="Line">
+        <Setter Property="X2" Value="{Binding ActualWidth, RelativeSource={RelativeSource AncestorType=FlowDocumentScrollViewer}}" />
+        <Setter Property="Stroke" Value="{StaticResource AccentColorBrush}" />
+        <Setter Property="StrokeThickness" Value="2" />
+    </Style>
+</ResourceDictionary>
\ No newline at end of file
diff --git a/Artemis/Artemis/Utilities/Logging.cs b/Artemis/Artemis/Utilities/Logging.cs
index 8d6040a3b..a69e103fc 100644
--- a/Artemis/Artemis/Utilities/Logging.cs
+++ b/Artemis/Artemis/Utilities/Logging.cs
@@ -1,4 +1,6 @@
-using NLog;
+using System.Linq;
+using Artemis.Controls.Log;
+using NLog;
 using NLog.Config;
 using NLog.Targets;
 
@@ -6,6 +8,8 @@ namespace Artemis.Utilities
 {
     public static class Logging
     {
+        public static event LoggingEvent MemoryEvent;
+
         public static void SetupLogging(string logLevel)
         {
             SetupLogging(LogLevel.FromString(logLevel));
@@ -13,6 +17,9 @@ namespace Artemis.Utilities
 
         public static void SetupLogging(LogLevel logLevel)
         {
+            if (logLevel == LogManager.Configuration?.LoggingRules?.FirstOrDefault()?.Levels.FirstOrDefault())
+                return;
+
             // Step 1. Create configuration object 
             var config = new LoggingConfiguration();
 
@@ -23,6 +30,10 @@ namespace Artemis.Utilities
             var fileTarget = new FileTarget();
             config.AddTarget("file", fileTarget);
 
+            var memoryTarget = new MemoryEventTarget();
+            memoryTarget.EventReceived += MemoryTargetOnEventReceived;
+            config.AddTarget("memory", memoryTarget);
+
             // Step 3. Set target properties 
             debuggerTarget.Layout = @"${logger:shortName=True} - ${uppercase:${level}}: ${message}";
             fileTarget.FileName = "${specialfolder:folder=MyDocuments}/Artemis/logs/${shortdate}.txt";
@@ -30,12 +41,14 @@ namespace Artemis.Utilities
             fileTarget.EnableFileDelete = true;
             fileTarget.MaxArchiveFiles = 7;
             fileTarget.ArchiveEvery = FileArchivePeriod.Minute;
-            
+
             // Step 4. Define rules
             var rule1 = new LoggingRule("*", logLevel, debuggerTarget);
             config.LoggingRules.Add(rule1);
             var rule2 = new LoggingRule("*", logLevel, fileTarget);
             config.LoggingRules.Add(rule2);
+            var rule3 = new LoggingRule("*", logLevel, memoryTarget);
+            config.LoggingRules.Add(rule3);
 
             // Step 5. Activate the configuration
             LogManager.Configuration = config;
@@ -44,5 +57,17 @@ namespace Artemis.Utilities
             var logger = LogManager.GetCurrentClassLogger();
             logger.Fatal("INFO: Set log level to {0}", logLevel);
         }
+
+        private static void MemoryTargetOnEventReceived(LogEventInfo logEventInfo)
+        {
+            MemoryEvent?.Invoke(logEventInfo);
+        }
+
+        public static void ClearLoggingEvent()
+        {
+            MemoryEvent = delegate { };
+        }
     }
+
+    public delegate void LoggingEvent(LogEventInfo logEventInfo);
 }
\ No newline at end of file
diff --git a/Artemis/Artemis/Utilities/Markdown/Markdown.cs b/Artemis/Artemis/Utilities/Markdown/Markdown.cs
new file mode 100644
index 000000000..805b75439
--- /dev/null
+++ b/Artemis/Artemis/Utilities/Markdown/Markdown.cs
@@ -0,0 +1,1051 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Markup;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+namespace Artemis.Utilities.Markdown
+{
+    public class Markdown : DependencyObject
+    {
+        /// <summary>
+        /// maximum nested depth of [] and () supported by the transform; implementation detail
+        /// </summary>
+        private const int _nestDepth = 6;
+
+        /// <summary>
+        /// Tabs are automatically converted to spaces as part of the transform  
+        /// this constant determines how "wide" those tabs become in spaces  
+        /// </summary>
+        private const int _tabWidth = 4;
+
+        private const string _markerUL = @"[*+-]";
+        private const string _markerOL = @"\d+[.]";
+
+        private int _listLevel;
+
+        /// <summary>
+        /// when true, bold and italic require non-word characters on either side  
+        /// WARNING: this is a significant deviation from the markdown spec
+        /// </summary>
+        /// 
+        public bool StrictBoldItalic { get; set; }
+
+        public ICommand HyperlinkCommand { get; set; }
+
+        public Style DocumentStyle
+        {
+            get { return (Style)GetValue(DocumentStyleProperty); }
+            set { SetValue(DocumentStyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for DocumentStyle.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty DocumentStyleProperty =
+            DependencyProperty.Register("DocumentStyle", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style Heading1Style
+        {
+            get { return (Style)GetValue(Heading1StyleProperty); }
+            set { SetValue(Heading1StyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Heading1Style.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty Heading1StyleProperty =
+            DependencyProperty.Register("Heading1Style", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style Heading2Style
+        {
+            get { return (Style)GetValue(Heading2StyleProperty); }
+            set { SetValue(Heading2StyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Heading2Style.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty Heading2StyleProperty =
+            DependencyProperty.Register("Heading2Style", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style Heading3Style
+        {
+            get { return (Style)GetValue(Heading3StyleProperty); }
+            set { SetValue(Heading3StyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Heading3Style.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty Heading3StyleProperty =
+            DependencyProperty.Register("Heading3Style", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style Heading4Style
+        {
+            get { return (Style)GetValue(Heading4StyleProperty); }
+            set { SetValue(Heading4StyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Heading4Style.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty Heading4StyleProperty =
+            DependencyProperty.Register("Heading4Style", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style CodeStyle
+        {
+            get { return (Style)GetValue(CodeStyleProperty); }
+            set { SetValue(CodeStyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for CodeStyle.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty CodeStyleProperty =
+            DependencyProperty.Register("CodeStyle", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style LinkStyle
+        {
+            get { return (Style)GetValue(LinkStyleProperty); }
+            set { SetValue(LinkStyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for LinkStyle.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty LinkStyleProperty =
+            DependencyProperty.Register("LinkStyle", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style ImageStyle
+        {
+            get { return (Style)GetValue(ImageStyleProperty); }
+            set { SetValue(ImageStyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for ImageStyle.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty ImageStyleProperty =
+            DependencyProperty.Register("ImageStyle", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public Style SeparatorStyle
+        {
+            get { return (Style)GetValue(SeparatorStyleProperty); }
+            set { SetValue(SeparatorStyleProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for SeparatorStyle.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty SeparatorStyleProperty =
+            DependencyProperty.Register("SeparatorStyle", typeof(Style), typeof(Markdown), new PropertyMetadata(null));
+
+        public string AssetPathRoot
+        {
+            get { return (string)GetValue(AssetPathRootProperty); }
+            set { SetValue(AssetPathRootProperty, value); }
+        }
+
+        public static readonly DependencyProperty AssetPathRootProperty =
+            DependencyProperty.Register("AssetPathRootRoot", typeof(string), typeof(Markdown), new PropertyMetadata(null));
+
+        public Markdown()
+        {
+            HyperlinkCommand = NavigationCommands.GoToPage;
+        }
+
+        public FlowDocument Transform(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            text = Normalize(text);
+            var document = Create<FlowDocument, Block>(RunBlockGamut(text));
+
+            if (DocumentStyle != null)
+            {
+                document.Style = DocumentStyle;
+            }
+            else
+            {
+                document.PagePadding = new Thickness(0);
+            }
+
+            return document;
+        }
+
+        /// <summary>
+        /// Perform transformations that form block-level tags like paragraphs, headers, and list items.
+        /// </summary>
+        private IEnumerable<Block> RunBlockGamut(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return DoHeaders(text,
+                s1 => DoHorizontalRules(s1,
+                    s2 => DoLists(s2,
+                    sn => FormParagraphs(sn))));
+
+            //text = DoCodeBlocks(text);
+            //text = DoBlockQuotes(text);
+
+            //// We already ran HashHTMLBlocks() before, in Markdown(), but that
+            //// was to escape raw HTML in the original Markdown source. This time,
+            //// we're escaping the markup we've just created, so that we don't wrap
+            //// <p> tags around block-level tags.
+            //text = HashHTMLBlocks(text);
+
+            //text = FormParagraphs(text);
+
+            //return text;
+        }
+
+        /// <summary>
+        /// Perform transformations that occur *within* block-level tags like paragraphs, headers, and list items.
+        /// </summary>
+        private IEnumerable<Inline> RunSpanGamut(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return DoCodeSpans(text,
+                s0 => DoImages(s0,
+                s1 => DoAnchors(s1,
+                s2 => DoItalicsAndBold(s2,
+                s3 => DoText(s3)))));
+
+            //text = EscapeSpecialCharsWithinTagAttributes(text);
+            //text = EscapeBackslashes(text);
+
+            //// Images must come first, because ![foo][f] looks like an anchor.
+            //text = DoImages(text);
+            //text = DoAnchors(text);
+
+            //// Must come after DoAnchors(), because you can use < and >
+            //// delimiters in inline links like [this](<url>).
+            //text = DoAutoLinks(text);
+
+            //text = EncodeAmpsAndAngles(text);
+            //text = DoItalicsAndBold(text);
+            //text = DoHardBreaks(text);
+
+            //return text;
+        }
+
+        private static Regex _newlinesLeadingTrailing = new Regex(@"^\n+|\n+\z", RegexOptions.Compiled);
+        private static Regex _newlinesMultiple = new Regex(@"\n{2,}", RegexOptions.Compiled);
+        private static Regex _leadingWhitespace = new Regex(@"^[ ]*", RegexOptions.Compiled);
+
+        /// <summary>
+        /// splits on two or more newlines, to form "paragraphs";    
+        /// </summary>
+        private IEnumerable<Block> FormParagraphs(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            // split on two or more newlines
+            string[] grafs = _newlinesMultiple.Split(_newlinesLeadingTrailing.Replace(text, ""));
+
+            foreach (var g in grafs)
+            {
+                yield return Create<Paragraph, Inline>(RunSpanGamut(g));
+            }
+        }
+
+        private static string _nestedBracketsPattern;
+
+        /// <summary>
+        /// Reusable pattern to match balanced [brackets]. See Friedl's 
+        /// "Mastering Regular Expressions", 2nd Ed., pp. 328-331.
+        /// </summary>
+        private static string GetNestedBracketsPattern()
+        {
+            // in other words [this] and [this[also]] and [this[also[too]]]
+            // up to _nestDepth
+            if (_nestedBracketsPattern == null)
+                _nestedBracketsPattern =
+                    RepeatString(@"
+                    (?>              # Atomic matching
+                       [^\[\]]+      # Anything other than brackets
+                     |
+                       \[
+                           ", _nestDepth) + RepeatString(
+                    @" \]
+                    )*"
+                    , _nestDepth);
+            return _nestedBracketsPattern;
+        }
+
+        private static string _nestedParensPattern;
+
+        /// <summary>
+        /// Reusable pattern to match balanced (parens). See Friedl's 
+        /// "Mastering Regular Expressions", 2nd Ed., pp. 328-331.
+        /// </summary>
+        private static string GetNestedParensPattern()
+        {
+            // in other words (this) and (this(also)) and (this(also(too)))
+            // up to _nestDepth
+            if (_nestedParensPattern == null)
+                _nestedParensPattern =
+                    RepeatString(@"
+                    (?>              # Atomic matching
+                       [^()\s]+      # Anything other than parens or whitespace
+                     |
+                       \(
+                           ", _nestDepth) + RepeatString(
+                    @" \)
+                    )*"
+                    , _nestDepth);
+            return _nestedParensPattern;
+        }
+
+        private static string _nestedParensPatternWithWhiteSpace;
+
+        /// <summary>
+        /// Reusable pattern to match balanced (parens), including whitespace. See Friedl's 
+        /// "Mastering Regular Expressions", 2nd Ed., pp. 328-331.
+        /// </summary>
+        private static string GetNestedParensPatternWithWhiteSpace()
+        {
+            // in other words (this) and (this(also)) and (this(also(too)))
+            // up to _nestDepth
+            if (_nestedParensPatternWithWhiteSpace == null)
+                _nestedParensPatternWithWhiteSpace =
+                    RepeatString(@"
+                    (?>              # Atomic matching
+                       [^()]+      # Anything other than parens
+                     |
+                       \(
+                           ", _nestDepth) + RepeatString(
+                    @" \)
+                    )*"
+                    , _nestDepth);
+            return _nestedParensPatternWithWhiteSpace;
+        }
+
+        private static Regex _imageInline = new Regex(string.Format(@"
+                (                           # wrap whole match in $1
+                    !\[
+                        ({0})               # link text = $2
+                    \]
+                    \(                      # literal paren
+                        [ ]*
+                        ({1})               # href = $3
+                        [ ]*
+                        (                   # $4
+                        (['""])           # quote char = $5
+                        (.*?)               # title = $6
+                        \5                  # matching quote
+                        #[ ]*                # ignore any spaces between closing quote and )
+                        )?                  # title is optional
+                    \)
+                )", GetNestedBracketsPattern(), GetNestedParensPatternWithWhiteSpace()),
+                  RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        private static Regex _anchorInline = new Regex(string.Format(@"
+                (                           # wrap whole match in $1
+                    \[
+                        ({0})               # link text = $2
+                    \]
+                    \(                      # literal paren
+                        [ ]*
+                        ({1})               # href = $3
+                        [ ]*
+                        (                   # $4
+                        (['""])           # quote char = $5
+                        (.*?)               # title = $6
+                        \5                  # matching quote
+                        [ ]*                # ignore any spaces between closing quote and )
+                        )?                  # title is optional
+                    \)
+                )", GetNestedBracketsPattern(), GetNestedParensPattern()),
+                  RegexOptions.Singleline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown images into images
+        /// </summary>
+        /// <remarks>
+        /// ![image alt](url) 
+        /// </remarks>
+        private IEnumerable<Inline> DoImages(string text, Func<string, IEnumerable<Inline>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return Evaluate(text, _imageInline, ImageInlineEvaluator, defaultHandler);
+        }
+
+        private Inline ImageInlineEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string linkText = match.Groups[2].Value;
+            string url = match.Groups[3].Value;
+            BitmapImage imgSource = null;
+            try
+            {
+                if (!Uri.IsWellFormedUriString(url, UriKind.Absolute) && !System.IO.Path.IsPathRooted(url))
+                {
+                    url = System.IO.Path.Combine(AssetPathRoot ?? string.Empty, url);
+                }
+
+                imgSource = new BitmapImage(new Uri(url, UriKind.RelativeOrAbsolute));
+            }
+            catch (Exception)
+            {
+                return new Run("!" + url) { Foreground = Brushes.Red };
+            }
+
+            Image image = new Image { Source = imgSource, Tag = linkText };
+            if (ImageStyle == null)
+            {
+                image.Margin = new Thickness(0);
+            }
+            else
+            {
+                image.Style = ImageStyle;
+            }
+
+            // Bind size so document is updated when image is downloaded
+            if (imgSource.IsDownloading)
+            {
+                Binding binding = new Binding(nameof(BitmapImage.Width));
+                binding.Source = imgSource;
+                binding.Mode = BindingMode.OneWay;
+
+                BindingExpressionBase bindingExpression = BindingOperations.SetBinding(image, Image.WidthProperty, binding);
+                EventHandler downloadCompletedHandler = null;
+                downloadCompletedHandler = (sender, e) =>
+                {
+                    imgSource.DownloadCompleted -= downloadCompletedHandler;
+                    bindingExpression.UpdateTarget();
+                };
+                imgSource.DownloadCompleted += downloadCompletedHandler;
+            }
+            else
+            {
+                image.Width = imgSource.Width;
+            }
+
+            return new InlineUIContainer(image);
+        }
+
+        /// <summary>
+        /// Turn Markdown link shortcuts into hyperlinks
+        /// </summary>
+        /// <remarks>
+        /// [link text](url "title") 
+        /// </remarks>
+        private IEnumerable<Inline> DoAnchors(string text, Func<string, IEnumerable<Inline>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            // Next, inline-style links: [link text](url "optional title") or [link text](url "optional title")
+            return Evaluate(text, _anchorInline, AnchorInlineEvaluator, defaultHandler);
+        }
+
+        private Inline AnchorInlineEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string linkText = match.Groups[2].Value;
+            string url = match.Groups[3].Value;
+            string title = match.Groups[6].Value;
+
+            var result = Create<Hyperlink, Inline>(RunSpanGamut(linkText));
+            result.Command = HyperlinkCommand;
+            result.CommandParameter = url;
+            if (LinkStyle != null)
+            {
+                result.Style = LinkStyle;
+            }
+
+            return result;
+        }
+
+        private static Regex _headerSetext = new Regex(@"
+                ^(.+?)
+                [ ]*
+                \n
+                (=+|-+)     # $1 = string of ='s or -'s
+                [ ]*
+                \n+",
+    RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        private static Regex _headerAtx = new Regex(@"
+                ^(\#{1,6})  # $1 = string of #'s
+                [ ]*
+                (.+?)       # $2 = Header text
+                [ ]*
+                \#*         # optional closing #'s (not counted)
+                \n+",
+            RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown headers into HTML header tags
+        /// </summary>
+        /// <remarks>
+        /// Header 1  
+        /// ========  
+        /// 
+        /// Header 2  
+        /// --------  
+        /// 
+        /// # Header 1  
+        /// ## Header 2  
+        /// ## Header 2 with closing hashes ##  
+        /// ...  
+        /// ###### Header 6  
+        /// </remarks>
+        private IEnumerable<Block> DoHeaders(string text, Func<string, IEnumerable<Block>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return Evaluate<Block>(text, _headerSetext, m => SetextHeaderEvaluator(m),
+                s => Evaluate<Block>(s, _headerAtx, m => AtxHeaderEvaluator(m), defaultHandler));
+        }
+
+        private Block SetextHeaderEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string header = match.Groups[1].Value;
+            int level = match.Groups[2].Value.StartsWith("=") ? 1 : 2;
+
+            //TODO: Style the paragraph based on the header level
+            return CreateHeader(level, RunSpanGamut(header.Trim()));
+        }
+
+        private Block AtxHeaderEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string header = match.Groups[2].Value;
+            int level = match.Groups[1].Value.Length;
+            return CreateHeader(level, RunSpanGamut(header));
+        }
+
+        public Block CreateHeader(int level, IEnumerable<Inline> content)
+        {
+            if (content == null)
+            {
+                throw new ArgumentNullException("content");
+            }
+
+            var block = Create<Paragraph, Inline>(content);
+
+            switch (level)
+            {
+                case 1:
+                    if (Heading1Style != null)
+                    {
+                        block.Style = Heading1Style;
+                    }
+                    break;
+
+                case 2:
+                    if (Heading2Style != null)
+                    {
+                        block.Style = Heading2Style;
+                    }
+                    break;
+
+                case 3:
+                    if (Heading3Style != null)
+                    {
+                        block.Style = Heading3Style;
+                    }
+                    break;
+
+                case 4:
+                    if (Heading4Style != null)
+                    {
+                        block.Style = Heading4Style;
+                    }
+                    break;
+            }
+
+            return block;
+        }
+
+        private static Regex _horizontalRules = new Regex(@"
+            ^[ ]{0,3}         # Leading space
+                ([-*_])       # $1: First marker
+                (?>           # Repeated marker group
+                    [ ]{0,2}  # Zero, one, or two spaces.
+                    \1        # Marker character
+                ){2,}         # Group repeated at least twice
+                [ ]*          # Trailing spaces
+                $             # End of line.
+            ", RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown horizontal rules into HTML hr tags
+        /// </summary>
+        /// <remarks>
+        /// ***  
+        /// * * *  
+        /// ---
+        /// - - -
+        /// </remarks>
+        private IEnumerable<Block> DoHorizontalRules(string text, Func<string, IEnumerable<Block>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return Evaluate(text, _horizontalRules, RuleEvaluator, defaultHandler);
+        }
+
+        private Block RuleEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            Line line = new Line();
+            if (SeparatorStyle == null)
+            {
+                line.X2 = 1;
+                line.StrokeThickness = 1.0;
+            }
+            else
+            {
+                line.Style = SeparatorStyle;
+            }
+
+            var container = new BlockUIContainer(line);
+            return container;
+        }
+
+        private static string _wholeList = string.Format(@"
+            (                               # $1 = whole list
+              (                             # $2
+                [ ]{{0,{1}}}
+                ({0})                       # $3 = first list item marker
+                [ ]+
+              )
+              (?s:.+?)
+              (                             # $4
+                  \z
+                |
+                  \n{{2,}}
+                  (?=\S)
+                  (?!                       # Negative lookahead for another list item marker
+                    [ ]*
+                    {0}[ ]+
+                  )
+              )
+            )", string.Format("(?:{0}|{1})", _markerUL, _markerOL), _tabWidth - 1);
+
+        private static Regex _listNested = new Regex(@"^" + _wholeList,
+            RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        private static Regex _listTopLevel = new Regex(@"(?:(?<=\n\n)|\A\n?)" + _wholeList,
+            RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown lists into HTML ul and ol and li tags
+        /// </summary>
+        private IEnumerable<Block> DoLists(string text, Func<string, IEnumerable<Block>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            // We use a different prefix before nested lists than top-level lists.
+            // See extended comment in _ProcessListItems().
+            if (_listLevel > 0)
+                return Evaluate(text, _listNested, ListEvaluator, defaultHandler);
+            else
+                return Evaluate(text, _listTopLevel, ListEvaluator, defaultHandler);
+        }
+
+        private Block ListEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string list = match.Groups[1].Value;
+            string listType = Regex.IsMatch(match.Groups[3].Value, _markerUL) ? "ul" : "ol";
+
+            // Turn double returns into triple returns, so that we can make a
+            // paragraph for the last item in a list, if necessary:
+            list = Regex.Replace(list, @"\n{2,}", "\n\n\n");
+
+            var resultList = Create<List, ListItem>(ProcessListItems(list, listType == "ul" ? _markerUL : _markerOL));
+
+            resultList.MarkerStyle = listType == "ul" ? TextMarkerStyle.Disc : TextMarkerStyle.Decimal;
+
+            return resultList;
+        }
+
+        /// <summary>
+        /// Process the contents of a single ordered or unordered list, splitting it
+        /// into individual list items.
+        /// </summary>
+        private IEnumerable<ListItem> ProcessListItems(string list, string marker)
+        {
+            // The listLevel global keeps track of when we're inside a list.
+            // Each time we enter a list, we increment it; when we leave a list,
+            // we decrement. If it's zero, we're not in a list anymore.
+
+            // We do this because when we're not inside a list, we want to treat
+            // something like this:
+
+            //    I recommend upgrading to version
+            //    8. Oops, now this line is treated
+            //    as a sub-list.
+
+            // As a single paragraph, despite the fact that the second line starts
+            // with a digit-period-space sequence.
+
+            // Whereas when we're inside a list (or sub-list), that line will be
+            // treated as the start of a sub-list. What a kludge, huh? This is
+            // an aspect of Markdown's syntax that's hard to parse perfectly
+            // without resorting to mind-reading. Perhaps the solution is to
+            // change the syntax rules such that sub-lists must start with a
+            // starting cardinal number; e.g. "1." or "a.".
+
+            _listLevel++;
+            try
+            {
+                // Trim trailing blank lines:
+                list = Regex.Replace(list, @"\n{2,}\z", "\n");
+
+                string pattern = string.Format(
+                  @"(\n)?                      # leading line = $1
+                (^[ ]*)                    # leading whitespace = $2
+                ({0}) [ ]+                 # list marker = $3
+                ((?s:.+?)                  # list item text = $4
+                (\n{{1,2}}))      
+                (?= \n* (\z | \2 ({0}) [ ]+))", marker);
+
+                var regex = new Regex(pattern, RegexOptions.IgnorePatternWhitespace | RegexOptions.Multiline);
+                var matches = regex.Matches(list);
+                foreach (Match m in matches)
+                {
+                    yield return ListItemEvaluator(m);
+                }
+            }
+            finally
+            {
+                _listLevel--;
+            }
+        }
+
+        private ListItem ListItemEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string item = match.Groups[4].Value;
+            string leadingLine = match.Groups[1].Value;
+
+            if (!String.IsNullOrEmpty(leadingLine) || Regex.IsMatch(item, @"\n{2,}"))
+                // we could correct any bad indentation here..
+                return Create<ListItem, Block>(RunBlockGamut(item));
+            else
+            {
+                // recursion for sub-lists
+                return Create<ListItem, Block>(RunBlockGamut(item));
+            }
+        }
+
+        private static Regex _codeSpan = new Regex(@"
+                    (?<!\\)   # Character before opening ` can't be a backslash
+                    (`+)      # $1 = Opening run of `
+                    (.+?)     # $2 = The code block
+                    (?<!`)
+                    \1
+                    (?!`)", RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown `code spans` into HTML code tags
+        /// </summary>
+        private IEnumerable<Inline> DoCodeSpans(string text, Func<string, IEnumerable<Inline>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            //    * You can use multiple backticks as the delimiters if you want to
+            //        include literal backticks in the code span. So, this input:
+            //
+            //        Just type ``foo `bar` baz`` at the prompt.
+            //
+            //        Will translate to:
+            //
+            //          <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
+            //
+            //        There's no arbitrary limit to the number of backticks you
+            //        can use as delimters. If you need three consecutive backticks
+            //        in your code, use four for delimiters, etc.
+            //
+            //    * You can use spaces to get literal backticks at the edges:
+            //
+            //          ... type `` `bar` `` ...
+            //
+            //        Turns to:
+            //
+            //          ... type <code>`bar`</code> ...         
+            //
+
+            return Evaluate(text, _codeSpan, CodeSpanEvaluator, defaultHandler);
+        }
+
+        private Inline CodeSpanEvaluator(Match match)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            string span = match.Groups[2].Value;
+            span = Regex.Replace(span, @"^[ ]*", ""); // leading whitespace
+            span = Regex.Replace(span, @"[ ]*$", ""); // trailing whitespace
+
+            var result = new Run(span);
+            if (CodeStyle != null)
+            {
+                result.Style = CodeStyle;
+            }
+
+            return result;
+        }
+
+        private static Regex _bold = new Regex(@"(\*\*|__) (?=\S) (.+?[*_]*) (?<=\S) \1",
+            RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled);
+        private static Regex _strictBold = new Regex(@"([\W_]|^) (\*\*|__) (?=\S) ([^\r]*?\S[\*_]*) \2 ([\W_]|$)",
+            RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled);
+
+        private static Regex _italic = new Regex(@"(\*|_) (?=\S) (.+?) (?<=\S) \1",
+            RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled);
+        private static Regex _strictItalic = new Regex(@"([\W_]|^) (\*|_) (?=\S) ([^\r\*_]*?\S) \2 ([\W_]|$)",
+            RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Turn Markdown *italics* and **bold** into HTML strong and em tags
+        /// </summary>
+        private IEnumerable<Inline> DoItalicsAndBold(string text, Func<string, IEnumerable<Inline>> defaultHandler)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            // <strong> must go first, then <em>
+            if (StrictBoldItalic)
+            {
+                return Evaluate<Inline>(text, _strictBold, m => BoldEvaluator(m, 3),
+                    s1 => Evaluate<Inline>(s1, _strictItalic, m => ItalicEvaluator(m, 3),
+                    s2 => defaultHandler(s2)));
+            }
+            else
+            {
+                return Evaluate<Inline>(text, _bold, m => BoldEvaluator(m, 2),
+                   s1 => Evaluate<Inline>(s1, _italic, m => ItalicEvaluator(m, 2),
+                   s2 => defaultHandler(s2)));
+            }
+        }
+
+        private Inline ItalicEvaluator(Match match, int contentGroup)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            var content = match.Groups[contentGroup].Value;
+            return Create<Italic, Inline>(RunSpanGamut(content));
+        }
+
+        private Inline BoldEvaluator(Match match, int contentGroup)
+        {
+            if (match == null)
+            {
+                throw new ArgumentNullException("match");
+            }
+
+            var content = match.Groups[contentGroup].Value;
+            return Create<Bold, Inline>(RunSpanGamut(content));
+        }
+
+        private static Regex _outDent = new Regex(@"^[ ]{1," + _tabWidth + @"}", RegexOptions.Multiline | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Remove one level of line-leading spaces
+        /// </summary>
+        private string Outdent(string block)
+        {
+            return _outDent.Replace(block, "");
+        }
+
+        /// <summary>
+        /// convert all tabs to _tabWidth spaces; 
+        /// standardizes line endings from DOS (CR LF) or Mac (CR) to UNIX (LF); 
+        /// makes sure text ends with a couple of newlines; 
+        /// removes any blank lines (only spaces) in the text
+        /// </summary>
+        private string Normalize(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            var output = new StringBuilder(text.Length);
+            var line = new StringBuilder();
+            bool valid = false;
+
+            for (int i = 0; i < text.Length; i++)
+            {
+                switch (text[i])
+                {
+                    case '\n':
+                        if (valid)
+                            output.Append(line);
+                        output.Append('\n');
+                        line.Length = 0;
+                        valid = false;
+                        break;
+                    case '\r':
+                        if ((i < text.Length - 1) && (text[i + 1] != '\n'))
+                        {
+                            if (valid)
+                                output.Append(line);
+                            output.Append('\n');
+                            line.Length = 0;
+                            valid = false;
+                        }
+                        break;
+                    case '\t':
+                        int width = (_tabWidth - line.Length % _tabWidth);
+                        for (int k = 0; k < width; k++)
+                            line.Append(' ');
+                        break;
+                    case '\x1A':
+                        break;
+                    default:
+                        if (!valid && text[i] != ' ')
+                            valid = true;
+                        line.Append(text[i]);
+                        break;
+                }
+            }
+
+            if (valid)
+                output.Append(line);
+            output.Append('\n');
+
+            // add two newlines to the end before return
+            return output.Append("\n\n").ToString();
+        }
+
+        /// <summary>
+        /// this is to emulate what's evailable in PHP
+        /// </summary>
+        private static string RepeatString(string text, int count)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            var sb = new StringBuilder(text.Length * count);
+            for (int i = 0; i < count; i++)
+                sb.Append(text);
+            return sb.ToString();
+        }
+
+        private TResult Create<TResult, TContent>(IEnumerable<TContent> content)
+            where TResult : IAddChild, new()
+        {
+            var result = new TResult();
+            foreach (var c in content)
+            {
+                result.AddChild(c);
+            }
+
+            return result;
+        }
+
+        private IEnumerable<T> Evaluate<T>(string text, Regex expression, Func<Match, T> build, Func<string, IEnumerable<T>> rest)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            var matches = expression.Matches(text);
+            var index = 0;
+            foreach (Match m in matches)
+            {
+                if (m.Index > index)
+                {
+                    var prefix = text.Substring(index, m.Index - index);
+                    foreach (var t in rest(prefix))
+                    {
+                        yield return t;
+                    }
+                }
+
+                yield return build(m);
+
+                index = m.Index + m.Length;
+            }
+
+            if (index < text.Length)
+            {
+                var suffix = text.Substring(index, text.Length - index);
+                foreach (var t in rest(suffix))
+                {
+                    yield return t;
+                }
+            }
+        }
+
+        private static Regex _eoln = new Regex("\\s+");
+
+        public IEnumerable<Inline> DoText(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            var t = _eoln.Replace(text, " ");
+            yield return new Run(t);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Artemis/Artemis/Utilities/Markdown/TextToFlowDocumentConverter.cs b/Artemis/Artemis/Utilities/Markdown/TextToFlowDocumentConverter.cs
new file mode 100644
index 000000000..cfafc9bf0
--- /dev/null
+++ b/Artemis/Artemis/Utilities/Markdown/TextToFlowDocumentConverter.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Data;
+
+namespace Artemis.Utilities.Markdown
+{
+    public class TextToFlowDocumentConverter : DependencyObject, IValueConverter
+    {
+        public Markdown Markdown
+        {
+            get { return (Markdown)GetValue(MarkdownProperty); }
+            set { SetValue(MarkdownProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Markdown.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty MarkdownProperty =
+            DependencyProperty.Register("Markdown", typeof(Markdown), typeof(TextToFlowDocumentConverter), new PropertyMetadata(null));
+
+        /// <summary>
+        /// Converts a value. 
+        /// </summary>
+        /// <returns>
+        /// A converted value. If the method returns null, the valid null value is used.
+        /// </returns>
+        /// <param name="value">The value produced by the binding source.</param>
+        /// <param name="targetType">The type of the binding target property.</param>
+        /// <param name="parameter">The converter parameter to use.</param>
+        /// <param name="culture">The culture to use in the converter.</param>
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+
+            var text = (string)value;
+
+            var engine = Markdown ?? mMarkdown.Value;
+
+            return engine.Transform(text);
+        }
+
+        /// <summary>
+        /// Converts a value. 
+        /// </summary>
+        /// <returns>
+        /// A converted value. If the method returns null, the valid null value is used.
+        /// </returns>
+        /// <param name="value">The value that is produced by the binding target.</param>
+        /// <param name="targetType">The type to convert to.</param>
+        /// <param name="parameter">The converter parameter to use.</param>
+        /// <param name="culture">The culture to use in the converter.</param>
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+
+        private Lazy<Markdown> mMarkdown
+            = new Lazy<Markdown>(() => new Markdown());
+    }
+}
\ No newline at end of file
diff --git a/Artemis/Artemis/Utilities/Updater.cs b/Artemis/Artemis/Utilities/Updater.cs
index fe9b5f51d..214307522 100644
--- a/Artemis/Artemis/Utilities/Updater.cs
+++ b/Artemis/Artemis/Utilities/Updater.cs
@@ -60,8 +60,8 @@ namespace Artemis.Utilities
         {
             var settings = SettingsProvider.Load<GeneralSettings>();
             var currentVersion = Assembly.GetExecutingAssembly().GetName().Version;
-            if ((settings.LastRanVersion != null) && (currentVersion > settings.LastRanVersion))
-            {
+//            if ((settings.LastRanVersion != null) && (currentVersion > settings.LastRanVersion))
+//            {
                 Logger.Info("Updated from {0} to {1}, showing changelog.", settings.LastRanVersion, currentVersion);
 
                 // Ask the user whether he/she wants to see what's new
@@ -73,7 +73,7 @@ namespace Artemis.Utilities
                 // If user wants to see changelog, show it to them
                 if ((showChanges != null) && showChanges.Value)
                     await ShowChanges(dialogService, currentVersion);
-            }
+//            }
 
             settings.LastRanVersion = currentVersion;
             settings.Save();
@@ -114,7 +114,7 @@ namespace Artemis.Utilities
             }
 
             if (release != null)
-                dialogService.ShowMessageBox(release["name"].Value<string>(), release["body"].Value<string>());
+                dialogService.ShowMarkdownDialog(release["name"].Value<string>(), release["body"].Value<string>());
             else
                 dialogService.ShowMessageBox("Couldn't fetch release",
                     "Sorry, Artemis was unable to fetch the release data off of GitHub.\n" +
diff --git a/Artemis/Artemis/ViewModels/DebugViewModel.cs b/Artemis/Artemis/ViewModels/DebugViewModel.cs
index e8b891f95..2dab9f89b 100644
--- a/Artemis/Artemis/ViewModels/DebugViewModel.cs
+++ b/Artemis/Artemis/ViewModels/DebugViewModel.cs
@@ -1,4 +1,7 @@
-using System.Windows;
+using System;
+using System.IO;
+using System.Linq;
+using System.Windows;
 using System.Windows.Media;
 using Caliburn.Micro;
 
@@ -6,7 +9,6 @@ namespace Artemis.ViewModels
 {
     public class DebugViewModel : Screen
     {
-
         private DrawingImage _razerDisplay;
 
         public DrawingImage RazerDisplay
@@ -20,6 +22,18 @@ namespace Artemis.ViewModels
             }
         }
 
+        public void OpenLog()
+        {
+            // Get the logging directory
+            var logDir = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
+                                           + @"\Artemis\logs");
+            // Get the newest log file
+            var currentLog = logDir.GetFiles().OrderByDescending(f => f.LastWriteTime).FirstOrDefault();
+            // Open the file with the user's default program
+            if (currentLog != null)
+                System.Diagnostics.Process.Start(currentLog.FullName);
+        }
+
         public void UpdateRazerDisplay(Color[,] colors)
         {
             // No point updating the display if the view isn't visible
@@ -31,10 +45,8 @@ namespace Artemis.ViewModels
             {
                 dc.PushClip(new RectangleGeometry(new Rect(0, 0, 22, 6)));
                 for (var y = 0; y < 6; y++)
-                {
                     for (var x = 0; x < 22; x++)
                         dc.DrawRectangle(new SolidColorBrush(colors[y, x]), null, new Rect(x, y, 1, 1));
-                }
             }
             var drawnDisplay = new DrawingImage(visual.Drawing);
             drawnDisplay.Freeze();
diff --git a/Artemis/Artemis/Views/DebugView.xaml b/Artemis/Artemis/Views/DebugView.xaml
index 5c9dd7b8d..32f3d9e9d 100644
--- a/Artemis/Artemis/Views/DebugView.xaml
+++ b/Artemis/Artemis/Views/DebugView.xaml
@@ -4,8 +4,9 @@
                       xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                       xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                       xmlns:controls="http://metro.mahapps.com/winfx/xaml/controls"
+                      xmlns:log="clr-namespace:Artemis.Controls.Log"
                       mc:Ignorable="d"
-                      Title="DebugView" Height="329.904" Width="446.624"
+                      Title="DebugView" Height="600" Width="900"
                       GlowBrush="{DynamicResource AccentColorBrush}">
     <Grid Margin="10">
         <Grid.ColumnDefinitions>
@@ -13,17 +14,27 @@
             <ColumnDefinition />
         </Grid.ColumnDefinitions>
         <Grid.RowDefinitions>
+            <RowDefinition Height="40" />
+            <RowDefinition Height="80" />
             <RowDefinition Height="40" />
             <RowDefinition Height="*" />
         </Grid.RowDefinitions>
 
         <!-- Razer output -->
-        <Label Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2" FontSize="20" Content="Razer display" />
+        <Label Grid.Row="0" Grid.Column="0" FontSize="20" Content="Razer display" />
         <Border Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Height="75" Width="300" HorizontalAlignment="Left"
                 VerticalAlignment="Top" BorderThickness="1" BorderBrush="{StaticResource GrayBrush7}"
                 SnapsToDevicePixels="True">
             <Image Source="{Binding Path=RazerDisplay}" />
         </Border>
 
+        <!-- Log -->
+        <Label Grid.Row="2" Grid.Column="0" FontSize="20" Content="Log" />
+        <Button x:Name="OpenLog" Grid.Row="2" Grid.Column="1" HorizontalAlignment="Right"
+                Style="{DynamicResource SquareButtonStyle}" Content="Open log file" VerticalAlignment="Center" />
+        <Border Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2" BorderThickness="1"
+                BorderBrush="{StaticResource GrayBrush7}" SnapsToDevicePixels="True">
+            <log:LoggingControl />
+        </Border>
     </Grid>
 </controls:MetroWindow>
\ No newline at end of file