diff --git a/GitDiffMargin.Unit.Tests/Git/GitDiffParserTests.cs b/GitDiffMargin.Unit.Tests/Git/GitDiffParserTests.cs
index f55ae9d..0d37fcd 100644
--- a/GitDiffMargin.Unit.Tests/Git/GitDiffParserTests.cs
+++ b/GitDiffMargin.Unit.Tests/Git/GitDiffParserTests.cs
@@ -10,7 +10,7 @@ namespace GitDiffMargin.Unit.Tests.Git
     // ReSharper disable InconsistentNaming 
 
     [TestFixture]
-    public class Tests1
+    public class GitDiffParserTests
     {
         /*
         git diff --unified=0 Sources/skyeEditor/Core/Model/Dependency/IModelDependency.cs                                                  
diff --git a/GitDiffMargin.Unit.Tests/GitDiffMargin.Unit.Tests.csproj b/GitDiffMargin.Unit.Tests/GitDiffMargin.Unit.Tests.csproj
index e434d56..04d42ec 100644
--- a/GitDiffMargin.Unit.Tests/GitDiffMargin.Unit.Tests.csproj
+++ b/GitDiffMargin.Unit.Tests/GitDiffMargin.Unit.Tests.csproj
@@ -37,12 +37,13 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.VisualStudio.Text.Data, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
-    <Reference Include="nunit.framework, Version=2.6.2.12296, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+    <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\NUnit.2.6.2\lib\nunit.framework.dll</HintPath>
+      <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
     </Reference>
-    <Reference Include="Shouldly">
-      <HintPath>..\packages\Shouldly.1.1.1.1\lib\35\Shouldly.dll</HintPath>
+    <Reference Include="Shouldly, Version=2.1.1.0, Culture=neutral, PublicKeyToken=6042cbcb05cbc941, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Shouldly.2.1.1\lib\net40\Shouldly.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -68,7 +69,6 @@
     </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/GitDiffMargin.Unit.Tests/packages.config b/GitDiffMargin.Unit.Tests/packages.config
index 5d23e6a..37e9079 100644
--- a/GitDiffMargin.Unit.Tests/packages.config
+++ b/GitDiffMargin.Unit.Tests/packages.config
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="NUnit" version="2.6.2" targetFramework="net45" />
-  <package id="Shouldly" version="1.1.1.1" />
+  <package id="NUnit" version="2.6.3" targetFramework="net45" />
+  <package id="Shouldly" version="2.1.1" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/GitDiffMargin.sln b/GitDiffMargin.sln
index 9d2d1f1..698440b 100644
--- a/GitDiffMargin.sln
+++ b/GitDiffMargin.sln
@@ -1,16 +1,12 @@
 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.30501.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitDiffMargin", "GitDiffMargin\GitDiffMargin.csproj", "{233B6F13-7687-4823-870B-A8F44B79D4F0}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitDiffMargin.Unit.Tests", "GitDiffMargin.Unit.Tests\GitDiffMargin.Unit.Tests.csproj", "{B954F515-AC6F-40D4-8169-03985AC62B06}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{0A0AF18B-6698-4A12-B5AB-C37929F583E4}"
-	ProjectSection(SolutionItems) = preProject
-		.nuget\NuGet.exe = .nuget\NuGet.exe
-		.nuget\NuGet.targets = .nuget\NuGet.targets
-	EndProjectSection
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
diff --git a/GitDiffMargin/BackgroundParser.cs b/GitDiffMargin/Core/BackgroundParser.cs
similarity index 97%
rename from GitDiffMargin/BackgroundParser.cs
rename to GitDiffMargin/Core/BackgroundParser.cs
index 58f4889..6138314 100644
--- a/GitDiffMargin/BackgroundParser.cs
+++ b/GitDiffMargin/Core/BackgroundParser.cs
@@ -28,7 +28,7 @@
 using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Text;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Core
 {
     public abstract class BackgroundParser : IDisposable
     {
@@ -45,7 +45,7 @@ public abstract class BackgroundParser : IDisposable
 
         public event EventHandler<ParseResultEventArgs> ParseComplete;
 
-        public BackgroundParser(ITextBuffer textBuffer, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService)
+        protected BackgroundParser(ITextBuffer textBuffer, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService)
         {
             if (textBuffer == null)
                 throw new ArgumentNullException("textBuffer");
diff --git a/GitDiffMargin/DiffParseResultEventArgs.cs b/GitDiffMargin/Core/DiffParseResultEventArgs.cs
similarity index 95%
rename from GitDiffMargin/DiffParseResultEventArgs.cs
rename to GitDiffMargin/Core/DiffParseResultEventArgs.cs
index dc45766..282a51d 100644
--- a/GitDiffMargin/DiffParseResultEventArgs.cs
+++ b/GitDiffMargin/Core/DiffParseResultEventArgs.cs
@@ -3,7 +3,7 @@
 using GitDiffMargin.Git;
 using Microsoft.VisualStudio.Text;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Core
 {
     public class DiffParseResultEventArgs : ParseResultEventArgs
     {
diff --git a/GitDiffMargin/DiffUpdateBackgroundParser.cs b/GitDiffMargin/Core/DiffUpdateBackgroundParser.cs
similarity index 93%
rename from GitDiffMargin/DiffUpdateBackgroundParser.cs
rename to GitDiffMargin/Core/DiffUpdateBackgroundParser.cs
index 54fa82d..cdf5d0c 100644
--- a/GitDiffMargin/DiffUpdateBackgroundParser.cs
+++ b/GitDiffMargin/Core/DiffUpdateBackgroundParser.cs
@@ -1,120 +1,119 @@
-using System.IO;
-using System.Threading;
-using GitDiffMargin.Git;
-using System;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.VisualStudio.Text;
-using Stopwatch = System.Diagnostics.Stopwatch;
-using Task = System.Threading.Tasks.Task;
-
-namespace GitDiffMargin
-{
-    public class DiffUpdateBackgroundParser : BackgroundParser
-    {
-        private readonly FileSystemWatcher _watcher;
-        private readonly IGitCommands _commands;
-        private readonly ITextDocument _textDocument;
-        private readonly ITextBuffer _documentBuffer;
-
-        public DiffUpdateBackgroundParser(ITextBuffer textBuffer, ITextBuffer documentBuffer, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService, IGitCommands commands)
-            : base(textBuffer, taskScheduler, textDocumentFactoryService)
-        {
-            _documentBuffer = documentBuffer;
-            _commands = commands;
-            ReparseDelay = TimeSpan.FromMilliseconds(500);
-
-            if (TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out _textDocument))
-            {
-                if (_commands.IsGitRepository(_textDocument.FilePath))
-                {
-                    _textDocument.FileActionOccurred += OnFileActionOccurred;
-
-                    var solutionDirectory = _commands.GetGitRepository(_textDocument.FilePath);
-
-                    if (!string.IsNullOrWhiteSpace(solutionDirectory))
-                    {
-                        var gitDirectory = Path.Combine(solutionDirectory, ".git");
-                        _watcher = new FileSystemWatcher(gitDirectory);
-                        _watcher.Changed += HandleFileSystemChanged;
-                        _watcher.Created += HandleFileSystemChanged;
-                        _watcher.Deleted += HandleFileSystemChanged;
-                        _watcher.Renamed += HandleFileSystemChanged;
-                        _watcher.EnableRaisingEvents = true;
-                    }
-                }
-            }
-        }
-        
-        private void HandleFileSystemChanged(object sender, FileSystemEventArgs e)
-        {
-            Action action = () => ProcessFileSystemChange(e);
-            Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
-        }
-
-        private void ProcessFileSystemChange(FileSystemEventArgs e)
-        {
-            if (e.ChangeType == WatcherChangeTypes.Changed && Directory.Exists(e.FullPath))
-                return;
-
-            if (string.Equals(Path.GetExtension(e.Name), ".lock", StringComparison.OrdinalIgnoreCase))
-                return;
-
-            MarkDirty(true);
-        }
-
-        private void OnFileActionOccurred(object sender, TextDocumentFileActionEventArgs e)
-        {
-            if ((e.FileActionType & FileActionTypes.ContentSavedToDisk) != 0)
-            {
-                MarkDirty(true);
-            }
-        }
-
-        public override string Name
-        {
-            get
-            {
-                return "Git Diff Analyzer";
-            }
-        }
-
-        protected override void ReParseImpl()
-        {
-            try
-            {
-                var stopwatch = Stopwatch.StartNew();
-
-                var snapshot = TextBuffer.CurrentSnapshot;
-                ITextDocument textDocument;
-                if (!TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out textDocument)) return;
-
-                var diff = _commands.GetGitDiffFor(textDocument, snapshot);
-                var result = new DiffParseResultEventArgs(snapshot, stopwatch.Elapsed, diff.ToList());
-                OnParseComplete(result);
-            }
-            catch (InvalidOperationException)
-            {
-                MarkDirty(true);
-                throw;
-            }
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            base.Dispose(disposing);
-
-            if (disposing)
-            {
-                if (_textDocument != null)
-                {
-                    _textDocument.FileActionOccurred -= OnFileActionOccurred;
-                }
-                if (_watcher != null)
-                {
-                    _watcher.Dispose();
-                }
-            }
-        }
-    }
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GitDiffMargin.Git;
+using Microsoft.VisualStudio.Text;
+
+namespace GitDiffMargin.Core
+{
+    public class DiffUpdateBackgroundParser : BackgroundParser
+    {
+        private readonly FileSystemWatcher _watcher;
+        private readonly IGitCommands _commands;
+        private readonly ITextDocument _textDocument;
+        private readonly ITextBuffer _documentBuffer;
+
+        public DiffUpdateBackgroundParser(ITextBuffer textBuffer, ITextBuffer documentBuffer, TaskScheduler taskScheduler, ITextDocumentFactoryService textDocumentFactoryService, IGitCommands commands)
+            : base(textBuffer, taskScheduler, textDocumentFactoryService)
+        {
+            _documentBuffer = documentBuffer;
+            _commands = commands;
+            ReparseDelay = TimeSpan.FromMilliseconds(500);
+
+            if (TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out _textDocument))
+            {
+                if (_commands.IsGitRepository(_textDocument.FilePath))
+                {
+                    _textDocument.FileActionOccurred += OnFileActionOccurred;
+
+                    var solutionDirectory = _commands.GetGitRepository(_textDocument.FilePath);
+
+                    if (!string.IsNullOrWhiteSpace(solutionDirectory))
+                    {
+                        var gitDirectory = Path.Combine(solutionDirectory, ".git");
+                        _watcher = new FileSystemWatcher(gitDirectory);
+                        _watcher.Changed += HandleFileSystemChanged;
+                        _watcher.Created += HandleFileSystemChanged;
+                        _watcher.Deleted += HandleFileSystemChanged;
+                        _watcher.Renamed += HandleFileSystemChanged;
+                        _watcher.EnableRaisingEvents = true;
+                    }
+                }
+            }
+        }
+        
+        private void HandleFileSystemChanged(object sender, FileSystemEventArgs e)
+        {
+            Action action = () => ProcessFileSystemChange(e);
+            Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
+        }
+
+        private void ProcessFileSystemChange(FileSystemEventArgs e)
+        {
+            if (e.ChangeType == WatcherChangeTypes.Changed && Directory.Exists(e.FullPath))
+                return;
+
+            if (string.Equals(Path.GetExtension(e.Name), ".lock", StringComparison.OrdinalIgnoreCase))
+                return;
+
+            MarkDirty(true);
+        }
+
+        private void OnFileActionOccurred(object sender, TextDocumentFileActionEventArgs e)
+        {
+            if ((e.FileActionType & FileActionTypes.ContentSavedToDisk) != 0)
+            {
+                MarkDirty(true);
+            }
+        }
+
+        public override string Name
+        {
+            get
+            {
+                return "Git Diff Analyzer";
+            }
+        }
+
+        protected override void ReParseImpl()
+        {
+            try
+            {
+                var stopwatch = Stopwatch.StartNew();
+
+                var snapshot = TextBuffer.CurrentSnapshot;
+                ITextDocument textDocument;
+                if (!TextDocumentFactoryService.TryGetTextDocument(_documentBuffer, out textDocument)) return;
+
+                var diff = _commands.GetGitDiffFor(textDocument, snapshot);
+                var result = new DiffParseResultEventArgs(snapshot, stopwatch.Elapsed, diff.ToList());
+                OnParseComplete(result);
+            }
+            catch (InvalidOperationException)
+            {
+                MarkDirty(true);
+                throw;
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+
+            if (disposing)
+            {
+                if (_textDocument != null)
+                {
+                    _textDocument.FileActionOccurred -= OnFileActionOccurred;
+                }
+                if (_watcher != null)
+                {
+                    _watcher.Dispose();
+                }
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/GitDiffMargin/Core/IMarginCore.cs b/GitDiffMargin/Core/IMarginCore.cs
new file mode 100644
index 0000000..cf290df
--- /dev/null
+++ b/GitDiffMargin/Core/IMarginCore.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Windows;
+using System.Windows.Media;
+using GitDiffMargin.Git;
+using Microsoft.VisualStudio.Text;
+
+namespace GitDiffMargin.Core
+{
+    internal interface IMarginCore
+    {
+        event EventHandler BrushesChanged;
+
+        event EventHandler<IEnumerable<HunkRangeInfo>> HunksChanged;
+
+        GitCommands GitCommands { get; }
+        FontFamily FontFamily { get; }
+        FontStretch FontStretch { get; }
+        FontStyle FontStyle { get; }
+        FontWeight FontWeight { get; }
+        double FontSize { get; }
+        Brush Background { get; }
+        Brush Foreground { get; }
+        Brush AdditionBrush { get; }
+        Brush ModificationBrush { get; }
+        Brush RemovedBrush { get; }
+        double EditorChangeLeft { get; }
+        double EditorChangeWidth { get; }
+        double ScrollChangeWidth { get; }
+        void MoveToChange(int lineNumber);
+        bool RollBack(HunkRangeInfo hunkRangeInfo);
+        ITextDocument GetTextDocument();
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/Core/MarginCore.cs b/GitDiffMargin/Core/MarginCore.cs
new file mode 100644
index 0000000..c7a3957
--- /dev/null
+++ b/GitDiffMargin/Core/MarginCore.cs
@@ -0,0 +1,328 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using GitDiffMargin.Git;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace GitDiffMargin.Core
+{
+    internal class MarginCore : IMarginCore, IDisposable
+    {
+        private readonly IWpfTextView _textView;
+
+        private readonly IClassificationFormatMap _classificationFormatMap;
+        private readonly IEditorFormatMap _editorFormatMap;
+
+        private readonly DiffUpdateBackgroundParser _parser;
+
+        private Brush _additionBrush;
+        private Brush _modificationBrush;
+        private Brush _removedBrush;
+
+        private bool _isDisposed;
+
+        public MarginCore(IWpfTextView textView, ITextDocumentFactoryService textDocumentFactoryService, IClassificationFormatMapService classificationFormatMapService, SVsServiceProvider serviceProvider, IEditorFormatMapService editorFormatMapService)
+        {
+            _textView = textView;
+
+            _classificationFormatMap = classificationFormatMapService.GetClassificationFormatMap(textView);
+
+            _editorFormatMap = editorFormatMapService.GetEditorFormatMap(textView);
+            _editorFormatMap.FormatMappingChanged += HandleFormatMappingChanged;
+
+            GitCommands = new GitCommands(serviceProvider);
+
+            _parser = new DiffUpdateBackgroundParser(textView.TextBuffer, textView.TextDataModel.DocumentBuffer, TaskScheduler.Default, textDocumentFactoryService, GitCommands);
+            _parser.ParseComplete += HandleParseComplete;
+            _parser.RequestParse(false);
+
+            _textView.Closed += (sender, e) =>
+            {
+                _editorFormatMap.FormatMappingChanged -= HandleFormatMappingChanged;
+                _parser.ParseComplete -= HandleParseComplete;
+            };
+
+            UpdateBrushes();
+        }
+
+        public GitCommands GitCommands { get; private set; }
+
+        public FontFamily FontFamily
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.TypefaceEmpty)
+                    return new FontFamily("Consolas");
+
+                return _classificationFormatMap.DefaultTextProperties.Typeface.FontFamily;
+            }
+        }
+
+        public FontStretch FontStretch
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.TypefaceEmpty)
+                    return FontStretches.Normal;
+
+                return _classificationFormatMap.DefaultTextProperties.Typeface.Stretch;
+            }
+        }
+
+        public FontStyle FontStyle
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.TypefaceEmpty)
+                    return FontStyles.Normal;
+
+                return _classificationFormatMap.DefaultTextProperties.Typeface.Style;
+            }
+        }
+
+        public FontWeight FontWeight
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.TypefaceEmpty)
+                    return FontWeights.Normal;
+
+                return _classificationFormatMap.DefaultTextProperties.Typeface.Weight;
+            }
+        }
+
+        public double FontSize
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.FontRenderingEmSizeEmpty)
+                    return 12.0;
+
+                return _classificationFormatMap.DefaultTextProperties.FontRenderingEmSize;
+            }
+        }
+
+        public Brush Background
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.BackgroundBrushEmpty)
+                    return _textView.Background;
+
+                return _classificationFormatMap.DefaultTextProperties.BackgroundBrush;
+            }
+        }
+
+        public Brush Foreground
+        {
+            get
+            {
+                if (_classificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty)
+                    return (Brush)Application.Current.Resources[VsBrushes.ToolWindowTextKey];
+
+                return _classificationFormatMap.DefaultTextProperties.ForegroundBrush;
+            }
+        }
+
+        public Brush AdditionBrush
+        {
+
+            get
+            {
+                return _additionBrush ?? Brushes.Transparent;
+            }
+        }
+
+        public Brush ModificationBrush
+        {
+            get
+            {
+                return _modificationBrush ?? Brushes.Transparent;
+            }
+        }
+
+        public Brush RemovedBrush
+        {
+            get
+            {
+                return _removedBrush ?? Brushes.Transparent;
+            }
+        }
+
+        public double EditorChangeLeft
+        {
+            get { return 2.5; }
+        }
+
+        public double EditorChangeWidth
+        {
+            get { return 5.0; }
+        }
+
+        public double ScrollChangeWidth
+        {
+            get { return 3.0; }
+        }
+
+        public event EventHandler BrushesChanged;
+
+        public event EventHandler<IEnumerable<HunkRangeInfo>> HunksChanged;
+
+        public void MoveToChange(int lineNumber)
+        {
+            var diffLine = _textView.TextSnapshot.GetLineFromLineNumber(lineNumber);
+
+            _textView.VisualElement.Focus();
+            _textView.Caret.MoveTo(diffLine.Start);
+            _textView.Caret.EnsureVisible();
+        }
+
+        private void CheckBeginInvokeOnUi(Action action)
+        {
+            if (_textView.VisualElement.Dispatcher.CheckAccess())
+            {
+                action();
+            }
+            else
+            {
+                _textView.VisualElement.Dispatcher.BeginInvoke(action);
+            } 
+        }
+
+        private void HandleFormatMappingChanged(object sender, FormatItemsEventArgs e)
+        {
+            if (e.ChangedItems.Contains(DiffFormatNames.Addition)
+                || e.ChangedItems.Contains(DiffFormatNames.Modification)
+                || e.ChangedItems.Contains(DiffFormatNames.Removed))
+            {
+                UpdateBrushes();
+            }
+        }
+
+        private void UpdateBrushes()
+        {
+            _additionBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Addition));
+            _modificationBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Modification));
+            _removedBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Removed));
+            OnBrushesChanged(EventArgs.Empty);
+        }
+
+        private void OnBrushesChanged(EventArgs e)
+        {
+            var t = BrushesChanged;
+            if (t != null)
+                t(this, e);
+        }
+
+        private static Brush GetBrush(ResourceDictionary properties)
+        {
+            if (properties == null)
+                return Brushes.Transparent;
+
+            if (properties.Contains(EditorFormatDefinition.BackgroundColorId))
+            {
+                var color = (Color)properties[EditorFormatDefinition.BackgroundColorId];
+                var brush = new SolidColorBrush(color);
+                if (brush.CanFreeze)
+                {
+                    brush.Freeze();
+                }
+                return brush;
+            }
+            if (properties.Contains(EditorFormatDefinition.BackgroundBrushId))
+            {
+                var brush = (Brush)properties[EditorFormatDefinition.BackgroundBrushId];
+                if (brush.CanFreeze)
+                {
+                    brush.Freeze();
+                }
+                return brush;
+            }
+
+            return Brushes.Transparent;
+        }
+        public bool RollBack(HunkRangeInfo hunkRangeInfo)
+        {
+            var snapshot = _textView.TextSnapshot;
+
+            if (snapshot != snapshot.TextBuffer.CurrentSnapshot)
+                return false;
+
+            using (var edit = snapshot.TextBuffer.CreateEdit())
+            {
+                Span newSpan;
+                if (hunkRangeInfo.IsDeletion)
+                {
+                    var startLine = snapshot.GetLineFromLineNumber(hunkRangeInfo.NewHunkRange.StartingLineNumber + 1);
+                    newSpan = new Span(startLine.Start.Position, 0);
+                }
+                else
+                {
+                    var startLine = snapshot.GetLineFromLineNumber(hunkRangeInfo.NewHunkRange.StartingLineNumber);
+                    var endLine = snapshot.GetLineFromLineNumber(hunkRangeInfo.NewHunkRange.StartingLineNumber + hunkRangeInfo.NewHunkRange.NumberOfLines - 1);
+                    newSpan = Span.FromBounds(startLine.Start.Position, endLine.EndIncludingLineBreak.Position);
+                }
+
+                if (hunkRangeInfo.IsAddition)
+                {
+                    var startLine = snapshot.GetLineFromLineNumber(hunkRangeInfo.NewHunkRange.StartingLineNumber);
+                    var endLine = snapshot.GetLineFromLineNumber(hunkRangeInfo.NewHunkRange.StartingLineNumber + hunkRangeInfo.NewHunkRange.NumberOfLines - 1);
+                    edit.Delete(Span.FromBounds(startLine.Start.Position, endLine.EndIncludingLineBreak.Position));
+                }
+                else
+                {
+                    var lineBreak = snapshot.GetLineFromLineNumber(0).GetLineBreakText();
+                    if (String.IsNullOrEmpty(lineBreak))
+                        lineBreak = Environment.NewLine;
+
+                    var originalText = String.Join(lineBreak, hunkRangeInfo.OriginalText);
+                    if (hunkRangeInfo.NewHunkRange.StartingLineNumber + hunkRangeInfo.NewHunkRange.NumberOfLines != snapshot.LineCount)
+                        originalText += lineBreak;
+
+                    edit.Replace(newSpan, originalText);
+                }
+
+                edit.Apply();
+
+                return true;
+            }
+        }
+
+        public ITextDocument GetTextDocument()
+        {
+            ITextDocument document;
+            _textView.TextDataModel.DocumentBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document);
+            return document;
+        }
+
+        private void HandleParseComplete(object sender, ParseResultEventArgs e)
+        {
+            var diffResult = e as DiffParseResultEventArgs;
+            if (diffResult == null) return;
+
+            CheckBeginInvokeOnUi(() => OnHunksChanged(diffResult.Diff));
+        }
+
+        private void OnHunksChanged(IEnumerable<HunkRangeInfo> hunkRangeInfos)
+        {
+            var t = HunksChanged;
+            if (t != null)
+                t(this, hunkRangeInfos);
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed)
+                return;
+
+            _isDisposed = true;
+
+            _parser.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ParseResultEventArgs.cs b/GitDiffMargin/Core/ParseResultEventArgs.cs
similarity index 98%
rename from GitDiffMargin/ParseResultEventArgs.cs
rename to GitDiffMargin/Core/ParseResultEventArgs.cs
index 5294219..f252bf1 100644
--- a/GitDiffMargin/ParseResultEventArgs.cs
+++ b/GitDiffMargin/Core/ParseResultEventArgs.cs
@@ -25,7 +25,7 @@
 using System;
 using Microsoft.VisualStudio.Text;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Core
 {
     public class ParseResultEventArgs : EventArgs
     {
diff --git a/GitDiffMargin/WeakReference.cs b/GitDiffMargin/Core/WeakReference.cs
similarity index 89%
rename from GitDiffMargin/WeakReference.cs
rename to GitDiffMargin/Core/WeakReference.cs
index 7360bbe..3c233fd 100644
--- a/GitDiffMargin/WeakReference.cs
+++ b/GitDiffMargin/Core/WeakReference.cs
@@ -22,12 +22,11 @@
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-namespace GitDiffMargin
-{
-    using SerializationInfo = System.Runtime.Serialization.SerializationInfo;
-    using StreamingContext = System.Runtime.Serialization.StreamingContext;
-    using WeakReference = System.WeakReference;
+using System;
+using System.Runtime.Serialization;
 
+namespace GitDiffMargin.Core
+{
     public class WeakReference<T> : WeakReference
         where T : class
     {
diff --git a/GitDiffMargin/DiffMarginBase.cs b/GitDiffMargin/DiffMarginBase.cs
new file mode 100644
index 0000000..371201b
--- /dev/null
+++ b/GitDiffMargin/DiffMarginBase.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using GitDiffMargin.ViewModel;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Editor.OptionsExtensionMethods;
+
+namespace GitDiffMargin
+{
+    internal abstract class DiffMarginBase : Canvas, IWpfTextViewMargin
+    {
+        protected readonly ITextView TextView;
+        private bool _isDisposed;
+        protected DiffMarginViewModelBase ViewModel;
+        protected UserControl UserControl;
+
+        protected abstract string MarginName { get; }
+
+        protected DiffMarginBase(ITextView textView)
+        {
+            TextView = textView;
+
+            TextView.Options.OptionChanged += HandleOptionChanged;
+            TextView.LayoutChanged += OnLayoutChanged;
+        }
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            _isDisposed = true;
+        }
+
+        public ITextViewMargin GetTextViewMargin(string marginName)
+        {
+            return string.Equals(marginName, MarginName, StringComparison.OrdinalIgnoreCase) ? this : null;
+        }
+
+        public double MarginSize
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return UserControl.ActualWidth;
+            }
+        }
+
+        public bool Enabled
+        {
+            get
+            {
+                return TextView.Options.IsSelectionMarginEnabled();
+            }
+        }
+
+        public FrameworkElement VisualElement
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return UserControl;
+            }
+        }
+
+        private void HandleOptionChanged(object sender, EditorOptionChangedEventArgs e)
+        {
+            if (!_isDisposed && e.OptionId == GitDiffMarginTextViewOptions.DiffMarginName)
+            {
+                UpdateVisibility();
+            }
+        }
+
+        private void UpdateVisibility()
+        {
+            ThrowIfDisposed();
+            UserControl.Visibility = Enabled ? Visibility.Visible : Visibility.Collapsed;
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_isDisposed)
+                throw new ObjectDisposedException(GetType().FullName);
+        }
+
+        private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
+        {
+            ViewModel.RefreshDiffViewModelPositions();
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/DiffMarginFactoryBase.cs b/GitDiffMargin/DiffMarginFactoryBase.cs
new file mode 100644
index 0000000..2592192
--- /dev/null
+++ b/GitDiffMargin/DiffMarginFactoryBase.cs
@@ -0,0 +1,32 @@
+using System.ComponentModel.Composition;
+using GitDiffMargin.Core;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace GitDiffMargin
+{
+    internal abstract class DiffMarginFactoryBase : IWpfTextViewMarginProvider
+    {
+        [Import]
+        internal ITextDocumentFactoryService TextDocumentFactoryService { get; private set; }
+
+        [Import]
+        internal IClassificationFormatMapService ClassificationFormatMapService { get; private set; }
+
+        [Import]
+        internal IEditorFormatMapService EditorFormatMapService { get; private set; }
+
+        [Import]
+        internal SVsServiceProvider ServiceProvider { get; private set; }
+
+        public abstract IWpfTextViewMargin CreateMargin(IWpfTextViewHost wpfTextViewHost, IWpfTextViewMargin marginContainer);
+
+        protected IMarginCore GetMarginCore(IWpfTextViewHost textViewHost)
+        {
+            return textViewHost.TextView.Properties.GetOrCreateSingletonProperty(
+                        () => new MarginCore(textViewHost.TextView, TextDocumentFactoryService, ClassificationFormatMapService, ServiceProvider, EditorFormatMapService));
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/EditorDiffMargin.cs b/GitDiffMargin/EditorDiffMargin.cs
new file mode 100644
index 0000000..9256ec3
--- /dev/null
+++ b/GitDiffMargin/EditorDiffMargin.cs
@@ -0,0 +1,181 @@
+#region using
+
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+using GitDiffMargin.View;
+using GitDiffMargin.ViewModel;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Formatting;
+
+#endregion
+
+namespace GitDiffMargin
+{
+    internal sealed class EditorDiffMargin : DiffMarginBase
+    {
+        private const double MarginWidth = 10.0;
+
+        public const string MarginNameConst = "EditorDiffMargin";
+
+        protected override string MarginName
+        {
+            get { return MarginNameConst; }
+        }
+
+        internal EditorDiffMargin(IWpfTextView textView, IMarginCore marginCore)
+            : base(textView)
+        {
+            ViewModel = new EditorDiffMarginViewModel(marginCore, UpdateDiffDimensions);
+
+            UserControl = new EditorDiffMarginControl {DataContext = ViewModel, Width = MarginWidth};
+        }
+
+        private void UpdateDiffDimensions(DiffViewModel diffViewModel, HunkRangeInfo hunkRangeInfo)
+        {
+            if (TextView.IsClosed)
+                return;
+
+            var snapshot = TextView.TextBuffer.CurrentSnapshot;
+
+            var startLineNumber = hunkRangeInfo.NewHunkRange.StartingLineNumber;
+            var endLineNumber = startLineNumber + hunkRangeInfo.NewHunkRange.NumberOfLines - 1;
+            if (startLineNumber < 0
+                || startLineNumber >= snapshot.LineCount
+                || endLineNumber < 0
+                || endLineNumber >= snapshot.LineCount)
+            {
+                diffViewModel.IsVisible = false;
+                return;
+            }
+
+            var startLine = snapshot.GetLineFromLineNumber(startLineNumber);
+            var endLine = snapshot.GetLineFromLineNumber(endLineNumber);
+
+            if (startLine == null || endLine == null) return;
+
+            if (endLine.LineNumber < startLine.LineNumber)
+            {
+                var span = new SnapshotSpan(endLine.Start, startLine.End);
+                if (!TextView.TextViewLines.FormattedSpan.IntersectsWith(span))
+                {
+                    diffViewModel.IsVisible = false;
+                    return;
+                }
+            }
+            else
+            {
+                var span = new SnapshotSpan(startLine.Start, endLine.End);
+                if (!TextView.TextViewLines.FormattedSpan.IntersectsWith(span))
+                {
+                    diffViewModel.IsVisible = false;
+                    return;
+                }
+            }
+
+            var startLineView = TextView.GetTextViewLineContainingBufferPosition(startLine.Start);
+            var endLineView = TextView.GetTextViewLineContainingBufferPosition(endLine.Start);
+
+            if (startLineView == null || endLineView == null)
+            {
+                diffViewModel.IsVisible = false;
+                return;
+            }
+
+            if (TextView.TextViewLines.LastVisibleLine.EndIncludingLineBreak < startLineView.Start
+                || TextView.TextViewLines.FirstVisibleLine.Start > endLineView.EndIncludingLineBreak)
+            {
+                diffViewModel.IsVisible = false;
+                return;
+            }
+
+            double startTop;
+            switch (startLineView.VisibilityState)
+            {
+                case VisibilityState.FullyVisible:
+                    startTop = startLineView.Top - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.Hidden:
+                    startTop = startLineView.Top - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.PartiallyVisible:
+                    startTop = startLineView.Top - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.Unattached:
+                    // if the closest line was past the end we would have already returned
+                    startTop = 0;
+                    break;
+
+                default:
+                    // shouldn't be reachable, but definitely hide if this is the case
+                    diffViewModel.IsVisible = false;
+                    return;
+            }
+
+            if (startTop >= TextView.ViewportHeight + TextView.LineHeight)
+            {
+                // shouldn't be reachable, but definitely hide if this is the case
+                diffViewModel.IsVisible = false;
+                return;
+            }
+
+            double stopBottom;
+            switch (endLineView.VisibilityState)
+            {
+                case VisibilityState.FullyVisible:
+                    stopBottom = endLineView.Bottom - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.Hidden:
+                    stopBottom = endLineView.Bottom - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.PartiallyVisible:
+                    stopBottom = endLineView.Bottom - TextView.ViewportTop;
+                    break;
+
+                case VisibilityState.Unattached:
+                    // if the closest line was before the start we would have already returned
+                    stopBottom = TextView.ViewportHeight;
+                    break;
+
+                default:
+                    // shouldn't be reachable, but definitely hide if this is the case
+                    diffViewModel.IsVisible = false;
+                    return;
+            }
+
+            if (stopBottom <= -TextView.LineHeight)
+            {
+                // shouldn't be reachable, but definitely hide if this is the case
+                diffViewModel.IsVisible = false;
+                return;
+            }
+
+            if (stopBottom <= startTop)
+            {
+                if (hunkRangeInfo.IsDeletion)
+                {
+                    double center = (startTop + stopBottom) / 2.0;
+                    diffViewModel.Top = (center - (TextView.LineHeight / 2.0)) + TextView.LineHeight;
+                    diffViewModel.Height = TextView.LineHeight;
+                    diffViewModel.IsVisible = true;
+                }
+                else
+                {
+                    // could be reachable if translation changes an addition to empty
+                    diffViewModel.IsVisible = false;
+                }
+
+                return;
+            }
+
+            diffViewModel.Top = startTop;
+            diffViewModel.Height = stopBottom - startTop;
+            diffViewModel.IsVisible = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/EditorDiffMarginFactory.cs b/GitDiffMargin/EditorDiffMarginFactory.cs
new file mode 100644
index 0000000..c16229f
--- /dev/null
+++ b/GitDiffMargin/EditorDiffMarginFactory.cs
@@ -0,0 +1,25 @@
+#region using
+
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+#endregion
+
+namespace GitDiffMargin
+{
+    [Export(typeof (IWpfTextViewMarginProvider))]
+    [Name(EditorDiffMargin.MarginNameConst)]
+    [Order(Before = PredefinedMarginNames.LineNumber)]
+    [MarginContainer(PredefinedMarginNames.LeftSelection)]
+    [ContentType("text")]
+    [TextViewRole(PredefinedTextViewRoles.Editable)]
+    internal sealed class EditorDiffMarginFactory : DiffMarginFactoryBase
+    {
+        public override IWpfTextViewMargin CreateMargin(IWpfTextViewHost textViewHost, IWpfTextViewMargin containerMargin)
+        {
+            var marginCore = GetMarginCore(textViewHost);
+            return new EditorDiffMargin(textViewHost.TextView, marginCore);
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/Extensions.cs b/GitDiffMargin/Git/Extensions.cs
similarity index 92%
rename from GitDiffMargin/Extensions.cs
rename to GitDiffMargin/Git/Extensions.cs
index ab85efa..897ca60 100644
--- a/GitDiffMargin/Extensions.cs
+++ b/GitDiffMargin/Git/Extensions.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using EnvDTE;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Git
 {
     public static class Extensions
     {
diff --git a/GitDiffMargin/Git/GitCommands.cs b/GitDiffMargin/Git/GitCommands.cs
index ecfa60a..f5bdd86 100644
--- a/GitDiffMargin/Git/GitCommands.cs
+++ b/GitDiffMargin/Git/GitCommands.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
+using System.Runtime.InteropServices;
 using EnvDTE;
 using LibGit2Sharp;
 using Microsoft.VisualStudio.Text;
@@ -16,7 +16,7 @@ public class GitCommands : IGitCommands
 
         public GitCommands(IServiceProvider serviceProvider)
         {
-            _dte = (DTE) serviceProvider.GetService(typeof (_DTE));
+            _dte = (DTE)serviceProvider.GetService(typeof(_DTE));
         }
 
         private const int ContextLines = 0;
@@ -36,22 +36,20 @@ public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITex
                 var content = GetCompleteContent(textDocument, snapshot);
                 if (content == null) yield break;
 
-                content = AdaptCrlf(repo, content, textDocument);
-
                 using (var currentContent = new MemoryStream(content))
                 {
-                    var newBlob = repo.ObjectDatabase.CreateBlob(currentContent);
-
                     var directoryInfo = new DirectoryInfo(discoveredPath).Parent;
                     if (directoryInfo == null) yield break;
 
                     var relativeFilepath = filename.Replace(directoryInfo.FullName + "\\", string.Empty);
 
+                    var newBlob = repo.ObjectDatabase.CreateBlob(currentContent, relativeFilepath);
+
                     var from = TreeDefinition.From(repo.Head.Tip.Tree);
 
-                    if (!repo.ObjectDatabase.Contains(@from[relativeFilepath].TargetId)) yield break;
+                    if (!repo.ObjectDatabase.Contains(from[relativeFilepath].TargetId)) yield break;
 
-                    var blob = repo.Lookup<Blob>(@from[relativeFilepath].TargetId);
+                    var blob = repo.Lookup<Blob>(from[relativeFilepath].TargetId);
 
                     var treeChanges = repo.Diff.Compare(blob, newBlob, new CompareOptions { ContextLines = ContextLines, InterhunkLines = 0 });
 
@@ -66,21 +64,6 @@ public IEnumerable<HunkRangeInfo> GetGitDiffFor(ITextDocument textDocument, ITex
             }
         }
 
-        private byte[] AdaptCrlf(IRepository repo, byte[] content, ITextDocument textDocument)
-        {
-            var docu = _dte.Documents.AllDocuments().FirstOrDefault(doc => doc.FullName == textDocument.FilePath);
-
-            if (docu != null && docu.Language == "HTML") return content;
-
-            var autocrlf = repo.Config.Get<string>("core.autocrlf");
-
-            if (autocrlf == null || autocrlf.Value != "true") return content;
-
-            var contentText = Encoding.UTF8.GetString(content);
-            content = Encoding.UTF8.GetBytes(contentText.Replace("\r\n", "\n"));
-            return content;
-        }
-
         private static byte[] GetCompleteContent(ITextDocument textDocument, ITextSnapshot snapshot)
         {
             var currentText = snapshot.GetText();
@@ -116,26 +99,31 @@ public void StartExternalDiff(ITextDocument textDocument)
 
             using (var repo = new Repository(discoveredPath))
             {
-                var diffGuiTool = repo.Config.Get<string>("diff.guitool");
+                var diffGuiTool = repo.Config.Get<string>("diff.tool");
 
                 if (diffGuiTool == null) return;
 
-                var diffCmd = repo.Config.Get<string>("difftool." + diffGuiTool.Value + ".path");
-
                 var indexEntry = repo.Index[filename.Replace(repo.Info.WorkingDirectory, "")];
                 var blob = repo.Lookup<Blob>(indexEntry.Id);
 
                 var tempFileName = Path.GetTempFileName();
                 File.WriteAllText(tempFileName, blob.GetContentText());
-                    
+
+                var diffCmd = repo.Config.Get<string>("difftool." + diffGuiTool.Value + ".cmd");
+                var cmd = diffCmd.Value.Replace("$LOCAL", tempFileName).Replace("$REMOTE", filename);
+
+                string exe;
+                var args = CommandLineToArgs(cmd, out exe);
+
                 var process = new Process
                 {
                     StartInfo =
                     {
-                        FileName = diffCmd.Value,
-                        Arguments = String.Format("{0} {1}", tempFileName, filename)
+                        FileName = exe,
+                        Arguments = string.Join(" ", args)
                     }
                 };
+
                 process.Start();
             }
         }
@@ -159,5 +147,37 @@ public string GetGitRepository(string filePath)
             var directoryInfo = Directory.GetParent(fullPath).Parent;
             return directoryInfo != null ? directoryInfo.FullName : null;
         }
+
+        [DllImport("shell32.dll", SetLastError = true)]
+        static extern IntPtr CommandLineToArgvW(
+
+        [MarshalAs(UnmanagedType.LPWStr)] string lpCmdLine, out int pNumArgs);
+        private static string[] CommandLineToArgs(string commandLine, out string executableName)
+        {
+            int argCount;
+            var result = CommandLineToArgvW(commandLine, out argCount);
+            if (result == IntPtr.Zero)
+            {
+                throw new System.ComponentModel.Win32Exception();
+            }
+
+            try
+            {
+                var pStr = Marshal.ReadIntPtr(result, 0 * IntPtr.Size);
+                executableName = Marshal.PtrToStringUni(pStr);
+                var args = new string[argCount - 1];
+                for (var i = 0; i < args.Length; i++)
+                {
+                    pStr = Marshal.ReadIntPtr(result, (i + 1) * IntPtr.Size);
+                    var arg = Marshal.PtrToStringUni(pStr);
+                    args[i] = arg;
+                }
+                return args;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(result);
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/GitDiffMargin/GitDiffMargin-Preview.png b/GitDiffMargin/GitDiffMargin-Preview.png
deleted file mode 100644
index c5100f6..0000000
Binary files a/GitDiffMargin/GitDiffMargin-Preview.png and /dev/null differ
diff --git a/GitDiffMargin/GitDiffMargin.cs b/GitDiffMargin/GitDiffMargin.cs
deleted file mode 100644
index 571c812..0000000
--- a/GitDiffMargin/GitDiffMargin.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-#region using
-
-using System;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Media;
-using GitDiffMargin.Git;
-using GitDiffMargin.View;
-using GitDiffMargin.ViewModel;
-using Microsoft.VisualStudio.Text.Classification;
-using Microsoft.VisualStudio.Text.Editor;
-using Microsoft.VisualStudio.Text.Editor.OptionsExtensionMethods;
-
-#endregion
-
-namespace GitDiffMargin
-{
-    internal class GitDiffMargin : Canvas, IWpfTextViewMargin
-    {
-        public const string MarginName = "GitDiffMargin";
-
-        internal const double ChangeLeft = 2.5;
-        internal const double ChangeWidth = 5.0;
-        private const double MarginWidth = 10.0;
-
-        private readonly IWpfTextView _textView;
-        private readonly IClassificationFormatMap _classificationFormatMap;
-        private readonly IEditorFormatMap _editorFormatMap;
-        private DiffMarginViewModel _viewModel;
-        private readonly DiffMarginControl _gitDiffBarControl;
-        private bool _isDisposed;
-
-        private Brush _additionBrush;
-        private Brush _modificationBrush;
-        private Brush _removedBrush;
-
-        internal GitDiffMargin(IWpfTextView textView, MarginFactory factory)
-        {
-            _textView = textView;
-            _classificationFormatMap = factory.ClassificationFormatMapService.GetClassificationFormatMap(textView);
-            _editorFormatMap = factory.EditorFormatMapService.GetEditorFormatMap(textView);
-
-            _editorFormatMap.FormatMappingChanged += HandleFormatMappingChanged;
-            _textView.Closed += (sender, e) => _editorFormatMap.FormatMappingChanged -= HandleFormatMappingChanged;
-            UpdateBrushes();
-
-            _textView.Options.OptionChanged += HandleOptionChanged;
-
-            _gitDiffBarControl = new DiffMarginControl();
-            _viewModel = new DiffMarginViewModel(this, _textView, factory.TextDocumentFactoryService, new GitCommands(factory.ServiceProvider));
-            _gitDiffBarControl.DataContext = _viewModel;
-            _gitDiffBarControl.Width = MarginWidth;
-        }
-
-        public event EventHandler BrushesChanged;
-
-        public FrameworkElement VisualElement
-        {
-            get
-            {
-                ThrowIfDisposed();
-                return _gitDiffBarControl;
-            }
-        }
-
-        public IClassificationFormatMap ClassificationFormatMap
-        {
-            get
-            {
-                return _classificationFormatMap;
-            }
-        }
-
-        public IWpfTextView TextView
-        {
-            get { return _textView; }
-        }
-        
-        public double MarginSize
-        {
-            get
-            {
-                ThrowIfDisposed();
-                return _gitDiffBarControl.ActualWidth;
-            }
-        }
-
-        public bool Enabled
-        {
-            get
-            {
-                return _textView.Options.IsSelectionMarginEnabled();
-            }
-        }
-
-        public Brush AdditionBrush
-        {
-            get
-            {
-                return _additionBrush ?? Brushes.Transparent;
-            }
-        }
-
-        public Brush ModificationBrush
-        {
-            get
-            {
-                return _modificationBrush ?? Brushes.Transparent;
-            }
-        }
-
-        public Brush RemovedBrush
-        {
-            get
-            {
-                return _removedBrush ?? Brushes.Transparent;
-            }
-        }
-
-        /// <summary>
-        ///   Returns an instance of the margin if this is the margin that has been requested.
-        /// </summary>
-        /// <param name="marginName"> The name of the margin requested </param>
-        /// <returns> An instance of GitDiffMargin or null </returns>
-        public ITextViewMargin GetTextViewMargin(string marginName)
-        {
-            return string.Equals(marginName, MarginName, StringComparison.OrdinalIgnoreCase) ? this : null;
-        }
-
-        public void Dispose()
-        {
-            GC.SuppressFinalize(this);
-            _viewModel.Cleanup();
-            _isDisposed = true;
-        }
-
-        protected virtual void OnBrushesChanged(EventArgs e)
-        {
-            var t = BrushesChanged;
-            if (t != null)
-                t(this, e);
-        }
-
-        private void HandleFormatMappingChanged(object sender, FormatItemsEventArgs e)
-        {
-            if (e.ChangedItems.Contains(DiffFormatNames.Addition)
-                || e.ChangedItems.Contains(DiffFormatNames.Modification)
-                || e.ChangedItems.Contains(DiffFormatNames.Removed))
-            {
-                UpdateBrushes();
-            }
-        }
-
-        private void HandleOptionChanged(object sender, EditorOptionChangedEventArgs e)
-        {
-            if (!_isDisposed && e.OptionId == GitDiffMarginTextViewOptions.DiffMarginName)
-                UpdateVisibility();
-        }
-
-        private void UpdateBrushes()
-        {
-            _additionBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Addition));
-            _modificationBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Modification));
-            _removedBrush = GetBrush(_editorFormatMap.GetProperties(DiffFormatNames.Removed));
-            OnBrushesChanged(EventArgs.Empty);
-        }
-
-        private void UpdateVisibility()
-        {
-            ThrowIfDisposed();
-            _gitDiffBarControl.Visibility = Enabled ? Visibility.Visible : Visibility.Collapsed;
-        }
-
-        private static Brush GetBrush(ResourceDictionary properties)
-        {
-            if (properties == null)
-                return Brushes.Transparent;
-
-            if (properties.Contains(EditorFormatDefinition.BackgroundColorId))
-            {
-                var color = (Color)properties[EditorFormatDefinition.BackgroundColorId];
-                var brush = new SolidColorBrush(color);
-                if (brush.CanFreeze)
-                {
-                    brush.Freeze();
-                }
-                return brush;
-            }
-            if (properties.Contains(EditorFormatDefinition.BackgroundBrushId))
-            {
-                var brush = (Brush)properties[EditorFormatDefinition.BackgroundBrushId];
-                if (brush.CanFreeze)
-                {
-                    brush.Freeze();
-                }
-                return brush;
-            }
-
-            return Brushes.Transparent;
-        }
-
-        private void ThrowIfDisposed()
-        {
-            if (_isDisposed)
-                throw new ObjectDisposedException(GetType().FullName);
-        }
-    }
-}
\ No newline at end of file
diff --git a/GitDiffMargin/GitDiffMargin.csproj b/GitDiffMargin/GitDiffMargin.csproj
index 7c55ede..f0c4a20 100644
--- a/GitDiffMargin/GitDiffMargin.csproj
+++ b/GitDiffMargin/GitDiffMargin.csproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -19,13 +19,14 @@
     <RestorePackages>true</RestorePackages>
     <Utf8Output>true</Utf8Output>
     <ExpressionBlendVersion>4.0.30816.0</ExpressionBlendVersion>
-    <MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
+    <MinimumVisualStudioVersion>12.0</MinimumVisualStudioVersion>
     <FileUpgradeFlags>
     </FileUpgradeFlags>
     <UpgradeBackupLocation>
     </UpgradeBackupLocation>
     <OldToolsVersion>4.0</OldToolsVersion>
     <TargetFrameworkProfile />
+    <IsWebBootstrapper>false</IsWebBootstrapper>
     <PublishUrl>publish\</PublishUrl>
     <Install>true</Install>
     <InstallFrom>Disk</InstallFrom>
@@ -38,7 +39,6 @@
     <MapFileExtensions>true</MapFileExtensions>
     <ApplicationRevision>0</ApplicationRevision>
     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
   </PropertyGroup>
@@ -65,7 +65,7 @@
     <CopyVsixExtensionFiles>False</CopyVsixExtensionFiles>
     <CopyVsixExtensionLocation>C:\Temp\GitDiffMargin</CopyVsixExtensionLocation>
     <CreateVsixContainer>True</CreateVsixContainer>
-    <DeployExtension>False</DeployExtension>
+    <DeployExtension>True</DeployExtension>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationIcon>Resources\Git-Icon-1788C.ico</ApplicationIcon>
@@ -74,54 +74,49 @@
     <Reference Include="EnvDTE, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
       <EmbedInteropTypes>False</EmbedInteropTypes>
     </Reference>
-    <Reference Include="GalaSoft.MvvmLight.WPF4">
-      <HintPath>..\packages\MvvmLightPreview.4.1.21.1\lib\net40\GalaSoft.MvvmLight.WPF4.dll</HintPath>
-    </Reference>
-    <Reference Include="LibGit2Sharp, Version=0.16.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\LibGit2Sharp.0.16.0.0\lib\net35\LibGit2Sharp.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.VisualStudio.CoreUtility, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\Microsoft.VisualStudio.CoreUtility.dll</HintPath>
+    <Reference Include="GalaSoft.MvvmLight">
+      <HintPath>..\packages\MvvmLightLibs.4.4.32.1\lib\net45\GalaSoft.MvvmLight.dll</HintPath>
     </Reference>
-    <Reference Include="Microsoft.VisualStudio.Shell.11.0, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
-    <Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
-    <Reference Include="Microsoft.VisualStudio.Text.Data, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\Microsoft.VisualStudio.Text.Data.dll</HintPath>
+    <Reference Include="GalaSoft.MvvmLight.Extras">
+      <HintPath>..\packages\MvvmLightLibs.4.4.32.1\lib\net45\GalaSoft.MvvmLight.Extras.dll</HintPath>
     </Reference>
-    <Reference Include="Microsoft.VisualStudio.Text.Logic, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+    <Reference Include="LibGit2Sharp, Version=0.18.1.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\Microsoft.VisualStudio.Text.Logic.dll</HintPath>
+      <HintPath>..\packages\LibGit2Sharp.0.18.1.0\lib\net40\LibGit2Sharp.dll</HintPath>
     </Reference>
-    <Reference Include="Microsoft.VisualStudio.Text.UI, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\Microsoft.VisualStudio.Text.UI.dll</HintPath>
-    </Reference>
-    <Reference Include="Microsoft.VisualStudio.Text.UI.Wpf, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\Program Files (x86)\Microsoft Visual Studio 11.0\VSSDK\VisualStudioIntegration\Common\Assemblies\v4.0\Microsoft.VisualStudio.Text.UI.Wpf.dll</HintPath>
+    <Reference Include="Microsoft.Practices.ServiceLocation">
+      <HintPath>..\packages\CommonServiceLocator.1.3\lib\portable-net4+sl5+netcore45+wpa81+wp8\Microsoft.Practices.ServiceLocation.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.VisualStudio.CoreUtility, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Shell.12.0, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.Data, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.Logic, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.UI, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Text.UI.Wpf, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Windows.Interactivity, Version=4.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\MvvmLightLibs.4.4.32.1\lib\net45\System.Windows.Interactivity.dll</HintPath>
+    </Reference>
     <Reference Include="System.Xml" />
     <Reference Include="System.Xaml" />
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="BackgroundParser.cs" />
-    <Compile Include="DiffAdditionEditorFormatDefinition.cs" />
-    <Compile Include="DiffModificationEditorFormatDefinition.cs" />
-    <Compile Include="DiffParseResultEventArgs.cs" />
-    <Compile Include="DiffRemovedEditorFormatDefinition.cs" />
-    <Compile Include="DiffUpdateBackgroundParser.cs" />
-    <Compile Include="Extensions.cs" />
-    <Compile Include="GitDiffMargin.cs" />
-    <Compile Include="GitDiffMarginFactory.cs" />
+    <Compile Include="Core\BackgroundParser.cs" />
+    <Compile Include="Settings\DiffAdditionEditorFormatDefinition.cs" />
+    <Compile Include="DiffMarginBase.cs" />
+    <Compile Include="Settings\DiffModificationEditorFormatDefinition.cs" />
+    <Compile Include="Core\DiffParseResultEventArgs.cs" />
+    <Compile Include="Settings\DiffRemovedEditorFormatDefinition.cs" />
+    <Compile Include="Core\DiffUpdateBackgroundParser.cs" />
+    <Compile Include="Git\Extensions.cs" />
+    <Compile Include="EditorDiffMargin.cs" />
+    <Compile Include="EditorDiffMarginFactory.cs" />
     <Compile Include="GitDiffMarginTextViewOptions.cs" />
     <Compile Include="Git\DiffFormatNames.cs" />
     <Compile Include="Git\GitCommands.cs" />
@@ -129,26 +124,38 @@
     <Compile Include="Git\HunkRange.cs" />
     <Compile Include="Git\HunkRangeInfo.cs" />
     <Compile Include="Git\IGitCommands.cs" />
-    <Compile Include="ParseResultEventArgs.cs" />
+    <Compile Include="Core\IMarginCore.cs" />
+    <Compile Include="Core\MarginCore.cs" />
+    <Compile Include="DiffMarginFactoryBase.cs" />
+    <Compile Include="Core\ParseResultEventArgs.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="ViewModel\DiffMarginViewModel.cs" />
+    <Compile Include="ScrollDiffMargin.cs" />
+    <Compile Include="ScrollDiffMarginFactory.cs" />
+    <Compile Include="ViewModel\DiffMarginViewModelBase.cs" />
+    <Compile Include="ViewModel\EditorDiffMarginViewModel.cs" />
     <Compile Include="ViewModel\DiffViewModel.cs" />
-    <Compile Include="View\GitDiffBarControl.xaml.cs">
-      <DependentUpon>GitDiffBarControl.xaml</DependentUpon>
+    <Compile Include="ViewModel\EditorDiffViewModel.cs" />
+    <Compile Include="ViewModel\ScrollDiffMarginViewModel.cs" />
+    <Compile Include="ViewModel\ScrollDiffViewModel.cs" />
+    <Compile Include="View\EditorDiffMarginControl.xaml.cs">
+      <DependentUpon>EditorDiffMarginControl.xaml</DependentUpon>
     </Compile>
-    <Compile Include="WeakReference.cs" />
+    <Compile Include="View\ScrollDiffMarginControl.xaml.cs">
+      <DependentUpon>ScrollDiffMarginControl.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Core\WeakReference.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="..\packages\LibGit2Sharp.0.16.0.0\lib\net35\NativeBinaries\x86\git2-65e9dc6.dll">
-      <Link>git2-65e9dc6.dll</Link>
+    <Content Include="..\packages\LibGit2Sharp.0.18.1.0\lib\net40\NativeBinaries\x86\git2-90befde.dll">
+      <Link>git2-90befde.dll</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
-    <Content Include="GitDiffMargin-Preview.png">
+    <Content Include="Resources\GitDiffMargin-Preview.png">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
-    <Content Include="GitDiffMargin-Thumb.png">
+    <Content Include="Resources\GitDiffMargin-Thumb.png">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
@@ -179,11 +186,17 @@
     <Resource Include="Resources\PreviousArrow.png" />
   </ItemGroup>
   <ItemGroup>
-    <Page Include="View\GitDiffBarControl.xaml">
+    <Page Include="View\EditorDiffMarginControl.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Page Include="View\ScrollDiffMarginControl.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
     </Page>
   </ItemGroup>
   <ItemGroup>
@@ -215,7 +228,6 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\VSSDK\Microsoft.VsSDK.targets" Condition="false" />
-  <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <PropertyGroup>
     <PostBuildEvent>if not exist "$(TargetDir)NativeBinaries" md "$(TargetDir)NativeBinaries"
 if not exist "$(TargetDir)NativeBinaries\x86" md "$(TargetDir)NativeBinaries\x86"
@@ -224,9 +236,9 @@ if not exist "$(TargetDir)NativeBinaries\amd64" md "$(TargetDir)NativeBinaries\a
 xcopy /s /y "$(SolutionDir)packages\LibGit2Sharp.0.12.0.0\NativeBinaries\amd64\*.*" "$(TargetDir)NativeBinaries\amd64"
 if not exist "$(TargetDir)NativeBinaries" md "$(TargetDir)NativeBinaries"
 if not exist "$(TargetDir)NativeBinaries\x86" md "$(TargetDir)NativeBinaries\x86"
-xcopy /s /y /d "$(SolutionDir)packages\LibGit2Sharp.0.16.0.0\lib\net35\NativeBinaries\x86\*.*" "$(TargetDir)NativeBinaries\x86"
+xcopy /s /y /d "$(SolutionDir)packages\LibGit2Sharp.0.18.1.0\lib\net40\NativeBinaries\x86\*.*" "$(TargetDir)NativeBinaries\x86"
 if not exist "$(TargetDir)NativeBinaries\amd64" md "$(TargetDir)NativeBinaries\amd64"
-xcopy /s /y /d "$(SolutionDir)packages\LibGit2Sharp.0.16.0.0\lib\net35\NativeBinaries\amd64\*.*" "$(TargetDir)NativeBinaries\amd64"</PostBuildEvent>
+xcopy /s /y /d "$(SolutionDir)packages\LibGit2Sharp.0.18.1.0\lib\net40\NativeBinaries\amd64\*.*" "$(TargetDir)NativeBinaries\amd64"</PostBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/GitDiffMargin/GitDiffMarginFactory.cs b/GitDiffMargin/GitDiffMarginFactory.cs
deleted file mode 100644
index 9338d45..0000000
--- a/GitDiffMargin/GitDiffMarginFactory.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-#region using
-
-using System.ComponentModel.Composition;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Classification;
-using Microsoft.VisualStudio.Text.Editor;
-using Microsoft.VisualStudio.Utilities;
-
-#endregion
-
-namespace GitDiffMargin
-{
-    [Export(typeof (IWpfTextViewMarginProvider))]
-    [Name(GitDiffMargin.MarginName)]
-    [Order(Before = PredefinedMarginNames.LineNumber)]
-    [MarginContainer(PredefinedMarginNames.LeftSelection)]
-    [ContentType("text")]
-    [TextViewRole(PredefinedTextViewRoles.Editable)]
-    internal sealed class MarginFactory : IWpfTextViewMarginProvider
-    {
-        [Import]
-        internal ITextDocumentFactoryService TextDocumentFactoryService { get; private set; }
-
-        [Import]
-        internal IClassificationFormatMapService ClassificationFormatMapService { get; private set; }
-
-        [Import]
-        internal IEditorFormatMapService EditorFormatMapService { get; private set; }
-
-        [Import]
-        internal SVsServiceProvider ServiceProvider { get; private set; }
-        
-        public IWpfTextViewMargin CreateMargin(IWpfTextViewHost textViewHost, IWpfTextViewMargin containerMargin)
-        {
-            return new GitDiffMargin(textViewHost.TextView, this);
-        }
-    }
-}
\ No newline at end of file
diff --git a/GitDiffMargin/GitDiffMarginTextViewOptions.cs b/GitDiffMargin/GitDiffMarginTextViewOptions.cs
index a5c14b5..064497b 100644
--- a/GitDiffMargin/GitDiffMarginTextViewOptions.cs
+++ b/GitDiffMargin/GitDiffMarginTextViewOptions.cs
@@ -4,7 +4,7 @@ namespace GitDiffMargin
 {
     public class GitDiffMarginTextViewOptions
     {
-        public const string DiffMarginName = GitDiffMargin.MarginName + "/DiffMarginName";
+        public const string DiffMarginName = EditorDiffMargin.MarginNameConst + "/DiffMarginName";
 
         public static readonly EditorOptionKey<bool> DiffMarginId = new EditorOptionKey<bool>(DiffMarginName);
 
diff --git a/GitDiffMargin/Properties/AssemblyInfo.cs b/GitDiffMargin/Properties/AssemblyInfo.cs
index 38627ce..eab9874 100644
--- a/GitDiffMargin/Properties/AssemblyInfo.cs
+++ b/GitDiffMargin/Properties/AssemblyInfo.cs
@@ -4,11 +4,11 @@
 // General Information about an assembly is controlled through the following 
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
-[assembly: AssemblyTitle("GitDiffMargin")]
-[assembly: AssemblyDescription("A margin extension to the Visual Studio Editor which displays the git diff.")]
+[assembly: AssemblyTitle("Git Diff Margin")]
+[assembly: AssemblyDescription("Git Diff Margin displays live changes of the currently edited file on Visual Studio 2013 margin and scroll bar.")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Laurent Kempé")]
-[assembly: AssemblyProduct("GitDiffMargin")]
+[assembly: AssemblyProduct("Git Diff Margin")]
 [assembly: AssemblyCopyright("Laurent Kempé")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
@@ -28,5 +28,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.3.2.0")]
-[assembly: AssemblyFileVersion("1.3.2.0")]
+[assembly: AssemblyVersion("2.0.0.0")]
+[assembly: AssemblyFileVersion("2.0.0.0")]
diff --git a/GitDiffMargin/Resources/GitDiffMargin-Preview.png b/GitDiffMargin/Resources/GitDiffMargin-Preview.png
new file mode 100644
index 0000000..d248b22
Binary files /dev/null and b/GitDiffMargin/Resources/GitDiffMargin-Preview.png differ
diff --git a/GitDiffMargin/GitDiffMargin-Thumb.png b/GitDiffMargin/Resources/GitDiffMargin-Thumb.png
similarity index 100%
rename from GitDiffMargin/GitDiffMargin-Thumb.png
rename to GitDiffMargin/Resources/GitDiffMargin-Thumb.png
diff --git a/GitDiffMargin/ScrollDiffMargin.cs b/GitDiffMargin/ScrollDiffMargin.cs
new file mode 100644
index 0000000..3c12fa7
--- /dev/null
+++ b/GitDiffMargin/ScrollDiffMargin.cs
@@ -0,0 +1,64 @@
+using System;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+using GitDiffMargin.View;
+using GitDiffMargin.ViewModel;
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace GitDiffMargin
+{
+    internal sealed class ScrollDiffMargin : DiffMarginBase
+    {
+        private readonly IVerticalScrollBar _scrollBar;
+        private const double MarginWidth = 4.0;
+
+        public const string MarginNameConst = "ScrollDiffMargin";
+
+        protected override string MarginName
+        {
+            get { return MarginNameConst; }
+        }
+
+        internal ScrollDiffMargin(IWpfTextView textView, IMarginCore marginCore, IWpfTextViewMargin containerMargin)
+            : base(textView)
+        {
+            var scrollBarMargin = containerMargin.GetTextViewMargin(PredefinedMarginNames.VerticalScrollBar);
+            // ReSharper disable once SuspiciousTypeConversion.Global
+            _scrollBar = (IVerticalScrollBar)scrollBarMargin;
+
+            ViewModel = new ScrollDiffMarginViewModel(marginCore, UpdateDiffDimensions);
+
+            UserControl = new ScrollDiffMarginControl { DataContext = ViewModel, Width = MarginWidth, MaxWidth = MarginWidth, MinWidth = MarginWidth};
+        }
+
+        private void UpdateDiffDimensions(DiffViewModel diffViewModel, HunkRangeInfo hunkRangeInfo)
+        {
+            if (TextView.IsClosed)
+                return;
+
+            var startLineNumber = hunkRangeInfo.NewHunkRange.StartingLineNumber;
+            var endLineNumber = startLineNumber + hunkRangeInfo.NewHunkRange.NumberOfLines - 1;
+
+            var snapshot = TextView.TextBuffer.CurrentSnapshot;
+
+            if (startLineNumber < 0
+                || startLineNumber >= snapshot.LineCount
+                || endLineNumber < 0
+                || endLineNumber >= snapshot.LineCount)
+            {
+                return;
+            }
+
+            var startLine = snapshot.GetLineFromLineNumber(startLineNumber);
+            var endLine = snapshot.GetLineFromLineNumber(endLineNumber);
+
+            if (startLine == null || endLine == null) return;
+
+            var mapTop = _scrollBar.Map.GetCoordinateAtBufferPosition(startLine.Start) - 0.5;
+            var mapBottom = _scrollBar.Map.GetCoordinateAtBufferPosition(endLine.End) + 0.5;
+
+            diffViewModel.Top = Math.Round(_scrollBar.GetYCoordinateOfScrollMapPosition(mapTop)) - 2.0;
+            diffViewModel.Height = Math.Round(_scrollBar.GetYCoordinateOfScrollMapPosition(mapBottom)) - diffViewModel.Top + 2.0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ScrollDiffMarginFactory.cs b/GitDiffMargin/ScrollDiffMarginFactory.cs
new file mode 100644
index 0000000..2919958
--- /dev/null
+++ b/GitDiffMargin/ScrollDiffMarginFactory.cs
@@ -0,0 +1,24 @@
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace GitDiffMargin
+{
+    [Export(typeof(IWpfTextViewMarginProvider))]
+    [Name(ScrollDiffMargin.MarginNameConst)]
+    [ContentType("text")]
+    [TextViewRole(PredefinedTextViewRoles.Editable)]
+    [MarginContainer(PredefinedMarginNames.VerticalScrollBar)]
+    [Order(After = PredefinedMarginNames.OverviewChangeTracking)]
+    [Order(Before = PredefinedMarginNames.OverviewError)]
+    [Order(Before = PredefinedMarginNames.OverviewMark)]
+    [Order(Before = PredefinedMarginNames.OverviewSourceImage)]
+    internal sealed class ScrollDiffMarginFactory : DiffMarginFactoryBase
+    {
+        public override IWpfTextViewMargin CreateMargin(IWpfTextViewHost textViewHost, IWpfTextViewMargin containerMargin)
+        {
+            var marginCore = GetMarginCore(textViewHost);
+            return new ScrollDiffMargin(textViewHost.TextView, marginCore, containerMargin);
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/DiffAdditionEditorFormatDefinition.cs b/GitDiffMargin/Settings/DiffAdditionEditorFormatDefinition.cs
similarity index 94%
rename from GitDiffMargin/DiffAdditionEditorFormatDefinition.cs
rename to GitDiffMargin/Settings/DiffAdditionEditorFormatDefinition.cs
index 82da1f1..63d8426 100644
--- a/GitDiffMargin/DiffAdditionEditorFormatDefinition.cs
+++ b/GitDiffMargin/Settings/DiffAdditionEditorFormatDefinition.cs
@@ -4,7 +4,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Settings
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DiffFormatNames.Addition)]
diff --git a/GitDiffMargin/DiffModificationEditorFormatDefinition.cs b/GitDiffMargin/Settings/DiffModificationEditorFormatDefinition.cs
similarity index 94%
rename from GitDiffMargin/DiffModificationEditorFormatDefinition.cs
rename to GitDiffMargin/Settings/DiffModificationEditorFormatDefinition.cs
index dca16aa..b1201d9 100644
--- a/GitDiffMargin/DiffModificationEditorFormatDefinition.cs
+++ b/GitDiffMargin/Settings/DiffModificationEditorFormatDefinition.cs
@@ -4,7 +4,7 @@
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Settings
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DiffFormatNames.Modification)]
diff --git a/GitDiffMargin/DiffRemovedEditorFormatDefinition.cs b/GitDiffMargin/Settings/DiffRemovedEditorFormatDefinition.cs
similarity index 84%
rename from GitDiffMargin/DiffRemovedEditorFormatDefinition.cs
rename to GitDiffMargin/Settings/DiffRemovedEditorFormatDefinition.cs
index ef65461..a941cd0 100644
--- a/GitDiffMargin/DiffRemovedEditorFormatDefinition.cs
+++ b/GitDiffMargin/Settings/DiffRemovedEditorFormatDefinition.cs
@@ -1,10 +1,10 @@
-using GitDiffMargin.Git;
-using System.ComponentModel.Composition;
+using System.ComponentModel.Composition;
 using System.Windows.Media;
+using GitDiffMargin.Git;
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Utilities;
 
-namespace GitDiffMargin
+namespace GitDiffMargin.Settings
 {
     [Export(typeof(EditorFormatDefinition))]
     [Name(DiffFormatNames.Removed)]
diff --git a/GitDiffMargin/View/GitDiffBarControl.xaml b/GitDiffMargin/View/EditorDiffMarginControl.xaml
similarity index 95%
rename from GitDiffMargin/View/GitDiffBarControl.xaml
rename to GitDiffMargin/View/EditorDiffMarginControl.xaml
index ba0a40c..dea7e4c 100644
--- a/GitDiffMargin/View/GitDiffBarControl.xaml
+++ b/GitDiffMargin/View/EditorDiffMarginControl.xaml
@@ -1,202 +1,203 @@
-<UserControl x:Class="GitDiffMargin.View.DiffMarginControl"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-             xmlns:viewModel="clr-namespace:GitDiffMargin.ViewModel"
-             Cursor="Hand"
-             ClipToBounds="True"
-             d:DataContext="{d:DesignInstance viewModel:DiffMarginViewModel}"
-             d:DesignHeight="300"
-             d:DesignWidth="9"
-             mc:Ignorable="d">
-  <UserControl.Resources>
-    <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
-    <Style x:Key="ButtonFocusVisual">
-      <Setter Property="Control.Template">
-        <Setter.Value>
-          <ControlTemplate>
-            <Rectangle Margin="2"
-                       SnapsToDevicePixels="true"
-                       Stroke="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"
-                       StrokeDashArray="1 2"
-                       StrokeThickness="4" />
-          </ControlTemplate>
-        </Setter.Value>
-      </Setter>
-    </Style>
-    <LinearGradientBrush x:Key="ButtonNormalBackground" StartPoint="0,0" EndPoint="0,1">
-      <GradientStop Offset="0" Color="#F3F3F3" />
-      <GradientStop Offset="0.5" Color="#EBEBEB" />
-      <GradientStop Offset="0.5" Color="#DDDDDD" />
-      <GradientStop Offset="1" Color="#CDCDCD" />
-    </LinearGradientBrush>
-    <SolidColorBrush x:Key="ButtonNormalBorder" Color="#FF707070" />
-    <Style x:Key="PopupButtonStyle" TargetType="{x:Type Button}">
-      <Setter Property="FocusVisualStyle" Value="{StaticResource ButtonFocusVisual}" />
-      <Setter Property="Background" Value="{StaticResource ButtonNormalBackground}" />
-      <Setter Property="BorderBrush" Value="{StaticResource ButtonNormalBorder}" />
-      <Setter Property="BorderThickness" Value="1" />
-      <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
-      <Setter Property="HorizontalContentAlignment" Value="Center" />
-      <Setter Property="VerticalContentAlignment" Value="Center" />
-      <Setter Property="Padding" Value="1" />
-      <Setter Property="Width" Value="24" />
-      <Setter Property="Height" Value="24" />
-      <Setter Property="Template">
-        <Setter.Value>
-          <ControlTemplate TargetType="{x:Type Button}">
-            <Grid>
-                <Border x:Name="border" SnapsToDevicePixels="True">
-                    <ContentPresenter Margin="{TemplateBinding Padding}"
-                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
-                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
-                    RecognizesAccessKey="True"
-                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
-                </Border>
-            </Grid>
-            <ControlTemplate.Triggers>
-              <Trigger Property="IsKeyboardFocused" Value="true" />
-              <Trigger Property="ToggleButton.IsChecked" Value="true" />
-              <Trigger Property="IsEnabled" Value="false">
-                <Setter Property="Opacity" TargetName="border" Value="0.3" />
-              </Trigger>
-            <Trigger Property="IsMouseOver" Value="True">
-                <Setter Property="Background" TargetName="border" Value="#FFBEE6FD"/>
-                <Setter Property="BorderBrush" TargetName="border" Value="#FF3C7FB1"/>
-            </Trigger>
-                        </ControlTemplate.Triggers>
-          </ControlTemplate>
-        </Setter.Value>
-      </Setter>
-    </Style>
-        <ControlTemplate x:Key="ChangeTemplate" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
-            <Rectangle Width="{Binding Width, Mode=OneWay}" HorizontalAlignment="Left" Margin="{Binding Margin, Mode=OneWay}" Fill="{Binding DiffBrush}" />
-        </ControlTemplate>
-        <ControlTemplate x:Key="DeletionTemplate" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
-            <Polygon Points="0,0 1,1 0,2 0,0" Fill="{Binding DiffBrush}" Width="9" Height="{Binding Height}" Stretch="Fill" />
-        </ControlTemplate>
-    </UserControl.Resources>
-  <Grid>
-    <Grid.ColumnDefinitions>
-      <ColumnDefinition Width="9" MinWidth="9" />
-    </Grid.ColumnDefinitions>
-    <ItemsControl Grid.Column="0"
-                  HorizontalAlignment="Stretch"
-                  VerticalAlignment="Stretch"
-                  ItemsSource="{Binding DiffViewModels, Mode=OneWay}">
-      <ItemsControl.ItemsPanel>
-        <ItemsPanelTemplate>
-          <Canvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
-        </ItemsPanelTemplate>
-      </ItemsControl.ItemsPanel>
-      <ItemsControl.ItemContainerStyle>
-        <Style TargetType="ContentPresenter" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
-          <Setter Property="VerticalAlignment" Value="Top" />
-          <Setter Property="Canvas.Top" Value="{Binding Top, Mode=OneWay}" />
-          <Setter Property="Height" Value="{Binding Height, Mode=OneWay}" />
-        </Style>
-      </ItemsControl.ItemContainerStyle>
-      <ItemsControl.ItemTemplate>
-        <DataTemplate>
-            <Grid Visibility="{Binding IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}">
-              <Button Name="diffControl" Command="{Binding ShowPopUpCommand}">
-                  <Button.Style>
-                      <Style TargetType="{x:Type Button}">
-                          <Style.Triggers>
-                              <DataTrigger Binding="{Binding IsDeletion}" Value="true">
-                                  <Setter Property="Template" Value="{StaticResource DeletionTemplate}" />
-                              </DataTrigger>
-                              <DataTrigger Binding="{Binding IsDeletion}" Value="false">
-                                  <Setter Property="Template" Value="{StaticResource ChangeTemplate}" />
-                              </DataTrigger>
-                          </Style.Triggers>
-                      </Style>
-                  </Button.Style>
-              </Button>
-            <Popup AllowsTransparency="True"
-                   HorizontalOffset="8"
-                   IsOpen="{Binding ShowPopup, Mode=TwoWay}"
-                   Placement="MousePoint"
-                   PlacementTarget="{Binding ElementName=diffControl}"
-                   StaysOpen="False">
-              <Border Background="Transparent">
-                <StackPanel Orientation="Vertical">
-                  <Border HorizontalAlignment="Left"
-                          Background="White"
-                          BorderBrush="Black"
-                          BorderThickness="1,1,1,1">
-                    <StackPanel Margin="0"
-                                Background="White"
-                                Orientation="Horizontal">
-                        <Button
-                            Command="{Binding DataContext.PreviousChangeCommand, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl} }}"
-                            CommandParameter="{Binding}"
-                            Style="{DynamicResource PopupButtonStyle}"
-                            ToolTip="Previous Change">
-                            <Image Width="16"
-                                   Height="16"
-                                   Source="..\Resources\PreviousArrow.png" />
-                        </Button>
-                        <Button
-                            Command="{Binding DataContext.NextChangeCommand, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl} }}"
-                            CommandParameter="{Binding}"
-                            Style="{DynamicResource PopupButtonStyle}"
-                            ToolTip="Next Change">
-                            <Image Width="16"
-                                   Height="16"
-                                   Source="..\Resources\NextArrow.png" />
-                        </Button>
-                      <Button Command="{Binding RollbackCommand}"
-                              Style="{DynamicResource PopupButtonStyle}"
-                              ToolTip="Rollback">
-                        <Image Width="16"
-                               Height="16"
-                               Source="..\Resources\Rollback.png" />
-                      </Button>
-                      <Button Command="{Binding ShowDifferenceCommand}"
-                              Style="{DynamicResource PopupButtonStyle}"
-                              ToolTip="Show Difference">
-                        <Image Width="16"
-                               Height="16"
-                               Source="..\Resources\ShowDifference.png" />
-                      </Button>
-                      <Button Command="{Binding CopyOldTextCommand}"
-                              Style="{DynamicResource PopupButtonStyle}"
-                              ToolTip="Copy Old Text">
-                        <Image Width="16"
-                               Height="16"
-                               Source="..\Resources\CopyOldText.png" />
-                      </Button>
-                    </StackPanel>
-                  </Border>
-                 <Border Background="{Binding Background, Mode=OneWay}"
-                          BorderBrush="{Binding Foreground, Mode=OneWay}"
-                          BorderThickness="1,1,1,1"
-                          Margin="0,-1,0,0"
-                          Visibility="{Binding IsDiffTextVisible,
-                                               Converter={StaticResource BooleanToVisibilityConverter}}">
-                    <TextBox Margin="5"
-                             BorderThickness="0"
-                             IsReadOnly="True"
-                             FontFamily="{Binding FontFamily, Mode=OneWay}"
-                             FontStretch="{Binding FontStretch, Mode=OneWay}"
-                             FontStyle="{Binding FontStyle, Mode=OneWay}"
-                             FontWeight="{Binding FontWeight, Mode=OneWay}"
-                             FontSize="{Binding FontSize, Mode=OneWay}"
-                             Text="{Binding DiffText, Mode=OneWay}"
-                             Background="{Binding Background, Mode=OneWay}"
-                             Foreground="{Binding Foreground, Mode=OneWay}"
-                             VerticalScrollBarVisibility="Auto"
-                             HorizontalScrollBarVisibility="Auto"
-                             />
-                  </Border>
-                </StackPanel>
-              </Border>
-            </Popup>
-          </Grid>
-        </DataTemplate>
-      </ItemsControl.ItemTemplate>
-    </ItemsControl>
-  </Grid>
-</UserControl>
+<UserControl x:Class="GitDiffMargin.View.EditorDiffMarginControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:viewModel="clr-namespace:GitDiffMargin.ViewModel"
+             Cursor="Hand"
+             ClipToBounds="True"
+             d:DataContext="{d:DesignInstance viewModel:EditorDiffMarginViewModel}"
+             d:DesignHeight="300"
+             d:DesignWidth="9"
+             mc:Ignorable="d">
+  <UserControl.Resources>
+    <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
+    <Style x:Key="ButtonFocusVisual">
+      <Setter Property="Control.Template">
+        <Setter.Value>
+          <ControlTemplate>
+            <Rectangle Margin="2"
+                       SnapsToDevicePixels="true"
+                       Stroke="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"
+                       StrokeDashArray="1 2"
+                       StrokeThickness="4" />
+          </ControlTemplate>
+        </Setter.Value>
+      </Setter>
+    </Style>
+    <LinearGradientBrush x:Key="ButtonNormalBackground" StartPoint="0,0" EndPoint="0,1">
+      <GradientStop Offset="0" Color="#F3F3F3" />
+      <GradientStop Offset="0.5" Color="#EBEBEB" />
+      <GradientStop Offset="0.5" Color="#DDDDDD" />
+      <GradientStop Offset="1" Color="#CDCDCD" />
+    </LinearGradientBrush>
+    <SolidColorBrush x:Key="ButtonNormalBorder" Color="#FF707070" />
+    <Style x:Key="PopupButtonStyle" TargetType="{x:Type Button}">
+      <Setter Property="FocusVisualStyle" Value="{StaticResource ButtonFocusVisual}" />
+      <Setter Property="Background" Value="{StaticResource ButtonNormalBackground}" />
+      <Setter Property="BorderBrush" Value="{StaticResource ButtonNormalBorder}" />
+      <Setter Property="BorderThickness" Value="1" />
+      <Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" />
+      <Setter Property="HorizontalContentAlignment" Value="Center" />
+      <Setter Property="VerticalContentAlignment" Value="Center" />
+      <Setter Property="Padding" Value="1" />
+      <Setter Property="Width" Value="24" />
+      <Setter Property="Height" Value="24" />
+      <Setter Property="Template">
+        <Setter.Value>
+          <ControlTemplate TargetType="{x:Type Button}">
+            <Grid>
+                <Border x:Name="border" SnapsToDevicePixels="True">
+                    <ContentPresenter Margin="{TemplateBinding Padding}"
+                    HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
+                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                    RecognizesAccessKey="True"
+                    SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}" />
+                </Border>
+            </Grid>
+            <ControlTemplate.Triggers>
+              <Trigger Property="IsKeyboardFocused" Value="true" />
+              <Trigger Property="ToggleButton.IsChecked" Value="true" />
+              <Trigger Property="IsEnabled" Value="false">
+                <Setter Property="Opacity" TargetName="border" Value="0.3" />
+              </Trigger>
+            <Trigger Property="IsMouseOver" Value="True">
+                <Setter Property="Background" TargetName="border" Value="#FFBEE6FD"/>
+                <Setter Property="BorderBrush" TargetName="border" Value="#FF3C7FB1"/>
+            </Trigger>
+                        </ControlTemplate.Triggers>
+          </ControlTemplate>
+        </Setter.Value>
+      </Setter>
+    </Style>
+        <ControlTemplate x:Key="ChangeTemplate" d:DataContext="{d:DesignInstance viewModel:EditorDiffViewModel}">
+            <Rectangle Width="{Binding Width, Mode=OneWay}" HorizontalAlignment="Left" Margin="{Binding Margin, Mode=OneWay}" Fill="{Binding DiffBrush}" />
+        </ControlTemplate>
+        <ControlTemplate x:Key="DeletionTemplate" d:DataContext="{d:DesignInstance viewModel:EditorDiffViewModel}">
+            <Polygon Points="0,0 1,1 0,2 0,0" Fill="{Binding DiffBrush}" Width="9" Height="{Binding Height}" Stretch="Fill" />
+        </ControlTemplate>
+    </UserControl.Resources>
+  <Grid>
+    <Grid.ColumnDefinitions>
+      <ColumnDefinition Width="9" MinWidth="9" />
+    </Grid.ColumnDefinitions>
+    <ItemsControl Grid.Column="0"
+                  HorizontalAlignment="Stretch"
+                  VerticalAlignment="Stretch"
+                  ItemsSource="{Binding DiffViewModels, Mode=OneWay}">
+      <ItemsControl.ItemsPanel>
+        <ItemsPanelTemplate>
+          <Canvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
+        </ItemsPanelTemplate>
+      </ItemsControl.ItemsPanel>
+      <ItemsControl.ItemContainerStyle>
+        <Style TargetType="ContentPresenter" d:DataContext="{d:DesignInstance viewModel:EditorDiffViewModel}">
+          <Setter Property="VerticalAlignment" Value="Top" />
+          <Setter Property="Canvas.Top" Value="{Binding Top, Mode=OneWay}" />
+          <Setter Property="Height" Value="{Binding Height, Mode=OneWay}" />
+        </Style>
+      </ItemsControl.ItemContainerStyle>
+      <ItemsControl.ItemTemplate>
+        <DataTemplate>
+            <Grid Visibility="{Binding IsVisible, Converter={StaticResource BooleanToVisibilityConverter}}"
+                  d:DataContext="{d:DesignInstance viewModel:EditorDiffViewModel}">
+              <Button Name="diffControl" Command="{Binding ShowPopUpCommand}">
+                  <Button.Style>
+                      <Style TargetType="{x:Type Button}">
+                          <Style.Triggers>
+                              <DataTrigger Binding="{Binding IsDeletion}" Value="true">
+                                  <Setter Property="Template" Value="{StaticResource DeletionTemplate}" />
+                              </DataTrigger>
+                              <DataTrigger Binding="{Binding IsDeletion}" Value="false">
+                                  <Setter Property="Template" Value="{StaticResource ChangeTemplate}" />
+                              </DataTrigger>
+                          </Style.Triggers>
+                      </Style>
+                  </Button.Style>
+              </Button>
+            <Popup AllowsTransparency="True"
+                   HorizontalOffset="8"
+                   IsOpen="{Binding ShowPopup, Mode=TwoWay}"
+                   Placement="MousePoint"
+                   PlacementTarget="{Binding ElementName=diffControl}"
+                   StaysOpen="False">
+              <Border Background="Transparent">
+                <StackPanel Orientation="Vertical">
+                  <Border HorizontalAlignment="Left"
+                          Background="White"
+                          BorderBrush="Black"
+                          BorderThickness="1,1,1,1">
+                    <StackPanel Margin="0"
+                                Background="White"
+                                Orientation="Horizontal">
+                        <Button
+                            Command="{Binding DataContext.PreviousChangeCommand, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl} }}"
+                            CommandParameter="{Binding}"
+                            Style="{DynamicResource PopupButtonStyle}"
+                            ToolTip="Previous Change">
+                            <Image Width="16"
+                                   Height="16"
+                                   Source="..\Resources\PreviousArrow.png" />
+                        </Button>
+                        <Button
+                            Command="{Binding DataContext.NextChangeCommand, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl} }}"
+                            CommandParameter="{Binding}"
+                            Style="{DynamicResource PopupButtonStyle}"
+                            ToolTip="Next Change">
+                            <Image Width="16"
+                                   Height="16"
+                                   Source="..\Resources\NextArrow.png" />
+                        </Button>
+                      <Button Command="{Binding RollbackCommand}"
+                              Style="{DynamicResource PopupButtonStyle}"
+                              ToolTip="Rollback">
+                        <Image Width="16"
+                               Height="16"
+                               Source="..\Resources\Rollback.png" />
+                      </Button>
+                      <Button Command="{Binding ShowDifferenceCommand}"
+                              Style="{DynamicResource PopupButtonStyle}"
+                              ToolTip="Show Difference">
+                        <Image Width="16"
+                               Height="16"
+                               Source="..\Resources\ShowDifference.png" />
+                      </Button>
+                      <Button Command="{Binding CopyOldTextCommand}"
+                              Style="{DynamicResource PopupButtonStyle}"
+                              ToolTip="Copy Old Text">
+                        <Image Width="16"
+                               Height="16"
+                               Source="..\Resources\CopyOldText.png" />
+                      </Button>
+                    </StackPanel>
+                  </Border>
+                 <Border Background="{Binding Background, Mode=OneWay}"
+                          BorderBrush="{Binding Foreground, Mode=OneWay}"
+                          BorderThickness="1,1,1,1"
+                          Margin="0,-1,0,0"
+                          Visibility="{Binding IsDiffTextVisible,
+                                               Converter={StaticResource BooleanToVisibilityConverter}}">
+                    <TextBox Margin="5"
+                             BorderThickness="0"
+                             IsReadOnly="True"
+                             FontFamily="{Binding FontFamily, Mode=OneWay}"
+                             FontStretch="{Binding FontStretch, Mode=OneWay}"
+                             FontStyle="{Binding FontStyle, Mode=OneWay}"
+                             FontWeight="{Binding FontWeight, Mode=OneWay}"
+                             FontSize="{Binding FontSize, Mode=OneWay}"
+                             Text="{Binding DiffText, Mode=OneWay}"
+                             Background="{Binding Background, Mode=OneWay}"
+                             Foreground="{Binding Foreground, Mode=OneWay}"
+                             VerticalScrollBarVisibility="Auto"
+                             HorizontalScrollBarVisibility="Auto"
+                             />
+                  </Border>
+                </StackPanel>
+              </Border>
+            </Popup>
+          </Grid>
+        </DataTemplate>
+      </ItemsControl.ItemTemplate>
+    </ItemsControl>
+  </Grid>
+</UserControl>
diff --git a/GitDiffMargin/View/GitDiffBarControl.xaml.cs b/GitDiffMargin/View/EditorDiffMarginControl.xaml.cs
similarity index 62%
rename from GitDiffMargin/View/GitDiffBarControl.xaml.cs
rename to GitDiffMargin/View/EditorDiffMarginControl.xaml.cs
index e5d4f83..f2b1242 100644
--- a/GitDiffMargin/View/GitDiffBarControl.xaml.cs
+++ b/GitDiffMargin/View/EditorDiffMarginControl.xaml.cs
@@ -1,13 +1,13 @@
-namespace GitDiffMargin.View
-{
-    /// <summary>
-    ///   Interaction logic for GitDiffBarControl.xaml
-    /// </summary>
-    public partial class DiffMarginControl
-    {
-        public DiffMarginControl()
-        {
-            InitializeComponent();
-        }
-    }
+namespace GitDiffMargin.View
+{
+    /// <summary>
+    ///   Interaction logic for EditorDiffMarginControl.xaml
+    /// </summary>
+    public partial class EditorDiffMarginControl
+    {
+        public EditorDiffMarginControl()
+        {
+            InitializeComponent();
+        }
+    }
 }
\ No newline at end of file
diff --git a/GitDiffMargin/View/ScrollDiffMarginControl.xaml b/GitDiffMargin/View/ScrollDiffMarginControl.xaml
new file mode 100644
index 0000000..edbdddf
--- /dev/null
+++ b/GitDiffMargin/View/ScrollDiffMarginControl.xaml
@@ -0,0 +1,73 @@
+<UserControl x:Class="GitDiffMargin.View.ScrollDiffMarginControl"
+             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:viewModel="clr-namespace:GitDiffMargin.ViewModel"
+             mc:Ignorable="d"
+             d:DataContext="{d:DesignInstance viewModel:ScrollDiffMarginViewModel}"
+             d:DesignHeight="300"
+             d:DesignWidth="300"
+             Width="4"
+             MinWidth="4"
+             MaxWidth="4">
+    <UserControl.Resources>
+        <ControlTemplate x:Key="ChangeTemplate" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
+            <Rectangle Width="{Binding Width, Mode=OneWay}"
+                       Height="{Binding Height, Mode=OneWay}"
+                       Margin="0"
+                       HorizontalAlignment="Left"
+                       Fill="{Binding DiffBrush}" />
+        </ControlTemplate>
+        <ControlTemplate x:Key="DeletionTemplate" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
+            <Polygon Width="{Binding Width, Mode=OneWay}"
+                     Height="{Binding Height, Mode=OneWay}"
+                     Points="0,0 1,1 0,2 0,0"
+                     Fill="{Binding DiffBrush}"
+                     Stretch="Fill" />
+        </ControlTemplate>
+    </UserControl.Resources>
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="4" MinWidth="4" MaxWidth="4" />
+        </Grid.ColumnDefinitions>
+        <Canvas HorizontalAlignment="Stretch" />
+        <ItemsControl Grid.Column="0"
+                      HorizontalAlignment="Stretch"
+                      VerticalAlignment="Stretch"
+                      ItemsSource="{Binding DiffViewModels, Mode=OneWay}">
+            <ItemsControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <Canvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
+                </ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
+            <ItemsControl.ItemContainerStyle>
+                <Style TargetType="ContentPresenter" d:DataContext="{d:DesignInstance viewModel:DiffViewModel}">
+                    <Setter Property="VerticalAlignment" Value="Top" />
+                    <Setter Property="Canvas.Top" Value="{Binding Top, Mode=OneWay}" />
+                    <Setter Property="Height" Value="{Binding Height, Mode=OneWay}" />
+                </Style>
+            </ItemsControl.ItemContainerStyle>
+            <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                    <Grid>
+                        <Control Name="diffControl">
+                            <Control.Style>
+                                <Style TargetType="{x:Type Control}">
+                                    <Style.Triggers>
+                                        <DataTrigger Value="true" Binding="{Binding IsDeletion}">
+                                            <Setter Property="Template" Value="{StaticResource DeletionTemplate}" />
+                                        </DataTrigger>
+                                        <DataTrigger Value="false" Binding="{Binding IsDeletion}">
+                                            <Setter Property="Template" Value="{StaticResource ChangeTemplate}" />
+                                        </DataTrigger>
+                                    </Style.Triggers>
+                                </Style>
+                            </Control.Style>
+                        </Control>
+                    </Grid>
+                </DataTemplate>
+            </ItemsControl.ItemTemplate>
+        </ItemsControl>
+    </Grid>
+</UserControl>
\ No newline at end of file
diff --git a/GitDiffMargin/View/ScrollDiffMarginControl.xaml.cs b/GitDiffMargin/View/ScrollDiffMarginControl.xaml.cs
new file mode 100644
index 0000000..42eb859
--- /dev/null
+++ b/GitDiffMargin/View/ScrollDiffMarginControl.xaml.cs
@@ -0,0 +1,15 @@
+using System.Windows.Controls;
+
+namespace GitDiffMargin.View
+{
+    /// <summary>
+    /// Interaction logic for ScrollDiffMarginControl.xaml
+    /// </summary>
+    public partial class ScrollDiffMarginControl
+    {
+        public ScrollDiffMarginControl()
+        {
+            InitializeComponent();
+        }
+    }
+}
diff --git a/GitDiffMargin/ViewModel/DiffMarginViewModel.cs b/GitDiffMargin/ViewModel/DiffMarginViewModel.cs
deleted file mode 100644
index 87ddcc5..0000000
--- a/GitDiffMargin/ViewModel/DiffMarginViewModel.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-#region using
-
-using System;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Threading.Tasks;
-using GalaSoft.MvvmLight;
-using GalaSoft.MvvmLight.Command;
-using GitDiffMargin.Git;
-using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
-
-#endregion
-
-namespace GitDiffMargin.ViewModel
-{
-    public class DiffMarginViewModel : ViewModelBase
-    {
-        private readonly GitDiffMargin _margin;
-        private readonly IWpfTextView _textView;
-        private readonly IGitCommands _gitCommands;
-        private readonly DiffUpdateBackgroundParser _parser;
-        private RelayCommand<DiffViewModel> _previousChangeCommand;
-        private RelayCommand<DiffViewModel> _nextChangeCommand;
-
-        internal DiffMarginViewModel(GitDiffMargin margin, IWpfTextView textView, ITextDocumentFactoryService textDocumentFactoryService, IGitCommands gitCommands)
-        {
-            if (margin == null)
-                throw new ArgumentNullException("margin");
-            if (textView == null)
-                throw new ArgumentNullException("textView");
-            if (textDocumentFactoryService == null)
-                throw new ArgumentNullException("textDocumentFactoryService");
-            if (gitCommands == null)
-                throw new ArgumentNullException("gitCommands");
-
-            _margin = margin;
-            _textView = textView;
-            _gitCommands = gitCommands;
-            DiffViewModels = new ObservableCollection<DiffViewModel>();
-
-            _textView.LayoutChanged += OnLayoutChanged;
-
-            _parser = new DiffUpdateBackgroundParser(textView.TextBuffer, textView.TextDataModel.DocumentBuffer, TaskScheduler.Default, textDocumentFactoryService, gitCommands);
-            _parser.ParseComplete += HandleParseComplete;
-            _parser.RequestParse(false);
-        }
-       
-        private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
-        {
-            RefreshDiffViewModelPositions();
-        }
-
-        public ObservableCollection<DiffViewModel> DiffViewModels { get; private set; }
-
-        public RelayCommand<DiffViewModel> PreviousChangeCommand
-        {
-            get { return _previousChangeCommand ?? (_previousChangeCommand = new RelayCommand<DiffViewModel>(PreviousChange, PreviousChangeCanExecute)); }
-        }
-
-        public RelayCommand<DiffViewModel> NextChangeCommand
-        {
-            get { return _nextChangeCommand ?? (_nextChangeCommand = new RelayCommand<DiffViewModel>(NextChange, NextChangeCanExecute)); }
-        }
-
-        public override void Cleanup()
-        {
-            _parser.Dispose();
-            base.Cleanup();
-        }
-
-        private bool PreviousChangeCanExecute(DiffViewModel currentDiffViewModel)
-        {
-            return DiffViewModels.IndexOf(currentDiffViewModel) > 0;
-        }
-
-        private bool NextChangeCanExecute(DiffViewModel currentDiffViewModel)
-        {
-            return DiffViewModels.IndexOf(currentDiffViewModel) < (DiffViewModels.Count - 1);
-        }
-
-        private void PreviousChange(DiffViewModel currentDiffViewModel)
-        {
-            MoveToChange(currentDiffViewModel, -1);
-        }
-
-        private void NextChange(DiffViewModel currentDiffViewModel)
-        {
-            MoveToChange(currentDiffViewModel, +1);
-        }
-
-        private void MoveToChange(DiffViewModel currentDiffViewModel, int indexModifier)
-        {
-            var diffViewModelIndex = DiffViewModels.IndexOf(currentDiffViewModel) + indexModifier;
-            var diffViewModel  = DiffViewModels[diffViewModelIndex];
-            var diffLine = _textView.TextSnapshot.GetLineFromLineNumber(diffViewModel.LineNumber);
-            currentDiffViewModel.ShowPopup = false;
-
-            _textView.VisualElement.Focus();
-            _textView.Caret.MoveTo(diffLine.Start);
-            _textView.Caret.EnsureVisible();
-        }
-
-        private void RefreshDiffViewModelPositions()
-        {
-            foreach (var diffViewModel in DiffViewModels)
-            {
-                diffViewModel.RefreshPosition();
-            }
-        }
-
-        private void HandleParseComplete(object sender, ParseResultEventArgs e)
-        {
-            _margin.VisualElement.Dispatcher.BeginInvoke((Action) (() =>
-                                                                       {
-                                                                           //todo do not clear if it the same collection returned
-
-                                                                           if (DiffViewModels.Any(dvm => dvm.ShowPopup)) return;
-
-                                                                           DiffViewModels.Clear();
-
-                                                                           var diffResult = e as DiffParseResultEventArgs;
-                                                                           if (diffResult == null) return;
-                                                                           
-                                                                           foreach (var diffViewModel in diffResult.Diff.Select(hunkRangeInfo => new DiffViewModel(_margin, hunkRangeInfo, _textView, _gitCommands)))
-                                                                           {
-                                                                               DiffViewModels.Add(diffViewModel);
-                                                                           }
-                                                                       }));
-        }
-    }
-}
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/DiffMarginViewModelBase.cs b/GitDiffMargin/ViewModel/DiffMarginViewModelBase.cs
new file mode 100644
index 0000000..83c7ffb
--- /dev/null
+++ b/GitDiffMargin/ViewModel/DiffMarginViewModelBase.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using GalaSoft.MvvmLight;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+
+namespace GitDiffMargin.ViewModel
+{
+    internal abstract class DiffMarginViewModelBase : ViewModelBase
+    {
+        protected readonly IMarginCore MarginCore;
+
+        protected DiffMarginViewModelBase(IMarginCore marginCore)
+        {
+            if (marginCore == null)
+                throw new ArgumentNullException("marginCore");
+
+            MarginCore = marginCore;
+
+            DiffViewModels = new ObservableCollection<DiffViewModel>();
+
+            MarginCore.HunksChanged += HandleHunksChanged;
+        }
+
+        public ObservableCollection<DiffViewModel> DiffViewModels { get; private set; }
+
+        public void RefreshDiffViewModelPositions()
+        {
+            foreach (var diffViewModel in DiffViewModels)
+            {
+                diffViewModel.RefreshPosition();
+            }
+        }
+
+        protected virtual void HandleHunksChanged(object sender, IEnumerable<HunkRangeInfo> hunkRangeInfos)
+        {
+            DiffViewModels.Clear();
+
+            foreach (var diffViewModel in hunkRangeInfos.Select(CreateDiffViewModel))
+            {
+                DiffViewModels.Add(diffViewModel);
+            }
+        }
+
+        protected abstract DiffViewModel CreateDiffViewModel(HunkRangeInfo hunkRangeInfo);
+
+        public override void Cleanup()
+        {
+            MarginCore.HunksChanged -= HandleHunksChanged;
+
+            base.Cleanup();
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/DiffViewModel.cs b/GitDiffMargin/ViewModel/DiffViewModel.cs
index 9bb4d23..8d4bd7c 100644
--- a/GitDiffMargin/ViewModel/DiffViewModel.cs
+++ b/GitDiffMargin/ViewModel/DiffViewModel.cs
@@ -1,514 +1,102 @@
-#region using
-
-using System;
-using System.Windows;
-using System.Windows.Input;
-using System.Windows.Media;
-using GalaSoft.MvvmLight;
-using GalaSoft.MvvmLight.Command;
-using GitDiffMargin.Git;
-using Microsoft.VisualStudio.Shell;
-using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
-using System.Linq;
-using Microsoft.VisualStudio.Text.Formatting;
-
-#endregion
-
-namespace GitDiffMargin.ViewModel
-{
-    public class DiffViewModel : ViewModelBase
-    {
-        private readonly GitDiffMargin _margin;
-        private readonly HunkRangeInfo _hunkRangeInfo;
-        private readonly IWpfTextView _textView;
-        private readonly IGitCommands _gitCommands;
-        private bool _isDiffTextVisible;
-        private bool _showPopup;
-        private bool _reverted;
-        private ICommand _copyOldTextCommand;
-        private ICommand _rollbackCommand;
-        private ICommand _showPopUpCommand;
-
-        internal DiffViewModel(GitDiffMargin margin, HunkRangeInfo hunkRangeInfo, IWpfTextView textView, IGitCommands gitCommands)
-        {
-            _margin = margin;
-            _hunkRangeInfo = hunkRangeInfo;
-            _textView = textView;
-            _gitCommands = gitCommands;
-            _margin.BrushesChanged += HandleBrushesChanged;
-
-            ShowPopup = false;
-
-            SetDisplayProperties();
-
-            DiffText = GetDiffText();
-
-            IsDiffTextVisible = GetIsDiffTextVisible();
-        }
-
-        public int LineNumber { get { return _hunkRangeInfo.NewHunkRange.StartingLineNumber; } }
-
-        private void HandleBrushesChanged(object sender, EventArgs e)
-        {
-            RaisePropertyChanged(() => DiffBrush);
-        }
-
-        private void SetDisplayProperties()
-        {
-            UpdateDimensions();
-        }
-
-        private bool GetIsDiffTextVisible()
-        {
-            return _hunkRangeInfo.IsDeletion || _hunkRangeInfo.IsModification;
-        }
-
-        private string GetDiffText()
-        {
-            if (_hunkRangeInfo.OriginalText != null && _hunkRangeInfo.OriginalText.Any())
-            {
-                return _hunkRangeInfo.IsModification || _hunkRangeInfo.IsDeletion ? String.Join(Environment.NewLine, _hunkRangeInfo.OriginalText) : string.Empty;
-            }
-
-            return string.Empty;
-        }
-
-        private void UpdateDimensions()
-        {
-            if (_reverted || _textView.IsClosed)
-                return;
-
-            var snapshot = _textView.TextBuffer.CurrentSnapshot;
-
-            var startLineNumber = _hunkRangeInfo.NewHunkRange.StartingLineNumber;
-            var endLineNumber = startLineNumber + _hunkRangeInfo.NewHunkRange.NumberOfLines - 1;
-            if (startLineNumber < 0
-                || startLineNumber >= snapshot.LineCount
-                || endLineNumber < 0
-                || endLineNumber >= snapshot.LineCount)
-            {
-                IsVisible = false;
-                return;
-            }
-
-            var startLine = snapshot.GetLineFromLineNumber(startLineNumber);
-            var endLine = snapshot.GetLineFromLineNumber(endLineNumber);
-
-            if (startLine == null || endLine == null) return;
-
-
-            if (endLine.LineNumber < startLine.LineNumber)
-            {
-                var span = new SnapshotSpan(endLine.Start, startLine.End);
-                if (!_textView.TextViewLines.FormattedSpan.IntersectsWith(span))
-                {
-                    IsVisible = false;
-                    return;
-                }
-            }
-            else
-            {
-                var span = new SnapshotSpan(startLine.Start, endLine.End);
-                if (!_textView.TextViewLines.FormattedSpan.IntersectsWith(span))
-                {
-                    IsVisible = false;
-                    return;
-                }
-            }
-
-            var startLineView = _textView.GetTextViewLineContainingBufferPosition(startLine.Start);
-            var endLineView = _textView.GetTextViewLineContainingBufferPosition(endLine.Start);
-
-            if (startLineView == null || endLineView == null)
-            {
-                IsVisible = false;
-                return;
-            }
-
-            if (_textView.TextViewLines.LastVisibleLine.EndIncludingLineBreak < startLineView.Start
-                || _textView.TextViewLines.FirstVisibleLine.Start > endLineView.EndIncludingLineBreak)
-            {
-                IsVisible = false;
-                return;
-            }
-
-            double startTop;
-            switch (startLineView.VisibilityState)
-            {
-                case VisibilityState.FullyVisible:
-                    startTop = startLineView.Top - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.Hidden:
-                    startTop = startLineView.Top - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.PartiallyVisible:
-                    startTop = startLineView.Top - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.Unattached:
-                    // if the closest line was past the end we would have already returned
-                    startTop = 0;
-                    break;
-
-                default:
-                    // shouldn't be reachable, but definitely hide if this is the case
-                    IsVisible = false;
-                    return;
-            }
-
-            if (startTop >= _textView.ViewportHeight + _textView.LineHeight)
-            {
-                // shouldn't be reachable, but definitely hide if this is the case
-                IsVisible = false;
-                return;
-            }
-
-            double stopBottom;
-            switch (endLineView.VisibilityState)
-            {
-                case VisibilityState.FullyVisible:
-                    stopBottom = endLineView.Bottom - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.Hidden:
-                    stopBottom = endLineView.Bottom - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.PartiallyVisible:
-                    stopBottom = endLineView.Bottom - _textView.ViewportTop;
-                    break;
-
-                case VisibilityState.Unattached:
-                    // if the closest line was before the start we would have already returned
-                    stopBottom = _textView.ViewportHeight;
-                    break;
-
-                default:
-                    // shouldn't be reachable, but definitely hide if this is the case
-                    IsVisible = false;
-                    return;
-            }
-
-            if (stopBottom <= -_textView.LineHeight)
-            {
-                // shouldn't be reachable, but definitely hide if this is the case
-                IsVisible = false;
-                return;
-            }
-
-            if (stopBottom <= startTop)
-            {
-                if (_hunkRangeInfo.IsDeletion)
-                {
-                    double center = (startTop + stopBottom) / 2.0;
-                    Top = (center - (_textView.LineHeight / 2.0)) + _textView.LineHeight;
-                    Height = _textView.LineHeight;
-                    IsVisible = true;
-                }
-                else
-                {
-                    // could be reachable if translation changes an addition to empty
-                    IsVisible = false;
-                }
-
-                return;
-            }
-
-            Top = startTop;
-            Height = stopBottom - startTop;
-            IsVisible = true;
-        }
-
-        public void RefreshPosition()
-        {
-            SetDisplayProperties();
-        }
-
-        public Thickness Margin
-        {
-            get
-            {
-                return new Thickness(GitDiffMargin.ChangeLeft, 0, 0, 0);
-            }
-        }
-
-        public double Width
-        {
-            get
-            {
-                return GitDiffMargin.ChangeWidth;
-            }
-        }
-
-        public double Height
-        {
-            get { return _height; }
-            set
-            {
-                _height = value;
-                RaisePropertyChanged(() => Height);
-            }
-        }
-
-        public double Top
-        {
-            get { return _top; }
-            private set
-            {
-                _top = value;
-                RaisePropertyChanged(() => Top);
-            }
-        }
-
-        public Brush DiffBrush
-        {
-            get
-            {
-                if (_hunkRangeInfo.IsAddition)
-                {
-                    return _margin.AdditionBrush;
-                }
-                return _hunkRangeInfo.IsModification ? _margin.ModificationBrush : _margin.RemovedBrush;
-            }
-        }
-
-        public FontFamily FontFamily
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.TypefaceEmpty)
-                    return new FontFamily("Consolas");
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.Typeface.FontFamily;
-            }
-        }
-
-        public FontStretch FontStretch
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.TypefaceEmpty)
-                    return FontStretches.Normal;
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.Typeface.Stretch;
-            }
-        }
-
-        public FontStyle FontStyle
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.TypefaceEmpty)
-                    return FontStyles.Normal;
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.Typeface.Style;
-            }
-        }
-
-        public FontWeight FontWeight
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.TypefaceEmpty)
-                    return FontWeights.Normal;
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.Typeface.Weight;
-            }
-        }
-
-        public double FontSize
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.FontRenderingEmSizeEmpty)
-                    return 12.0;
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.FontRenderingEmSize;
-            }
-        }
-
-        public double MaxWidth
-        {
-            get
-            {
-                return _margin.TextView.ViewportWidth;
-            }
-        }
-
-        public double MaxHeight
-        {
-            get
-            {
-                return Math.Max(_margin.TextView.ViewportHeight * 2.0 / 3.0, 400);
-            }
-        }
-
-        public Brush Background
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.BackgroundBrushEmpty)
-                    return _margin.TextView.Background;
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.BackgroundBrush;
-            }
-        }
-
-        public Brush Foreground
-        {
-            get
-            {
-                if (_margin.ClassificationFormatMap.DefaultTextProperties.ForegroundBrushEmpty)
-                    return (Brush)Application.Current.Resources[VsBrushes.ToolWindowTextKey];
-
-                return _margin.ClassificationFormatMap.DefaultTextProperties.ForegroundBrush;
-            }
-        }
-
-        public bool IsDeletion { get { return _hunkRangeInfo.IsDeletion;} }
-
-        public ICommand ShowPopUpCommand
-        {
-            get { return _showPopUpCommand ?? (_showPopUpCommand = new RelayCommand(ShowPopUp)); }
-        }
-
-        public bool ShowPopup
-        {
-            get { return _showPopup; }
-            set
-            {
-                if (value == _showPopup) return;
-                _showPopup = value;
-                RaisePropertyChanged(() => ShowPopup);
-            }
-        }
-
-        public string DiffText { get; private set; }
-
-        public bool IsVisible
-        {
-            get { return _isVisible; }
-            set { _isVisible = value;
-            RaisePropertyChanged(() => IsVisible);}
-        }
-
-        public bool IsDiffTextVisible
-        {
-            get { return _isDiffTextVisible; }
-            set
-            {
-                if (value == _isDiffTextVisible) return;
-                _isDiffTextVisible = value;
-                RaisePropertyChanged(() => IsDiffTextVisible);
-            }
-        }
-
-        private ICommand _showDifferenceCommand;
-
-        private bool _isVisible;
-        private double _height;
-        private double _top;
-
-        public ICommand ShowDifferenceCommand
-        {
-            get { return _showDifferenceCommand ?? (_showDifferenceCommand = new RelayCommand(ShowDifference, ShowDifferenceCanExecute)); }
-        }
-
-        private bool ShowDifferenceCanExecute()
-        {
-            return _hunkRangeInfo.IsModification || _hunkRangeInfo.IsDeletion || _hunkRangeInfo.IsAddition;
-        }
-
-        private void ShowDifference()
-        {
-            ITextDocument document;
-            _textView.TextDataModel.DocumentBuffer.Properties.TryGetProperty(typeof(ITextDocument), out document);
-
-            _gitCommands.StartExternalDiff(document);
-        }
-
-        public ICommand CopyOldTextCommand
-        {
-            get { return _copyOldTextCommand ?? (_copyOldTextCommand = new RelayCommand(CopyOldText, CopyOldTextCanExecute)); }
-        }
-
-        public ICommand RollbackCommand
-        {
-            get { return _rollbackCommand ?? (_rollbackCommand = new RelayCommand(Rollback, RollbackCanExecute)); }
-        }
-
-        private bool CopyOldTextCanExecute()
-        {
-            return _hunkRangeInfo.IsModification || _hunkRangeInfo.IsDeletion;
-        }
-
-        private void CopyOldText()
-        {
-            Clipboard.SetText(DiffText);
-            ShowPopup = false;
-        }
-
-        private bool RollbackCanExecute()
-        {
-            return _hunkRangeInfo.IsModification || _hunkRangeInfo.IsDeletion || _hunkRangeInfo.IsAddition;
-        }
-
-        private void Rollback()
-        {
-            var snapshot = _textView.TextSnapshot;
-            
-            if (snapshot != snapshot.TextBuffer.CurrentSnapshot)
-                return;
-
-            using (var edit = snapshot.TextBuffer.CreateEdit())
-            {
-                Span newSpan;
-                if (_hunkRangeInfo.IsDeletion)
-                {
-                    var startLine = snapshot.GetLineFromLineNumber(_hunkRangeInfo.NewHunkRange.StartingLineNumber + 1);
-                    newSpan = new Span(startLine.Start.Position, 0);
-                }
-                else
-                {
-                    var startLine = snapshot.GetLineFromLineNumber(_hunkRangeInfo.NewHunkRange.StartingLineNumber);
-                    var endLine = snapshot.GetLineFromLineNumber(_hunkRangeInfo.NewHunkRange.StartingLineNumber + _hunkRangeInfo.NewHunkRange.NumberOfLines - 1);
-                    newSpan = Span.FromBounds(startLine.Start.Position, endLine.EndIncludingLineBreak.Position);
-                }
-
-                if (_hunkRangeInfo.IsAddition)
-                {
-                    var startLine = snapshot.GetLineFromLineNumber(_hunkRangeInfo.NewHunkRange.StartingLineNumber);
-                    var endLine = snapshot.GetLineFromLineNumber(_hunkRangeInfo.NewHunkRange.StartingLineNumber + _hunkRangeInfo.NewHunkRange.NumberOfLines - 1);
-                    edit.Delete(Span.FromBounds(startLine.Start.Position, endLine.EndIncludingLineBreak.Position));
-                }
-                else
-                {
-                    var lineBreak = snapshot.GetLineFromLineNumber(0).GetLineBreakText();
-                    if (string.IsNullOrEmpty(lineBreak))
-                        lineBreak = Environment.NewLine;
-
-                    var originalText = string.Join(lineBreak, _hunkRangeInfo.OriginalText);
-                    if (_hunkRangeInfo.NewHunkRange.StartingLineNumber + _hunkRangeInfo.NewHunkRange.NumberOfLines != snapshot.LineCount)
-                        originalText += lineBreak;
-
-                    edit.Replace(newSpan, originalText);
-                }
-
-                edit.Apply();
-
-                // immediately hide the change
-                _reverted = true;
-                ShowPopup = false;
-                IsVisible = false;
-            }
-        }
-
-        private void ShowPopUp()
-        {
-            ShowPopup = true;
-        }
-    }
+using System;
+using System.Windows;
+using System.Windows.Media;         
+using GalaSoft.MvvmLight;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+
+namespace GitDiffMargin.ViewModel
+{
+    internal abstract class DiffViewModel : ViewModelBase
+    {
+        private double _height;
+        private double _top;
+        protected readonly HunkRangeInfo HunkRangeInfo;
+        protected readonly IMarginCore MarginCore;
+        private readonly Action<DiffViewModel, HunkRangeInfo> _updateDiffDimensions;
+        private bool _isVisible;
+
+        protected DiffViewModel(HunkRangeInfo hunkRangeInfo, IMarginCore marginCore, Action<DiffViewModel, HunkRangeInfo> updateDiffDimensions)
+        {
+            HunkRangeInfo = hunkRangeInfo;
+            MarginCore = marginCore;
+            _updateDiffDimensions = updateDiffDimensions;
+
+            MarginCore.BrushesChanged += HandleBrushesChanged;
+        }
+
+        public double Height
+        {
+            get { return _height; }
+            set
+            {
+                _height = value;
+                RaisePropertyChanged(() => Height);
+            }
+        }
+
+        public double Top
+        {
+            get { return _top; }
+            set
+            {
+                _top = value;
+                RaisePropertyChanged(() => Top);
+            }
+        }
+
+        public virtual double Width
+        {
+            get
+            {
+                return MarginCore.EditorChangeWidth;
+            }
+        }
+
+        public Thickness Margin
+        {
+            get
+            {
+                return new Thickness(MarginCore.EditorChangeLeft, 0, 0, 0);
+            }
+        }
+
+        public bool IsDeletion { get { return HunkRangeInfo.IsDeletion;} }
+
+        public Brush DiffBrush
+        {
+            get
+            {
+                if (HunkRangeInfo.IsAddition)
+                {
+                    return MarginCore.AdditionBrush;
+                }
+                return HunkRangeInfo.IsModification ? MarginCore.ModificationBrush : MarginCore.RemovedBrush;
+            }
+        }
+
+        public int LineNumber { get { return HunkRangeInfo.NewHunkRange.StartingLineNumber; } }
+
+        public virtual bool IsVisible
+        {
+            get { return _isVisible; }
+            set { _isVisible = value;
+                RaisePropertyChanged(() => IsVisible);}
+        }
+
+        public void RefreshPosition()
+        {
+            UpdateDimensions();
+        }
+
+        private void HandleBrushesChanged(object sender, EventArgs e)
+        {
+            RaisePropertyChanged(() => DiffBrush);
+        }
+
+        protected virtual void UpdateDimensions()
+        {
+            _updateDiffDimensions(this, HunkRangeInfo);
+        }
+    }
 }
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/EditorDiffMarginViewModel.cs b/GitDiffMargin/ViewModel/EditorDiffMarginViewModel.cs
new file mode 100644
index 0000000..f02d1a2
--- /dev/null
+++ b/GitDiffMargin/ViewModel/EditorDiffMarginViewModel.cs
@@ -0,0 +1,81 @@
+#region using
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GalaSoft.MvvmLight.Command;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+
+#endregion
+
+namespace GitDiffMargin.ViewModel
+{
+    internal class EditorDiffMarginViewModel : DiffMarginViewModelBase
+    {
+        private readonly Action<DiffViewModel, HunkRangeInfo> _updateDiffDimensions;
+        private RelayCommand<DiffViewModel> _previousChangeCommand;
+        private RelayCommand<DiffViewModel> _nextChangeCommand;
+
+        internal EditorDiffMarginViewModel(IMarginCore marginCore, Action<DiffViewModel, HunkRangeInfo> updateDiffDimensions) :
+            base(marginCore)
+        {
+            if (updateDiffDimensions == null)
+                throw new ArgumentNullException("updateDiffDimensions");
+
+            _updateDiffDimensions = updateDiffDimensions;
+        }
+
+        public RelayCommand<DiffViewModel> PreviousChangeCommand
+        {
+            get { return _previousChangeCommand ?? (_previousChangeCommand = new RelayCommand<DiffViewModel>(PreviousChange, PreviousChangeCanExecute)); }
+        }
+
+        public RelayCommand<DiffViewModel> NextChangeCommand
+        {
+            get { return _nextChangeCommand ?? (_nextChangeCommand = new RelayCommand<DiffViewModel>(NextChange, NextChangeCanExecute)); }
+        }
+
+        private bool PreviousChangeCanExecute(DiffViewModel currentEditorDiffViewModel)
+        {
+            return DiffViewModels.IndexOf(currentEditorDiffViewModel) > 0;
+        }
+
+        private bool NextChangeCanExecute(DiffViewModel currentEditorDiffViewModel)
+        {
+            return DiffViewModels.IndexOf(currentEditorDiffViewModel) < (DiffViewModels.Count - 1);
+        }
+
+        private void PreviousChange(DiffViewModel currentEditorDiffViewModel)
+        {
+            MoveToChange(currentEditorDiffViewModel, -1);
+        }
+
+        private void NextChange(DiffViewModel currentEditorDiffViewModel)
+        {
+            MoveToChange(currentEditorDiffViewModel, +1);
+        }
+
+        private void MoveToChange(DiffViewModel currentDiffViewModel, int indexModifier)
+        {
+            var diffViewModelIndex = DiffViewModels.IndexOf(currentDiffViewModel) + indexModifier;
+            var diffViewModel  = DiffViewModels[diffViewModelIndex];
+
+            MarginCore.MoveToChange(diffViewModel.LineNumber);    
+
+            ((EditorDiffViewModel)currentDiffViewModel).ShowPopup = false;
+        }
+
+        protected override void HandleHunksChanged(object sender, IEnumerable<HunkRangeInfo> hunkRangeInfos)
+        {
+            if (DiffViewModels.Cast<EditorDiffViewModel>().Any(dvm => dvm.ShowPopup)) return;
+
+            base.HandleHunksChanged(sender, hunkRangeInfos);
+        }
+
+        protected override DiffViewModel CreateDiffViewModel(HunkRangeInfo hunkRangeInfo)
+        {
+            return new EditorDiffViewModel(hunkRangeInfo, MarginCore, _updateDiffDimensions);
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/EditorDiffViewModel.cs b/GitDiffMargin/ViewModel/EditorDiffViewModel.cs
new file mode 100644
index 0000000..8ba82a6
--- /dev/null
+++ b/GitDiffMargin/ViewModel/EditorDiffViewModel.cs
@@ -0,0 +1,216 @@
+#region using
+
+using System;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using GalaSoft.MvvmLight.Command;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+using System.Linq;
+
+#endregion
+
+namespace GitDiffMargin.ViewModel
+{
+    internal class EditorDiffViewModel : DiffViewModel
+    {
+        private bool _isDiffTextVisible;
+        private bool _showPopup;
+        private bool _reverted;
+        private ICommand _copyOldTextCommand;
+        private ICommand _rollbackCommand;
+        private ICommand _showPopUpCommand;
+
+        internal EditorDiffViewModel(HunkRangeInfo hunkRangeInfo, IMarginCore marginCore, Action<DiffViewModel, HunkRangeInfo> updateDiffDimensions)
+            : base(hunkRangeInfo, marginCore, updateDiffDimensions)
+        {
+            ShowPopup = false;
+
+            DiffText = GetDiffText();
+
+            IsDiffTextVisible = GetIsDiffTextVisible();
+
+            UpdateDimensions();
+        }
+
+        private bool GetIsDiffTextVisible()
+        {
+            return HunkRangeInfo.IsDeletion || HunkRangeInfo.IsModification;
+        }
+
+        private string GetDiffText()
+        {
+            if (HunkRangeInfo.OriginalText != null && HunkRangeInfo.OriginalText.Any())
+            {
+                return HunkRangeInfo.IsModification || HunkRangeInfo.IsDeletion ? String.Join(Environment.NewLine, HunkRangeInfo.OriginalText) : string.Empty;
+            }
+
+            return string.Empty;
+        }
+
+        protected override void UpdateDimensions()
+        {
+            if (_reverted) return;
+
+            base.UpdateDimensions();
+        }
+
+        public FontFamily FontFamily
+        {
+            get { return MarginCore.FontFamily; }
+        }
+
+        public FontStretch FontStretch
+        {
+            get { return MarginCore.FontStretch; }
+        }
+
+        public FontStyle FontStyle
+        {
+            get
+            {
+                return MarginCore.FontStyle;
+            }
+        }
+
+        public FontWeight FontWeight
+        {
+            get
+            {
+                return MarginCore.FontWeight;
+            }
+        }
+
+        public double FontSize
+        {
+            get
+            {
+                return MarginCore.FontSize;
+            }
+        }
+
+        //public double MaxWidth
+        //{
+        //    get
+        //    {
+        //        return _textView.ViewportWidth;
+        //    }
+        //}
+
+        //public double MaxHeight
+        //{
+        //    get
+        //    {
+        //        return Math.Max(_textView.ViewportHeight * 2.0 / 3.0, 400);
+        //    }
+        //}
+
+        public Brush Background
+        {
+            get
+            {
+                return MarginCore.Background;
+            }
+        }
+
+        public Brush Foreground
+        {
+            get
+            {
+                return MarginCore.Foreground;
+            }
+        }
+
+        public ICommand ShowPopUpCommand
+        {
+            get { return _showPopUpCommand ?? (_showPopUpCommand = new RelayCommand(ShowPopUp)); }
+        }
+
+        public bool ShowPopup
+        {
+            get { return _showPopup; }
+            set
+            {
+                if (value == _showPopup) return;
+                _showPopup = value;
+                RaisePropertyChanged(() => ShowPopup);
+            }
+        }
+
+        public string DiffText { get; private set; }
+
+        public bool IsDiffTextVisible
+        {
+            get { return _isDiffTextVisible; }
+            set
+            {
+                if (value == _isDiffTextVisible) return;
+                _isDiffTextVisible = value;
+                RaisePropertyChanged(() => IsDiffTextVisible);
+            }
+        }
+
+        private ICommand _showDifferenceCommand;
+
+        public ICommand ShowDifferenceCommand
+        {
+            get { return _showDifferenceCommand ?? (_showDifferenceCommand = new RelayCommand(ShowDifference, ShowDifferenceCanExecute)); }
+        }
+
+        private bool ShowDifferenceCanExecute()
+        {
+            return HunkRangeInfo.IsModification || HunkRangeInfo.IsDeletion || HunkRangeInfo.IsAddition;
+        }
+
+        private void ShowDifference()
+        {
+            var document = MarginCore.GetTextDocument();
+            if (document != null)
+            {
+                MarginCore.GitCommands.StartExternalDiff(document);
+            } 
+        }
+
+        public ICommand CopyOldTextCommand
+        {
+            get { return _copyOldTextCommand ?? (_copyOldTextCommand = new RelayCommand(CopyOldText, CopyOldTextCanExecute)); }
+        }
+
+        public ICommand RollbackCommand
+        {
+            get { return _rollbackCommand ?? (_rollbackCommand = new RelayCommand(Rollback, RollbackCanExecute)); }
+        }
+
+        private bool CopyOldTextCanExecute()
+        {
+            return HunkRangeInfo.IsModification || HunkRangeInfo.IsDeletion;
+        }
+
+        private void CopyOldText()
+        {
+            Clipboard.SetText(DiffText);
+            ShowPopup = false;
+        }
+
+        private bool RollbackCanExecute()
+        {
+            return HunkRangeInfo.IsModification || HunkRangeInfo.IsDeletion || HunkRangeInfo.IsAddition;
+        }
+
+        private void Rollback()
+        {
+            if (!MarginCore.RollBack(HunkRangeInfo)) return;
+
+            // immediately hide the change
+            _reverted = true;
+            ShowPopup = false;
+            IsVisible = false;
+        }
+
+        private void ShowPopUp()
+        {
+            ShowPopup = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/ScrollDiffMarginViewModel.cs b/GitDiffMargin/ViewModel/ScrollDiffMarginViewModel.cs
new file mode 100644
index 0000000..f7726b7
--- /dev/null
+++ b/GitDiffMargin/ViewModel/ScrollDiffMarginViewModel.cs
@@ -0,0 +1,25 @@
+using System;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+
+namespace GitDiffMargin.ViewModel
+{
+    internal class ScrollDiffMarginViewModel : DiffMarginViewModelBase
+    {
+        private readonly Action<DiffViewModel, HunkRangeInfo> _updateDiffDimensions;
+
+        internal ScrollDiffMarginViewModel(IMarginCore marginCore, Action<DiffViewModel, HunkRangeInfo> updateDiffDimensions) :
+            base(marginCore)
+        {
+            if (updateDiffDimensions == null)
+                throw new ArgumentNullException("updateDiffDimensions");
+
+            _updateDiffDimensions = updateDiffDimensions;
+        }
+
+        protected override DiffViewModel CreateDiffViewModel(HunkRangeInfo hunkRangeInfo)
+        {
+            return new ScrollDiffViewModel(hunkRangeInfo, MarginCore, _updateDiffDimensions);
+        }
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/ViewModel/ScrollDiffViewModel.cs b/GitDiffMargin/ViewModel/ScrollDiffViewModel.cs
new file mode 100644
index 0000000..1dc9a22
--- /dev/null
+++ b/GitDiffMargin/ViewModel/ScrollDiffViewModel.cs
@@ -0,0 +1,30 @@
+using System;
+using GitDiffMargin.Core;
+using GitDiffMargin.Git;
+
+namespace GitDiffMargin.ViewModel
+{
+    internal sealed class ScrollDiffViewModel : DiffViewModel
+    {
+        internal ScrollDiffViewModel(HunkRangeInfo hunkRangeInfo, IMarginCore marginCore, Action<DiffViewModel, HunkRangeInfo> updateDiffDimensions)
+            : base(hunkRangeInfo, marginCore, updateDiffDimensions)
+        {
+            UpdateDimensions();
+        }
+
+        public override bool IsVisible
+        {
+            get { return true; }
+            set { }
+        }
+
+        public override double Width
+        {
+            get
+            {
+                return MarginCore.ScrollChangeWidth;
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/GitDiffMargin/packages.config b/GitDiffMargin/packages.config
index 3627f93..94939ba 100644
--- a/GitDiffMargin/packages.config
+++ b/GitDiffMargin/packages.config
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="LibGit2Sharp" version="0.16.0.0" targetFramework="net45" />
-  <package id="MvvmLightPreview" version="4.1.21.1" />
+  <package id="CommonServiceLocator" version="1.3" targetFramework="net45" />
+  <package id="LibGit2Sharp" version="0.18.1.0" targetFramework="net45" />
+  <package id="MvvmLightLibs" version="4.4.32.1" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/GitDiffMargin/source.extension.vsixmanifest b/GitDiffMargin/source.extension.vsixmanifest
index 5a424ab..083490d 100644
--- a/GitDiffMargin/source.extension.vsixmanifest
+++ b/GitDiffMargin/source.extension.vsixmanifest
@@ -1,23 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Vsix xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Version="1.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2010">
   <Identifier Id="GitDiffMargin..5ef9f816-d9ce-45cd-a8fa-cd67a807df0e">
-    <Name>Git Diff Margin</Name>
+    <Name>Git Diff Margin 2013</Name>
     <Author>Laurent Kempé</Author>
-    <Version>1.3.2</Version>
-    <Description xml:space="preserve">A margin extension to the Visual Studio Editor which displays the git diff.</Description>
+    <Version>2.0.0.0</Version>
+    <Description xml:space="preserve">Git Diff Margin displays live changes of the currently edited file on Visual Studio 2013 margin and scroll bar.</Description>
     <MoreInfoUrl>https://github.com/laurentkempe/GitDiffMargin</MoreInfoUrl>
     <ReleaseNotes>http://visualstudiogallery.msdn.microsoft.com/cf49cf30-2ca6-4ea0-b7cc-6a8e0dadc1a8</ReleaseNotes>
     <Locale>1033</Locale>
-    <Icon>GitDiffMargin-Thumb.png</Icon>
-    <PreviewImage>GitDiffMargin-Preview.png</PreviewImage>
+    <Icon>Resources/GitDiffMargin-Thumb.png</Icon>
+    <PreviewImage>Resources/GitDiffMargin-Preview.png</PreviewImage>
     <License>License.md</License>
     <SupportedProducts>
-      <VisualStudio Version="11.0">
-        <Edition>Pro</Edition>
-        <Edition>Premium</Edition>
-        <Edition>Ultimate</Edition>
-        <Edition>IntegratedShell</Edition>
-      </VisualStudio>
       <VisualStudio Version="12.0">
         <Edition>Pro</Edition>
         <Edition>Premium</Edition>
diff --git a/LICENSE.md b/LICENSE.md
index fa8cfa8..898a7f9 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) 2012-2013 Laurent Kempé
+Copyright (c) 2012-2014 Laurent Kempé
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 6f936c4..4fcf78a 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,23 @@
 # Git Diff Margin
 
-A Visual Studio 2013/2012 extension to display Git Diff on the margin of the current file.
-
-* Quickly view all current file changes on the left margin: blue rectangle for modification, green rectangle for new lines and grey triangle for deletion
-* Navigate to previous/next change on the file
+Git Diff Margin displays live changes of the currently edited file on Visual Studio 2013 margin and scroll bar
+
+* Quickly view all current file changes on
+    * Left margin
+    * Scroll Bars in map and bar mode with and without source overview
+        * blue rectangle for modifications
+        * green rectangles for new lines
+        * red triangles for deletions
+        * all colors configurable through Visual Studio Fonts and Colors options
 * Undo the change
-* Show the diff in external tool
 * Copy the old code into the clipboard
 * Copy a part of the old code by selecting it in the popup
-* Define the colors of the Addition, Modification and Deletion diff margin through Visual Studio Fonts and Colors options
-* Support Visual Studio 2013/2012 Dark, Light and Blue Theme
-* Support the zoom
+* Show the diff in configured Git external diff tool
+* Navigate to previous/next change on the file
+* Support Visual Studio 2013 Dark, Light and Blue Theme
+* Support zoom
+
+![Screenshot](https://c2.staticflickr.com/6/5584/14880092457_5b32e67a6a.jpg)
 
 Perfect companion of [Visual Studio Tools for Git](http://visualstudiogallery.msdn.microsoft.com/abafc7d6-dcaa-40f4-8a5e-d6724bdb980c)
 
@@ -18,20 +25,16 @@ Perfect companion of [Visual Studio Tools for Git](http://visualstudiogallery.ms
 
 Grab it from inside of Visual Studio's Extension Manager, or via the [Extension Gallery link](http://visualstudiogallery.msdn.microsoft.com/cf49cf30-2ca6-4ea0-b7cc-6a8e0dadc1a8)
 
-Or use the [Chocolatey installation](http://chocolatey.org/packages/GitDiffMargin.vs2012) Thanks to [@Iristyle](https://github.com/Iristyle)
+Or use the [Chocolatey installation](http://chocolatey.org/packages/GitDiffMargin.vs2012)
 
-## Screenshots
+## Video
 
-![Screenshot](http://farm9.staticflickr.com/8329/8116895025_ec9519b5bb_o.png)
-
-![Screenshot](http://farm9.staticflickr.com/8370/8457441367_dc23f4a51c_o.png)
-
-![Screenshot](http://farm9.staticflickr.com/8385/8457451383_068e258b94_o.png)
-
-You might see a little video on the [following page](http://www.flickr.com/photos/laurentkempe/8116990137/).
+You might see a little video on the [following page](https://www.flickr.com/photos/laurentkempe/14879945429/).
 
 ## Credits
 
-Thanks to Sam Harwell [@sharwell](https://github.com/sharwell) for all the improvements!
+Thanks to Sam Harwell [@sharwell](https://github.com/sharwell) for all the improvements
+
+Thanks to Rick Sladkey [@ricksladkey](https://github.com/ricksladkey) for the fixes
 
-Thanks to Rick Sladkey [@ricksladkey](https://github.com/ricksladkey) for the fixes!
+ Thanks to [@Iristyle](https://github.com/Iristyle) for the chocolatey package
\ No newline at end of file