Merge pull request #86 from rionmonster/library-toggle

Glyphfriend 2.1 Release

Author: rionmonster

Glyphfriend.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26020.0
+VisualStudioVersion = 15.0.26206.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Glyphfriend.Core", "src\Glyphfriend.Core\Glyphfriend.Core.shproj", "{8189A63E-D159-4195-BE2E-D44B022B45AB}"
 EndProject

README.md

@@ -18,20 +18,28 @@ Glyphfriend is a Visual Studio extension to enhance the existing Intellisense to
 
 ## Getting Started
 
-Glyphfriend has a separate extension for both Visual Studio 2015 and Visual Studio 2017, so to get started, you'll simply need to download the version(s) that apply to you from the Visual Studio Marketplace :
+Glyphfriend has a separate extension for both Visual Studio 2015 and Visual Studio 2017, so to get started, you'll simply need to download the version(s) that apply to you from the Visual Studio Marketplace:
 
 * [Download Glyphfriend 2015](https://marketplace.visualstudio.com/items?itemName=RionWilliams.Glyphfriend)
 * [Download Glyphfriend 2017](https://marketplace.visualstudio.com/items?itemName=RionWilliams.Glyphfriend2017)
 
 You can also just search for it within the **Tools > Extensions and Updates** area of Visual Studio.
 
-After installing the extension, that's it. Glyphfriend will automatically detect when a valid HTML flavored file is opened and it will add all of the supported icons to the autocompletion within `class` attributes as seen below :
+After installing the extension, that's it. Glyphfriend will automatically detect when a valid HTML flavored file is opened and it will add all of the supported icons to the autocompletion within `class` attributes as seen below:
 
 ![Glyphfriend in Action](https://raw.githubusercontent.com/rionmonster/Glyphfriend/develop/art/glyphfriend-in-action.gif)
 
+## Setting Preferences
+
+By default, Glyphfriend has support for Bootstrap Glyphicons enabled by default, however you can easily select the libraries that you prefer to use by simply **right-clicking and selecting the preferred library from the Glyphfriend context menu in any HTML-supported file** as seen below:
+
+![Glyphfriend Library Toggling](https://raw.githubusercontent.com/rionmonster/Glyphfriend/develop/art/glyphfriend-toggling-support.gif)
+
+It's important to note that **library preferences are persistent across Visual Studio sessions.** Basically, you will only need to define which libraries that you want to use and they will be available the next time you open Visual Studio.
+
 ## What's In Here?
 
-Within this repository you'll find all of the necessary projects that make Glyphfriend work, which can be described below :
+Within this repository you'll find all of the necessary projects that make Glyphfriend work, which can be described below:
 
 * **[Glyphfriend.Core](https://github.com/rionmonster/Glyphfriend/tree/develop/src/Glyphfriend.Core)** - This project is a Shared Library that contains all of the necessary code for the extension to work. Namely the autocompletion providers and the necessary code to handle deserializing the glyphs at run-time.
 * **[Glyphfriend.Packager](https://github.com/rionmonster/Glyphfriend/tree/develop/src/Glyphfriend.Packager)** - This project functions as a build-time dependency for the two extension projects and handles generating a binary file containing all of the glyph mappings (via Protobuf), which is consumed and deserialized within the Glyphfriend.Core package.
@@ -42,9 +50,11 @@ Within this repository you'll find all of the necessary projects that make Glyph
 
 If you find an issue or encounter a problem with the extension, please don't hesitate to contact me or file an issue with the [Issues](https://github.com/Rionmonster/Glyphfriend/issues) are of this repository and I'll try to address it as soon as possible.
 
-**If you use Resharper, then Glyphfriend may not work properly (or at all)**. This is a known issue and is outside of my control as many of the APIs that Glyphfriend relies on are overridden by Resharper and thus don't allow the extension to ever be accessed by Visual Studio directly.
+> **NOTE: If you use Resharper, then Glyphfriend may not work properly (or at all), so read this**. 
+
+Issues with Resharper and Glyphfriend have been widely reported (enough to warrant a spot here) and are outside of my control. Many of the APIs that Glyphfriend relies on are overridden by Resharper and thus don't allow the extension to ever be accessed by Visual Studio directly.
 
-The following two options have been successful with other Resharper users, so I would highly recommend trying either of them :
+The following two options have been successful with other Resharper users, so I would highly recommend trying either of them:
 
 * **Try disabling any HTML features within Resharper** - By disabling the HTML autocompletion and other features, this should hopefully allow for Glyphfriend to hook into the necessary APIs and work as expected.
 * **Consider downloading the [ResharperGlyphfriend Plug-in](https://github.com/Huntk23/ResharperGlyphfriend)** - A member of the community, [Kelby Hunt (Huntk23)](https://github.com/Huntk23) wrote a Resharper plug-in port of Glyphfriend, which attempts to implement much of the functionality of this extension. Consider downloading it if the previous approach didn't work as expected.
@@ -58,10 +68,12 @@ just clone this repository, make a fork and add your changes (and then just make
 
 ## Thanks
 
-There are a few folks that I would like to give a special shout-out to several members of the Visual Studio Tooling team for the help and guidance in developing this project, and espeically during the migration over to Visual Studio 2017 :
+I would like to give a special shout-out to several members of the community, including a few from the Visual Studio Tooling team, for their assistance in evolving, developing, and testing Glyphfriend:
 
-* **[Mads Kristensen](https://github.com/madskristensen)**
-* **[Alex Eyler](https://github.com/AlexEyler)**
 * **[Justin Clarebert](https://github.com/justcla)**
+* **[Alex Eyler](https://github.com/AlexEyler)**
+* **[Mads Kristensen](https://github.com/madskristensen)**
+* **[Allen Underwood](http://www.codingblocks.net/about#joezack)**
+* **[Joe Zack](http://www.codingblocks.net/about#joezack)**
 
-Additionally, I want to thank everyone for their feedback on the extension, new feature ideas, and all of the folks that don't hesitate to shoot an e-mail my way regarding the project.
+Additionally, I want to thank everyone for their feedback on the extension, new feature ideas, and all of the folks that don't hesitate to shoot an e-mail my way regarding the project.

appveyor.yml

@@ -1,4 +1,4 @@
-version: 2.0.1.{build}
+version: 2.1.0.{build}
 configuration: Release
 image: Visual Studio 2017 RC
 branches:

art/glyphfriend-toggling-support.gif

@@ -0,0 +1,49 @@
+using Microsoft.VisualStudio.Shell;
+using System;
+using System.ComponentModel.Design;
+
+namespace Glyphfriend
+{
+    internal sealed class ToggleLibraryCommand
+    {
+        public static ToggleLibraryCommand Instance { get; private set; }
+
+        private readonly Package _package;
+        private IServiceProvider ServiceProvider => _package;
+
+        public static void Initialize(Package package)
+        {
+            Instance = new ToggleLibraryCommand(package);
+        }
+
+        private ToggleLibraryCommand(Package package)
+        {
+            _package = package;
+
+            var commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
+            if (commandService != null)
+            {
+                foreach (var library in Constants.Libraries.Keys)
+                {
+                    var command = CreateCommand(Constants.ToggleLibraryCommandSet, library);
+                    commandService.AddCommand(command);
+                }
+            }
+        }
+
+        private MenuCommand CreateCommand(Guid commandSet, int commandId)
+        {
+            var library = Constants.Libraries[commandId];
+            // Generate the command that will map this particular library to the appropriate button within the
+            // .vsct file
+            return new MenuCommand(ToggleLibrary, new CommandID(commandSet, commandId)) { Checked = library.Enabled };
+        }
+
+        private void ToggleLibrary(object sender, EventArgs e)
+        {
+            var command = (MenuCommand)sender;
+            command.Checked = !command.Checked;
+            GlyphfriendPreferences.ToggleLibrary(command.CommandID.ID, command.Checked);
+        }
+    }
+}

src/Glyphfriend.Core/Commands/ToggleLibraryCommand.cs

@@ -6,7 +6,7 @@
 
 namespace Glyphfriend
 {
-    abstract class BaseClassCompletionProvider : IHtmlCompletionListProvider
+    internal abstract class BaseHtmlCompletionListProvider : IHtmlCompletionListProvider
     {
         public abstract string CompletionType { get; }
 
@@ -17,4 +17,4 @@ protected HtmlCompletion CreateItem(string name, ImageSource icon, ICompletionSe
             return new HtmlCompletion(name, name, name, icon, null, session);
         }
     }
-}
+}

…etion/BaseClassCompletionListProvider.cs …Completion/BaseCompletionListProvider.cssrc/Glyphfriend.Core/Completion/BaseClassCompletionListProvider.cs renamed to src/Glyphfriend.Core/Completion/BaseCompletionListProvider.cs src/Glyphfriend.Core/Completion/BaseClassCompletionListProvider.cs renamed to src/Glyphfriend.Core/Completion/BaseCompletionListProvider.cs

@@ -1,48 +1,44 @@
-using Glyphfriend.Extensions;
-using Microsoft.Html.Editor.Completion;
+using Microsoft.Html.Editor.Completion;
 using Microsoft.Html.Editor.Completion.Def;
-using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Utilities;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
+using System.Linq;
 
 namespace Glyphfriend
 {
     [HtmlCompletionProvider(CompletionTypes.Values, "*", "class")]
     [ContentType("htmlx")]
-    class GlyphClassCompletionListProvider : BaseClassCompletionProvider
+    internal class GlyphCompletionListProvider : BaseHtmlCompletionListProvider
     {
         [Import]
-        protected SVsServiceProvider GlobalServiceProvider { get;  private set; }
-        public override string CompletionType => CompletionTypes.Values;
+        protected SVsServiceProvider GlobalServiceProvider { get; private set; }
+
+        public override string CompletionType { get { return CompletionTypes.Values; } }
 
         public override IList<HtmlCompletion> GetEntries(HtmlCompletionContext context)
         {
             VSPackage package = (VSPackage)EnsurePackageLoaded();
-            if(package == null)
+            if (package == null)
             {
+                Logger.Log("Package failed to load properly!");
                 return new List<HtmlCompletion>();
             }
-
             var glyphCompletionItems = new List<HtmlCompletion>();
-            foreach (var glyph in package.Glyphs)
+            // Get the filtered set of enabled glyphs
+            var enabledGlyphs = package.Glyphs.Where(g => g.Enabled);
+            foreach (var glyph in enabledGlyphs)
             {
-                glyphCompletionItems.Add(CreateItem(glyph.Key, glyph.Value, context.Session));
+                glyphCompletionItems.Add(CreateItem(glyph.Name, glyph.Image, context.Session));
             }
             return glyphCompletionItems;
         }
 
         private IVsPackage EnsurePackageLoaded()
         {
-            IVsPackage package;
-            // If the package failed to load or is null, explicitly load it
-            if (!ErrorHandler.Succeeded(GlobalServiceProvider.GetShell().IsPackageLoaded(Constants.PackageGuid, out package)) || package == null)
-            {
-                package = GlobalServiceProvider.GetShell().LoadPackage<VSPackage>();
-            }
-            return package;
+            return GlobalServiceProvider.GetShell().LoadPackage<VSPackage>();
         }
     }
 }

…tion/GlyphClassCompletionListProvider.cs …ompletion/GlyphCompletionListProvider.cssrc/Glyphfriend.Core/Completion/GlyphClassCompletionListProvider.cs renamed to src/Glyphfriend.Core/Completion/GlyphCompletionListProvider.cs src/Glyphfriend.Core/Completion/GlyphClassCompletionListProvider.cs renamed to src/Glyphfriend.Core/Completion/GlyphCompletionListProvider.cs

@@ -1,10 +1,50 @@
 using System;
+using System.Collections.Generic;
 
 namespace Glyphfriend
 {
-    class Constants
+    internal class Constants
     {
+        /// <summary>
+        /// These settings are specific to Glyphfriend itself and its associated commands
+        /// </summary>
+        public const string UserSettingsLibrary = "GlyphfriendLibraries";
+
         public const string HtmlFileLoadedContext = "21F5568E-A5DE-4821-AF39-F4F1049BB9CF";
         public static readonly Guid PackageGuid = new Guid("21F5568E-A5DE-4821-AF39-F4F1049BB9CF");
+        public static readonly Guid ToggleLibraryCommandSet = new Guid("faf962bd-d32b-4c73-a5d3-fcdf95277a21");
+
+        /// <summary>
+        /// These commands are associated with the items found within the VSCT files and handles configuring
+        /// the menu items that appear. Thus any new libraries will need to have key defined here and
+        /// a button set within the VSCT file as well.
+        /// </summary>
+        public const int ToggleLibraryCommandId = 0x0100;
+
+        public const int ToggleBootstrapCommand = 0x1101;
+        public const int ToggleEntypoCommand = 0x1102;
+        public const int ToggleFontAwesomeCommand = 0x1103;
+        public const int ToggleFoundationCommand = 0x1104;
+        public const int ToggleIonicCommand = 0x1105;
+        public const int ToggleMaterialDesignCommand = 0x1106;
+        public const int ToggleMetroUiCommand = 0x1107;
+        public const int ToggleOcticonsCommand = 0x1108;
+        // public const int ToggleYourLibraryHereCommand = 0x1109;
+
+        /// <summary>
+        /// These are all of the supported libraries in Glyphfriend along with their associated default
+        /// values (i.e. only Bootstrap is enabled by default).
+        /// </summary>
+        public static readonly Dictionary<int, GlyphLibrary> Libraries = new Dictionary<int, GlyphLibrary>(){
+            { ToggleBootstrapCommand, new GlyphLibrary("Bootstrap",  true) },
+            { ToggleEntypoCommand, new GlyphLibrary("Entypo",  false) },
+            { ToggleFontAwesomeCommand, new GlyphLibrary("Font Awesome",  false) },
+            { ToggleFoundationCommand, new GlyphLibrary("Foundation",  false) },
+            { ToggleIonicCommand, new GlyphLibrary("Ionic", false) },
+            { ToggleMaterialDesignCommand, new GlyphLibrary("Material Design", false) },
+            { ToggleMetroUiCommand, new GlyphLibrary("Metro UI",  false) },
+            { ToggleOcticonsCommand, new GlyphLibrary("Octicons", false) },
+            // { ToggleYourLibraryHereCommand, new GlyphLibrary("Your Library", false) }
+        };
     }
-}
+}

src/Glyphfriend.Core/Constants.cs

@@ -3,7 +3,7 @@
 using Microsoft.VisualStudio.Shell.Interop;
 using System;
 
-namespace Glyphfriend.Extensions
+namespace Glyphfriend
 {
     public static class ServiceProviderExtensions
     {
@@ -25,4 +25,4 @@ public static T LoadPackage<T>(this IVsShell shell) where T : Package
             return (T)package;
         }
     }
-}
+}

src/Glyphfriend.Core/Extensions/ServiceProviderExtensions.cs

@@ -0,0 +1,56 @@
+using ProtoBuf;
+using System.IO;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace Glyphfriend
+{
+    /// <summary>
+    /// This class presents a single Glyph image and contains various informatio about it,
+    /// its image contents, and a method to handle generating a usable ImageSource with
+    /// the contents after it has been deserialized.
+    /// </summary>
+    [ProtoContract]
+    internal class Glyph
+    {
+        [ProtoMember(1)]
+        public string Name { get; private set; }
+
+        [ProtoMember(2)]
+        public string Library { get; private set; }
+
+        [ProtoMember(3)]
+        public byte[] ImageContent { get; private set; }
+
+        [ProtoIgnore]
+        public bool Enabled { get; set; }
+
+        [ProtoIgnore]
+        public ImageSource Image { get; set; }
+
+        public Glyph()
+        {
+        }
+
+        public Glyph(string name, string library, byte[] imageContent)
+        {
+            Name = name;
+            Library = library;
+            ImageContent = imageContent;
+        }
+
+        public void GenerateImage()
+        {
+            var image = new BitmapImage();
+            using (var ms = new MemoryStream(ImageContent))
+            {
+                image.BeginInit();
+                image.StreamSource = ms;
+                // This is required for images to be loaded by Visual Studio on-demand
+                image.CacheOption = BitmapCacheOption.OnLoad;
+                image.EndInit();
+            }
+            Image = image as ImageSource;
+        }
+    }
+}