[gh-4] Initial version of breakpoint overlays.

ashmind · Jan 3, 2015 · de6b372 · de6b372
1 parent c1a4cfe
commit de6b372
Show file tree

Hide file tree

Showing 20 changed files with 285 additions and 50 deletions.
diff --git a/#assets/BreakpointOverlay.pdn b/#assets/BreakpointOverlay.pdn
diff --git a/ExceptionBreaker.sln.DotSettings b/ExceptionBreaker.sln.DotSettings
@@ -9,6 +9,7 @@
 	<s:String x:Key="/Default/CodeStyle/CSharpUsing/KeepImports/=System/@EntryIndexedValue">System</s:String>
 	<s:String x:Key="/Default/CodeStyle/CSharpUsing/KeepImports/=System_002ECollections_002EGeneric/@EntryIndexedValue">System.Collections.Generic</s:String>
 	<s:String x:Key="/Default/CodeStyle/CSharpUsing/KeepImports/=System_002ELinq/@EntryIndexedValue">System.Linq</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=DTE/@EntryIndexedValue">DTE</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=VS/@EntryIndexedValue">VS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=LocalConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/ExceptionBreaker/Breakpoints/BreakpointEventProcessor.cs b/ExceptionBreaker/Breakpoints/BreakpointEventProcessor.cs
@@ -9,13 +9,13 @@
 namespace ExceptionBreaker.Breakpoints {
     public class BreakpointEventProcessor : IDebugEventCallback2, IDisposable {
         private readonly IVsDebugger _debugger;
-        private readonly BreakpointExtraDataProvider _extraDataProvider;
+        private readonly BreakpointExtraDataStore _extraDataStore;
         private readonly ExceptionBreakManager _breakManager;
         private readonly IDiagnosticLogger _logger;
 
-        public BreakpointEventProcessor(IVsDebugger debugger, BreakpointExtraDataProvider extraDataProvider, ExceptionBreakManager breakManager, IDiagnosticLogger logger) {
+        public BreakpointEventProcessor(IVsDebugger debugger, BreakpointExtraDataStore extraDataStore, ExceptionBreakManager breakManager, IDiagnosticLogger logger) {
             _debugger = debugger;
-            _extraDataProvider = extraDataProvider;
+            _extraDataStore = extraDataStore;
             _breakManager = breakManager;
             _logger = logger;
 
@@ -46,7 +46,7 @@ private void ProcessEvent(IDebugEvent2 pEvent) {
 
             _logger.WriteLine("Event: Breakpoint reached.");
             foreach (var breakpoint in breakpointEvent.GetBreakpointsAsArraySafe()) {
-                var extraData = _extraDataProvider.GetData(breakpoint);
+                var extraData = _extraDataStore.GetData(breakpoint);
                 if (extraData == null || extraData.ExceptionBreakChange == ExceptionBreakChange.NoChange)
                     continue;
 

diff --git a/...reakpoints/BreakpointExtraDataProvider.cs → ...r/Breakpoints/BreakpointExtraDataStore.cs b/...reakpoints/BreakpointExtraDataProvider.cs → ...r/Breakpoints/BreakpointExtraDataStore.cs
@@ -1,27 +1,33 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.ComponentModel.Composition;
 using System.IO;
 using System.Linq;
-using AshMind.Extensions;
 using EnvDTE80;
 using ExceptionBreaker.Core;
 using JetBrains.Annotations;
 using Microsoft.VisualStudio.Debugger.Interop;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 
 namespace ExceptionBreaker.Breakpoints {
-    public class BreakpointExtraDataProvider : ISolutionDataPersister {
+    [Export]
+    public class BreakpointExtraDataStore : ISolutionDataPersister {
         private readonly BreakpointKeyProvider _keyProvider;
         private readonly BreakpointFinder _finder;
         private readonly JsonSerializer _jsonSerializer;
         private readonly IDiagnosticLogger _logger;
         private readonly ConcurrentDictionary<string, BreakpointExtraData> _store = new ConcurrentDictionary<string, BreakpointExtraData>(StringComparer.InvariantCultureIgnoreCase);
 
-        public BreakpointExtraDataProvider(BreakpointKeyProvider keyProvider, BreakpointFinder finder, JsonSerializer jsonSerializer, IDiagnosticLogger logger) {
+        [ImportingConstructor]
+        public BreakpointExtraDataStore(BreakpointKeyProvider keyProvider, BreakpointFinder finder, IDiagnosticLogger logger) {
             _keyProvider = keyProvider;
             _finder = finder;
-            _jsonSerializer = jsonSerializer;
+            _jsonSerializer = new JsonSerializer {
+                Converters = { new StringEnumConverter() },
+                Formatting = Formatting.None
+            };
             _logger = logger;
         }
 

diff --git a/ExceptionBreaker/Breakpoints/BreakpointFinder.cs b/ExceptionBreaker/Breakpoints/BreakpointFinder.cs
@@ -1,15 +1,20 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.Composition;
 using System.Linq;
 using EnvDTE;
 using EnvDTE80;
+using ExceptionBreaker.Core;
+using Microsoft.VisualStudio.Text;
 
 namespace ExceptionBreaker.Breakpoints {
+    [Export]
     public class BreakpointFinder {
         private readonly DTE _dte;
 
-        public BreakpointFinder(DTE dte) {
-            _dte = dte;
+        [ImportingConstructor]
+        public BreakpointFinder(DTEImport dteImport) {
+            _dte = dteImport.DTE;
         }
 
         public IEnumerable<Breakpoint2> GetAllBreakpoints() {
@@ -19,15 +24,19 @@ public IEnumerable<Breakpoint2> GetAllBreakpoints() {
         public Breakpoint2 GetBreakpointForCommand() {
             var path = _dte.ActiveDocument.FullName;
             var line = ((TextSelection)_dte.ActiveDocument.Selection).CurrentLine;
+            return GetBreakpointFromLocation(path, line);
+        }
 
-            var breakpoints = _dte.Debugger.Breakpoints;
-            for (var i = 1; i <= breakpoints.Count; i++) {
-                var breakpoint = breakpoints.Item(i);
-                if (breakpoint.File == path && breakpoint.FileLine == line)
-                    return (Breakpoint2)breakpoint;
-            }
+        public Breakpoint2 GetBreakpointFromSpan(SnapshotSpan span, ITextDocument document) {
+            var path = document.FilePath;
+            var line = span.Snapshot.GetLineNumberFromPosition(span.Span.Start) + 1;
+            return GetBreakpointFromLocation(path, line);
+        }
 
-            return null;
+        private Breakpoint2 GetBreakpointFromLocation(string path, int line) {
+            return GetAllBreakpoints().FirstOrDefault(
+                breakpoint => breakpoint.File == path && breakpoint.FileLine == line
+            );
         }
     }
 }
diff --git a/ExceptionBreaker/Breakpoints/BreakpointKeyProvider.cs b/ExceptionBreaker/Breakpoints/BreakpointKeyProvider.cs
@@ -1,14 +1,15 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.Composition;
 using System.Linq;
 using System.Runtime.InteropServices;
-using System.Text;
 using EnvDTE80;
 using ExceptionBreaker.Core;
 using JetBrains.Annotations;
 using Microsoft.VisualStudio.Debugger.Interop;
 
 namespace ExceptionBreaker.Breakpoints {
+    [Export]
     public class BreakpointKeyProvider {
         [NotNull]
         public string GetKey(Breakpoint2 breakpoint) {

diff --git a/ExceptionBreaker/Breakpoints/BreakpointSetupExceptionsController.cs b/ExceptionBreaker/Breakpoints/BreakpointSetupExceptionsController.cs
@@ -9,27 +9,27 @@
 namespace ExceptionBreaker.Breakpoints {
     public class BreakpointSetupExceptionsController {
         private readonly BreakpointFinder _breakpointFinder;
-        private readonly BreakpointExtraDataProvider _extraDataProvider;
+        private readonly BreakpointExtraDataStore _extraDataStore;
         private readonly IDiagnosticLogger _logger;
         private readonly MenuCommand _command;
 
         public BreakpointSetupExceptionsController(CommandInitializer commandInitializer,
                                                    BreakpointFinder breakpointFinder,
-                                                   BreakpointExtraDataProvider extraDataProvider,
+                                                   BreakpointExtraDataStore extraDataStore,
                                                    IDiagnosticLogger logger) 
         {
             _breakpointFinder = breakpointFinder;
-            _extraDataProvider = extraDataProvider;
+            _extraDataStore = extraDataStore;
             _logger = logger;
             _command = commandInitializer.InitializeCommand(command_Callback, command_BeforeQueryStatus);
         }
 
         private void command_BeforeQueryStatus(object sender, EventArgs e) {
             try {
                 var breakpoint = _breakpointFinder.GetBreakpointForCommand();
-                var extraData = _extraDataProvider.GetData(breakpoint);
+                var extraData = _extraDataStore.GetData(breakpoint);
 
-                var @checked = (extraData != null && extraData.ExceptionBreakChange != ExceptionBreakChange.NoChange);
+                var @checked = extraData.ExceptionBreakChange != ExceptionBreakChange.NoChange;
                 if (@checked == _command.Checked)
                     return;
 
@@ -55,10 +55,10 @@ private void command_Callback(object sender, EventArgs e) {
         }
 
         private void RequestAndUpdateExceptionSettings(Breakpoint2 breakpoint) {
-            var extraData = _extraDataProvider.GetData(breakpoint);
+            var extraData = _extraDataStore.GetData(breakpoint);
             var dialog = new BreakpointExceptionsDialog {
                 ViewModel = new BreakpointExceptionSettings {
-                    Change = extraData != null ? extraData.ExceptionBreakChange : ExceptionBreakChange.NoChange,
+                    Change = extraData.ExceptionBreakChange,
                     ContinueExecution = !breakpoint.BreakWhenHit
                 }
             };

diff --git a/ExceptionBreaker/Breakpoints/Glyphs/BreakpointGlyphFactory.cs b/ExceptionBreaker/Breakpoints/Glyphs/BreakpointGlyphFactory.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media.Imaging;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Formatting;
+
+namespace ExceptionBreaker.Breakpoints.Glyphs {
+    public class BreakpointGlyphFactory : IGlyphFactory {
+        public const string Name = "ExceptionBreaker.BreakpointGlyphFactory";
+        private const int OverlayGlyphSize = 9;
+        private readonly double _breakpointGlyphSize;
+
+        private readonly BitmapImage _image;
+
+        public BreakpointGlyphFactory(IWpfTextViewMargin margin) {
+            _breakpointGlyphSize = margin.MarginSize;
+
+            var assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
+            _image = new BitmapImage(new Uri("pack://application:,,,/" + assemblyName + ";component/Resources/BreakpointOverlay.png"));
+            _image.Freeze();
+        }
+
+        public UIElement GenerateGlyph(IWpfTextViewLine line, IGlyphTag tag) {
+            if (!(tag is BreakpointTag))
+                return null;
+
+            return new Image {
+                Source = _image,
+                Margin = new Thickness {
+                    Left = _breakpointGlyphSize - OverlayGlyphSize,
+                    Top = _breakpointGlyphSize - OverlayGlyphSize
+                },
+                Width  = 9,
+                Height = 9
+            };
+        }
+    }
+}
diff --git a/ExceptionBreaker/Breakpoints/Glyphs/BreakpointGlyphFactoryProvider.cs b/ExceptionBreaker/Breakpoints/Glyphs/BreakpointGlyphFactoryProvider.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel.Composition;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace ExceptionBreaker.Breakpoints.Glyphs {
+    [Export(typeof(IGlyphFactoryProvider))]
+    [Name(BreakpointGlyphFactory.Name)]
+    [Order(After = "VsTextMarker")]
+    [ContentType("code")]
+    [TextViewRole(PredefinedTextViewRoles.Debuggable)]
+    [TagType(typeof(BreakpointTag))]
+    public class BreakpointGlyphFactoryProvider : IGlyphFactoryProvider {
+        public IGlyphFactory GetGlyphFactory(IWpfTextView view, IWpfTextViewMargin margin) {
+            return new BreakpointGlyphFactory(margin);
+        }
+    }
+}
diff --git a/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTag.cs b/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTag.cs
@@ -0,0 +1,11 @@
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace ExceptionBreaker.Breakpoints.Glyphs {
+    public class BreakpointTag : IGlyphTag {
+        public BreakpointExtraData BreakpointExtraData { get; private set; }
+
+        public BreakpointTag(BreakpointExtraData breakpointExtraData) {
+            BreakpointExtraData = breakpointExtraData;
+        }
+    }
+}
diff --git a/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTagger.cs b/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTagger.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Tagging;
+
+namespace ExceptionBreaker.Breakpoints.Glyphs {
+    public class BreakpointTagger : ITagger<BreakpointTag> {
+        private readonly ITextDocument _document;
+        private readonly BreakpointFinder _finder;
+        private readonly BreakpointExtraDataStore _extraDataStore;
+
+        public BreakpointTagger(ITextDocument document, BreakpointFinder finder, BreakpointExtraDataStore extraDataStore) {
+            _document = document;
+            _finder = finder;
+            _extraDataStore = extraDataStore;
+        }
+
+        public IEnumerable<ITagSpan<BreakpointTag>> GetTags(NormalizedSnapshotSpanCollection spans) {
+            foreach (var span in spans) {
+                var breakpoint = _finder.GetBreakpointFromSpan(span, _document);
+                if (breakpoint == null)
+                    continue;
+
+                var extraData = _extraDataStore.GetData(breakpoint);
+                if (extraData.ExceptionBreakChange == ExceptionBreakChange.NoChange)
+                    continue;
+
+                yield return new TagSpan<BreakpointTag>(new SnapshotSpan(span.Start, span.Length), new BreakpointTag(extraData));
+            }
+        }
+
+        public event EventHandler<SnapshotSpanEventArgs> TagsChanged;
+    }
+}
diff --git a/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTaggerProvider.cs b/ExceptionBreaker/Breakpoints/Glyphs/BreakpointTaggerProvider.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using System.Windows.Media.TextFormatting;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace ExceptionBreaker.Breakpoints.Glyphs {
+    [Export(typeof(ITaggerProvider))]
+    [Order(After = "VsTextMarker")]
+    [ContentType("code")]
+    [TextViewRole(PredefinedTextViewRoles.Debuggable)]
+    [TagType(typeof(BreakpointTag))]
+    public class BreakpointTaggerProvider : ITaggerProvider {
+        private readonly BreakpointFinder _finder;
+        private readonly BreakpointExtraDataStore _extraDataStore;
+
+        [ImportingConstructor]
+        public BreakpointTaggerProvider(BreakpointFinder finder, BreakpointExtraDataStore extraDataStore) {
+            _finder = finder;
+            _extraDataStore = extraDataStore;
+        }
+
+        public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag {
+            var document = (ITextDocument)buffer.Properties[typeof(ITextDocument)];
+            return (ITagger<T>)new BreakpointTagger(document, _finder, _extraDataStore);
+        }
+    }
+}
diff --git a/ExceptionBreaker/Core/DTEImport.cs b/ExceptionBreaker/Core/DTEImport.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Linq;
+using EnvDTE;
+using Microsoft.VisualStudio.Shell;
+
+namespace ExceptionBreaker.Core {
+    [Export]
+    public class DTEImport {
+        [ImportingConstructor]
+        public DTEImport(SVsServiceProvider serviceProvider) {
+            DTE = (DTE) serviceProvider.GetService(typeof (DTE));
+        }
+
+        public DTE DTE { get; private set; }
+    }
+}