[clang-format-vs] Add Alternate format config and auto-format on Open

[gigadude]

Summary

This diff adds support for an alternate formatting style and auto-format on open. The intent is to make it easy to use a personal formatting style while working under a team-standard .clang-format.

New Format Options

• Style (Alternate): specifies an alternate formatting style.

Either Style can be specified as file:<path_to_clang-format>, which will select a formatting config file explicitly.

New Format On... Options

• Format On Open (Alternative): if true, the alternate style will be applied on file open. Note that the document dirty flag is forced clean when this happens, which can result in the in-editor version differing from the version saved to disk. Externally modified files will require a manual reinvokation when reloaded, for example.

• Format On Save: will re-run Format On Open (Alternative) after the save if it is set to true.

• Path Filter: a regex tested against the full file path to further refine which files are auto-formatted.

New menu commands

• Format Selection (Alternate): format the selection using Style (Alternate)
• Format Document (Alternate): format the current document using Style (Alternate)
• Format Open Documents: format currently opened documents using Style
• Format Open Documents (Alternate): format currently opened documents using Style (Alternate)

Example Setup

This examples allows you to view a personally preferred style in the editor while working under a
company-imposed formatting standard set by the repository-local .clang-format file:

Under Format On...:

• Format On Open (Alternate): True
• Format On Save: True

Under Format Options:

• Style: file
• Style (Alternate): file:c:\Users\me\my-format.clang-format

[gigadude]

• Fixed bugs when auto-formatting files on startup (wait for solution loading to complete)
• Added commands to format all opened files (useful for switching between debugging using the saved format and editing using the alternate format)
• Preserve dirty state but reformat unconditionally when running Format Opened Documents

tools/clang-format-vs/ClangFormat/ClangFormat.csproj

     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>Key.snk</AssemblyOriginatorKeyFile>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
     <FileUpgradeFlags>
     </FileUpgradeFlags>
     <UpgradeBackupLocation>

   <ItemGroup>
     <VSCTCompile Include="ClangFormat.vsct">
       <ResourceName>Menus.ctmenu</ResourceName>
+      <SubType>Designer</SubType>
     </VSCTCompile>
   </ItemGroup>
   <ItemGroup>
-    <None Include="Resources\Images_32bit.bmp" />
-  </ItemGroup>
-  <ItemGroup>
     <Content Include="clang-format.exe">
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
     <Content Include="license.txt">
       <IncludeInVSIX>true</IncludeInVSIX>
     </Content>
+    <Resource Include="Resources\Images_32bit.png" />
     <Content Include="Resources\Package.ico" />
   </ItemGroup>
   <ItemGroup>

   <PropertyGroup>
     <PreBuildEvent>if not exist $(ProjectDir)Key.snk ("$(FrameworkSDKDir)Bin\NETFX 4.6 Tools\sn.exe" -k $(ProjectDir)Key.snk)</PreBuildEvent>
   </PropertyGroup>
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <!-- 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">
   </Target>
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>
 No newline at end of file

tools/clang-format-vs/ClangFormat/ClangFormat.vsct

   <!--This header contains the command ids for the menus provided by the shell. -->
   <Extern href="vsshlids.h"/>
 
   
-
-
   <!--The Commands section is where we the commands, menus and menu groups are defined.
       This section uses a Guid to identify the package that provides the command defined inside it. -->
-  <Commands package="guidClangFormatPkg">
+  <Commands package="guidClangFormatSubmenu">
     <!-- Inside this section we have different sub-sections: one for the menus, another  
     for the menu groups, one for the buttons (the actual commands), one for the combos 
     and the last one for the bitmaps used. Each element is identified by a command id that  

          group as the part of a menu contained between two lines. The parent of a group 
          must be a menu. -->
     <Groups>
+      <Group guid="guidClangFormatCmdSet" id="clangFormatSubmenuGroup" />
+      <Group guid="guidClangFormatCmdSet" id="clangFormatCommandGroup" />
+    </Groups>
 
-      <Group guid="guidClangFormatCmdSet" id="MyMenuGroup" priority="0x0600">
-        <Parent guid="guidSHLMainMenu" id="IDM_VS_MENU_TOOLS"/>
-      </Group>
-      
-
+    <Menus>
+      <Menu guid="guidClangFormatCmdSet" id="clangFormatSubmenu" type="Menu">
+        <Strings>
+          <ButtonText>Clang Format</ButtonText>
+        </Strings>
+      </Menu>
+    </Menus>
 
-    </Groups>
-    
     <!--Buttons section. -->
     <!--This section defines the elements the user can interact with, like a menu command or a button 
         or combo box in a toolbar. -->

               <CommandFlag>DynamicVisibility</CommandFlag>
           If you do not want an image next to your command, remove the Icon node /> -->
 
-      <Button guid="guidClangFormatCmdSet" id="cmdidClangFormatSelection" priority="0x0100" type="Button">
-        <Parent guid="guidClangFormatCmdSet" id="MyMenuGroup" />
-        <Icon guid="guidImages" id="bmpPic1" />
+      <Button guid="guidClangFormatCmdSet" id="cmdidClangFormatDocument" type="Button">
+        <Icon guid="guidImages" id="bmpFmtDoc" />
         <Strings>
-          <ButtonText>Clang Format Selection</ButtonText>
+          <ButtonText>Format Document</ButtonText>
         </Strings>
       </Button>
 
-      <Button guid="guidClangFormatCmdSet" id="cmdidClangFormatDocument" priority="0x0101" type="Button">
-        <Parent guid="guidClangFormatCmdSet" id="MyMenuGroup" />
-        <Icon guid="guidImages" id="bmpPic2" />
+      <Button guid="guidClangFormatCmdSet" id="cmdidClangFormatSelection" type="Button">
+        <Icon guid="guidImages" id="bmpFmtSel" />
         <Strings>
-          <ButtonText>Clang Format Document</ButtonText>
+          <ButtonText>Format Selection</ButtonText>
+        </Strings>
+      </Button>
+
+      <Button guid="guidClangFormatCmdSet" id="cmdidClangAltFormatDocument" type="Button">
+        <Icon guid="guidImages" id="bmpAltFmtDoc" />
+        <Strings>
+          <ButtonText>Format Document (Alternate)</ButtonText>
+        </Strings>
+      </Button>
+
+      <Button guid="guidClangFormatCmdSet" id="cmdidClangAltFormatSelection" type="Button">
+        <Icon guid="guidImages" id="bmpAltFmtSel" />
+        <Strings>
+          <ButtonText>Format Selection (Alternate)</ButtonText>
         </Strings>
       </Button>
 

             bitmap strip containing the bitmaps and then there are the numeric ids of the elements used 
             inside a button definition. An important aspect of this declaration is that the element id 
             must be the actual index (1-based) of the bitmap inside the bitmap strip. -->
-      <Bitmap guid="guidImages" href="Resources\Images_32bit.bmp" usedList="bmpPic1, bmpPic2, bmpPicSearch, bmpPicX, bmpPicArrows"/>
-      
+      <Bitmap guid="guidImages" href="Resources\Images_32bit.png" usedList="bmpFmtDoc, bmpFmtSel, bmpAltFmtDoc, bmpAltFmtSel"/>
     </Bitmaps>
  
   </Commands>

   <KeyBindings>
     <KeyBinding guid="guidClangFormatCmdSet" id="cmdidClangFormatSelection" editor="guidTextEditor" key1="R" mod1="Control" key2="F" mod2="Control"/>
     <KeyBinding guid="guidClangFormatCmdSet" id="cmdidClangFormatDocument" editor="guidTextEditor" key1="R" mod1="Control" key2="D" mod2="Control"/>
+    <KeyBinding guid="guidClangFormatCmdSet" id="cmdidClangAltFormatSelection" editor="guidTextEditor" key1="R" mod1="Control" key2="F" mod2="Control Alt"/>
+    <KeyBinding guid="guidClangFormatCmdSet" id="cmdidClangAltFormatDocument" editor="guidTextEditor" key1="R" mod1="Control" key2="D" mod2="Control Alt"/>
   </KeyBindings>
 
 
+  <CommandPlacements>
+
+    <!-- Placement for groups and menus.
+           The parent of a group is a menu, context menu or toolbar.
+           The parent of a submenu is always a group
+           The priority sets the position of the group compared to the priority of other existing groups in the menu.
+           The order is: Toolbar or Menu > clangFormatSubmenuGroup > clangFormatSubmenu > MyGroupForCommands > Command1Id, Command2Id
+      -->
+    <CommandPlacement guid="guidClangFormatCmdSet" id="clangFormatSubmenuGroup" priority="0x0800">
+      <!-- The parent of the group will be the tools menu -->
+      <Parent guid="guidSHLMainMenu" id="IDM_VS_MENU_TOOLS"/>
+    </CommandPlacement>
+    <CommandPlacement guid="guidClangFormatCmdSet" id="clangFormatSubmenu" priority="0x0001">
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatSubmenuGroup"/>
+    </CommandPlacement>
+    <CommandPlacement guid="guidClangFormatCmdSet" id="clangFormatCommandGroup" priority="0x0001">
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatSubmenu"/>
+    </CommandPlacement>
+
+    <!-- Placement for commands.
+           The parent of a command is always a group, never a menu, context menu or toolbar.
+      -->
+    <CommandPlacement guid="guidClangFormatCmdSet" id="cmdidClangFormatSelection" priority="0x0001" >
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatCommandGroup"/>
+    </CommandPlacement>
+    <CommandPlacement guid="guidClangFormatCmdSet" id="cmdidClangFormatDocument" priority="0x0002" >
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatCommandGroup"/>
+    </CommandPlacement>
+    <CommandPlacement guid="guidClangFormatCmdSet" id="cmdidClangAltFormatSelection" priority="0x0003" >
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatCommandGroup"/>
+    </CommandPlacement>
+    <CommandPlacement guid="guidClangFormatCmdSet" id="cmdidClangAltFormatDocument" priority="0x0004" >
+      <Parent guid="guidClangFormatCmdSet" id="clangFormatCommandGroup"/>
+    </CommandPlacement>
+  </CommandPlacements>
+
 
   <Symbols>
     <!-- This is the package guid. -->
-    <GuidSymbol name="guidClangFormatPkg" value="{c5286038-25d3-4f65-83a8-51fa2df4a146}" />
-    
+    <GuidSymbol name="guidClangFormatSubmenu" value="{c5286038-25d3-4f65-83a8-51fa2df4a146}" />
       <!-- This is the guid used to group the menu commands together -->
     <GuidSymbol name="guidClangFormatCmdSet" value="{e39cbab1-0f96-4022-a2bc-da5a9db7eb78}">
 
-      <IDSymbol name="MyMenuGroup" value="0x1020" />
-      <IDSymbol name="cmdidClangFormatSelection" value="0x0100" />
-      <IDSymbol name="cmdidClangFormatDocument" value="0x0101" />
+      <IDSymbol name="clangFormatSubmenuGroup" value="0x1030" />
+      <IDSymbol name="clangFormatCommandGroup" value="0x1031" />
+      <IDSymbol name="clangFormatSubmenu" value="0x0100" />
+      <IDSymbol name="cmdidClangFormatSelection" value="0x0101" />
+      <IDSymbol name="cmdidClangFormatDocument" value="0x0102" />
+      <IDSymbol name="cmdidClangAltFormatSelection" value="0x0103" />
+      <IDSymbol name="cmdidClangAltFormatDocument" value="0x0104" />
     </GuidSymbol>
 
     <GuidSymbol name="guidTextEditor" value="{8B382828-6202-11d1-8870-0000F87579D2}" />
 
-
     <GuidSymbol name="guidImages" value="{6d53937b-9ae1-42e1-8849-d876dcdbad7b}" >
-      <IDSymbol name="bmpPic1" value="1" />
-      <IDSymbol name="bmpPic2" value="2" />
-      <IDSymbol name="bmpPicSearch" value="3" />
-      <IDSymbol name="bmpPicX" value="4" />
-      <IDSymbol name="bmpPicArrows" value="5" />
+      <IDSymbol name="bmpFmtDoc" value="1" />
+      <IDSymbol name="bmpFmtSel" value="2" />
+      <IDSymbol name="bmpAltFmtDoc" value="3" />
+      <IDSymbol name="bmpAltFmtSel" value="4" />
     </GuidSymbol>
   </Symbols>
 

tools/clang-format-vs/ClangFormat/ClangFormatPackage.cs

 using Microsoft.VisualStudio.Text.Editor;
 using System;
 using System.Collections;
+using System.Text.RegularExpressions;
 using System.ComponentModel;
 using System.ComponentModel.Design;
 using System.IO;

         private string fallbackStyle = "LLVM";
         private bool sortIncludes = false;
         private string style = "file";
+        private string altStyle = "file";
         private bool formatOnSave = false;
-        private string formatOnSaveFileExtensions =
+        private bool altFormatOnOpen = false;
+        private string formatOnFileExtensions =
             ".c;.cpp;.cxx;.cc;.tli;.tlh;.h;.hh;.hpp;.hxx;.hh;.inl" +
             ".java;.js;.ts;.m;.mm;.proto;.protodevel;.td";
+        private string formatOnPathFilter = "";
 
         public OptionPageGrid Clone()
         {

                      "  - Predefined styles ('LLVM', 'Google', 'Chromium', 'Mozilla', 'WebKit').\n" +
                      "  - 'file' to search for a YAML .clang-format or _clang-format\n" +
                      "    configuration file.\n" +
+                     "  - 'file:<path>' to explicitly specify the configuration file.\n" +
                      "  - A YAML configuration snippet.\n\n" +
                      "'File':\n" +
                      "  Searches for a .clang-format or _clang-format configuration file\n" +

             set { style = value; }
         }
 
+        [Category("Format Options")]
+        [DisplayName("Style (Alternate)")]
+        [Description("Alternate Coding style, supports same options as Style.\n")]
+        [TypeConverter(typeof(StyleConverter))]
+        public string AltStyle
+        {
+            get { return altStyle; }
+            set { altStyle = value; }
+        }
+
         public sealed class FilenameConverter : TypeConverter
         {
             public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

         [DisplayName("Assume Filename")]
         [Description("When reading from stdin, clang-format assumes this " +
                      "filename to look for a style config file (with 'file' style) " +
-                     "and to determine the language.")]
+                     "and to determine the language. Leave blank to use current document's name.")]
         [TypeConverter(typeof(FilenameConverter))]
         public string AssumeFilename
         {

         }
 
         [Category("Format Options")]
-        [DisplayName("Sort includes")]
-        [Description("Sort touched include lines.\n\n" +
+        [DisplayName("Sort Includes")]
+        [Description("Sort touched #include lines.\n\n" +
                      "See also: http://clang.llvm.org/docs/ClangFormat.html.")]
         public bool SortIncludes
         {

             set { sortIncludes = value; }
         }
 
-        [Category("Format On Save")]
-        [DisplayName("Enable")]
+        [Category("Format On...")]
+        [DisplayName("Format On Save")]
         [Description("Enable running clang-format when modified files are saved. " +
                      "Will only format if Style is found (ignores Fallback Style)."
             )]

             set { formatOnSave = value; }
         }
 
-        [Category("Format On Save")]
-        [DisplayName("File extensions")]
-        [Description("When formatting on save, clang-format will be applied only to " +
+        [Category("Format On...")]
+        [DisplayName("Format On Open (Alternate)")]
+        [Description("Enable running clang-format when files are opened. " +
+                     "Will only format if Style (Alternate) is found (ignores Fallback Style)."
+            )]
+        public bool AltFormatOnOpen
+        {
+            get { return altFormatOnOpen; }
+            set { altFormatOnOpen = value; }
+        }
+
+        [Category("Format On...")]
+        [DisplayName("File Extensions")]
+        [Description("When formatting on open/save, clang-format will be applied only to " +
                      "files with these extensions.")]
-        public string FormatOnSaveFileExtensions
+        public string FormatOnFileExtensions
+        {
+            get { return formatOnFileExtensions; }
+            set { formatOnFileExtensions = value; }
+        }
+
+        [Category("Format On...")]
+        [DisplayName("Path Filter")]
+        [Description("When formatting on open/save, clang-format will be applied only to " +
+                     "paths matching this regular expression.")]
+        public string FormatOnPathFilter
         {
-            get { return formatOnSaveFileExtensions; }
-            set { formatOnSaveFileExtensions = value; }
+            get { return formatOnPathFilter; }
+            set { formatOnPathFilter = value; }
         }
     }
 

     [InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400)]
     [ProvideMenuResource("Menus.ctmenu", 1)]
     [ProvideAutoLoad(UIContextGuids80.SolutionExists)] // Load package on solution load
-    [Guid(GuidList.guidClangFormatPkgString)]
+    [Guid(GuidList.guidClangFormatSubmenuString)]
     [ProvideOptionPage(typeof(OptionPageGrid), "LLVM/Clang", "ClangFormat", 0, 0, true)]
     public sealed class ClangFormatPackage : Package
     {

 
             _runningDocTableEventsDispatcher = new RunningDocTableEventsDispatcher(this);
             _runningDocTableEventsDispatcher.BeforeSave += OnBeforeSave;
+            _runningDocTableEventsDispatcher.BeforeShow += OnBeforeShow;
 
             var commandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
             if (commandService != null)

                     var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
                     commandService.AddCommand(menuItem);
                 }
+
+                {
+                    var menuCommandID = new CommandID(GuidList.guidClangFormatCmdSet, (int)PkgCmdIDList.cmdidClangAltFormatSelection);
+                    var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
+                    commandService.AddCommand(menuItem);
+                }
+
+                {
+                    var menuCommandID = new CommandID(GuidList.guidClangFormatCmdSet, (int)PkgCmdIDList.cmdidClangAltFormatDocument);
+                    var menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
+                    commandService.AddCommand(menuItem);
+                }
             }
         }
         #endregion

             return (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));
         }
 
+        OptionPageGrid GetAltUserOptions()
+        {
+            OptionPageGrid copy = GetUserOptions().Clone();
+            copy.Style = copy.AltStyle;
+            return copy;
+        }
+
         private void MenuItemCallback(object sender, EventArgs args)
         {
             var mc = sender as System.ComponentModel.Design.MenuCommand;

                 case (int)PkgCmdIDList.cmdidClangFormatDocument:
                     FormatDocument(GetUserOptions());
                     break;
+
+                case (int)PkgCmdIDList.cmdidClangAltFormatSelection:
+                    FormatSelection(GetAltUserOptions());
+                    break;
+
+                case (int)PkgCmdIDList.cmdidClangAltFormatDocument:
+                    FormatDocument(GetAltUserOptions());
+                    break;
             }
         }
 
-        private static bool FileHasExtension(string filePath, string fileExtensions)
+        private bool FileMatchesFilter(string filePath, string fileExtensions, string pathFilter)
         {
-            var extensions = fileExtensions.ToLower().Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
-            return extensions.Contains(Path.GetExtension(filePath).ToLower());
+            if (fileExtensions.Length > 0)
+            {
+                var extensions = fileExtensions.ToLower().Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+                if (!extensions.Contains(Path.GetExtension(filePath).ToLower()))
+                    return false;
+            }
+            if (pathFilter.Length > 0)
+            {
+                try
+                {
+                    Regex filter = new Regex(pathFilter);
+                    if (!filter.IsMatch(filePath))
+                        return false;
+                }
+                catch (Exception e)
+                {
+                    var uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
+                    var id = Guid.Empty;
+                    int result;
+                    uiShell.ShowMessageBox(
+                            0, ref id,
+                            "Error in path filter regex:",
+                            e.Message,
+                            string.Empty, 0,
+                            OLEMSGBUTTON.OLEMSGBUTTON_OK,
+                            OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
+                            OLEMSGICON.OLEMSGICON_INFO,
+                            0, out result);
+                    return false;
+                }
+            }
+            return true;
         }
 
         private void OnBeforeSave(object sender, Document document)

             if (!options.FormatOnSave)
                 return;
 
-            if (!FileHasExtension(document.FullName, options.FormatOnSaveFileExtensions))
+            if (!FileMatchesFilter(document.FullName, options.FormatOnFileExtensions, options.FormatOnPathFilter))
                 return;
 
             if (!Vsix.IsDocumentDirty(document))
                 return;
 
-            var optionsWithNoFallbackStyle = GetUserOptions().Clone();
+            var optionsWithNoFallbackStyle = options.Clone();
             optionsWithNoFallbackStyle.FallbackStyle = "none";
             FormatDocument(document, optionsWithNoFallbackStyle);
         }
 
+        private void OnBeforeShow(object sender, Document document)
+        {
+            var options = GetUserOptions();
+
+            if (!options.AltFormatOnOpen)
+                return;
+
+            if (!FileMatchesFilter(document.FullName, options.FormatOnFileExtensions, options.FormatOnPathFilter))
+                return;
+
+            bool wasDirty = Vsix.IsDocumentDirty(document);
+            DateTime lastModified = Vsix.LastContentModifiedTime(document);
+
+            var altOptionsWithNoFallbackStyle = options.Clone();
+            altOptionsWithNoFallbackStyle.Style = altOptionsWithNoFallbackStyle.AltStyle;
+            altOptionsWithNoFallbackStyle.FallbackStyle = "none";
+            FormatDocument(document, altOptionsWithNoFallbackStyle);
+
+            if (!wasDirty)
+            {
+                Vsix.CleanDocument(document, lastModified);
+            }
+        }
+
         /// <summary>
         /// Runs clang-format on the current selection
         /// </summary>

tools/clang-format-vs/ClangFormat/Guids.cs

 {
     static class GuidList
     {
-        public const string guidClangFormatPkgString = "c5286038-25d3-4f65-83a8-51fa2df4a146";
+        public const string guidClangFormatSubmenuString = "c5286038-25d3-4f65-83a8-51fa2df4a146";
         public const string guidClangFormatCmdSetString = "e39cbab1-0f96-4022-a2bc-da5a9db7eb78";
 
         public static readonly Guid guidClangFormatCmdSet = new Guid(guidClangFormatCmdSetString);

tools/clang-format-vs/ClangFormat/PkgCmdID.cs

 {
     static class PkgCmdIDList
     {
-        public const uint cmdidClangFormatSelection = 0x100;
-        public const uint cmdidClangFormatDocument = 0x101;
+        public const uint cmdidClangFormatSelection = 0x101;
+        public const uint cmdidClangFormatDocument = 0x102;
+        public const uint cmdidClangAltFormatSelection = 0x103;
+        public const uint cmdidClangAltFormatDocument = 0x104;
     };
 }
 No newline at end of file

tools/clang-format-vs/ClangFormat/RunningDocTableEventsDispatcher.cs

     {
         private RunningDocumentTable _runningDocumentTable;
         private DTE _dte;
+        private SolutionEvents _solutionEvents;
+        private bool _isClosing = false;
 
         public delegate void OnBeforeSaveHander(object sender, Document document);
         public event OnBeforeSaveHander BeforeSave;
 
+        public delegate void OnBeforeShowHander(object sender, Document document);
+        public event OnBeforeShowHander BeforeShow;
+
+        private void SolutionIsClosing()
+        {
+            _isClosing = true;
+        }
+
         public RunningDocTableEventsDispatcher(Package package)
         {
             _runningDocumentTable = new RunningDocumentTable(package);
             _runningDocumentTable.Advise(this);
             _dte = (DTE)Package.GetGlobalService(typeof(DTE));
+            _solutionEvents = _dte.Events.SolutionEvents;
+            _solutionEvents.BeforeClosing += SolutionIsClosing;
         }
 
         public int OnAfterAttributeChange(uint docCookie, uint grfAttribs)

             return VSConstants.S_OK;
         }
 
-        public int OnAfterSave(uint docCookie)
-        {
-            return VSConstants.S_OK;
-        }
-
         public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
         {
+            if (fFirstShow != 0)
+            {
+                if (BeforeShow != null)
+                {
+                    var document = FindDocumentByCookie(docCookie);
+                    if (document != null) // Not sure why this happens sometimes
+                    {
+                        BeforeShow(this, document);
+                    }
+                }
+            }
             return VSConstants.S_OK;
         }
 

                 var document = FindDocumentByCookie(docCookie);
                 if (document != null) // Not sure why this happens sometimes
                 {
-                    BeforeSave(this, FindDocumentByCookie(docCookie));
+                    BeforeSave(this, document);
+                }
+            }
+            return VSConstants.S_OK;
+        }
+
+        public int OnAfterSave(uint docCookie)
+        {
+            // If we're not closing the solution, re-run the open formatter
+            // (the idea is to always see your alt format if both format on open/save are enabled)
+            if (!_isClosing)
+            {
+                if (BeforeShow != null)
+                {
+                    var document = FindDocumentByCookie(docCookie);
+                    if (document != null) // Not sure why this happens sometimes
+                    {
+                        BeforeShow(this, document);
+                    }
                 }
             }
             return VSConstants.S_OK;

tools/clang-format-vs/ClangFormat/Vsix.cs

             return textDocument?.IsDirty == true;
         }
 
+        public static DateTime LastContentModifiedTime(Document document)
+        {
+            DateTime when = DateTime.MinValue;
+            var textView = GetDocumentView(document);
+            var textDocument = GetTextDocument(textView);
+            if (textDocument != null)
+            {
+                when = textDocument.LastContentModifiedTime;
+            }
+            return when;
+        }
+
+        public static void CleanDocument(Document document, DateTime lastContentModifiedTime)
+        {
+            var textView = GetDocumentView(document);
+            var textDocument = GetTextDocument(textView);
+            if (textDocument != null)
+            {
+                textDocument.UpdateDirtyState(false, lastContentModifiedTime);
+            }
+        }
+
         public static IWpfTextView GetDocumentView(Document document)
         {
             var textView = GetVsTextViewFrompPath(document.FullName);