Word AfterSave event?

    ''' This is the trappable Event we'll use. It allows 
    ''' us to do our checking in the background but handle 
    ''' the actual AfterSave Event in our Addin Thread. 

    Private Event WordDoc_AfterSave(ByVal Doc As Word.Document)


    ''' This WithEvents variable allows us to capture 
    ''' Events in DotNET from MS Word. This can't be done 
    ''' from the ADX WordApp Property! 
    ''' We're using this to trap the BeforeSave Event, 
    ''' since you can't have an AfterSave without a 
    ''' BeforeSave. 

    Private WithEvents MS_WordApp As Word.Application


    ''' Since checking is a process that we want to repeat 
    ''' as long as the Addin is running in Word, we need 
    ''' to treat it a little more specially than a standard 
    ''' background Thread. A Delegate does the trick. 

    Private Delegate Sub del_SaveCheck()


    ''' We need a usable object in memory to use our Delegate. 

    Private th_SaveCheck As del_SaveCheck


    ''' This is the special treatment I mentioned earlier - 
    ''' Every time the separate thread finishes, it needs 
    ''' to be started straight back up. The AsyncCallback 
    ''' allows us to do this. 

    Private th_SaveDone As AsyncCallback


    ''' We MAY have multiple documents open in MS Word at any 
    ''' given time, and because it AutoSaves there is always 
    ''' the possibility that one document will autosave at the 
    ''' exact same time as another, or at the same time as a 
    ''' user save occurs. 
    ''' We also have two threads here - the Addin Primary 
    ''' in the Foreground and our new Asynchronous Delegate 
    ''' in the background. We MUST NOT attempt to access 
    ''' this object in memory from more than 1 thread at a 
    ''' time! 
    ''' The Queue Class allows us to chain documents as they're 
    ''' saved, remove them as they're processed in the AfterSave 
    ''' Event, and also to instantiate a SyncLock for Thread 
    ''' Safety. 

    Private queue_Docs As New System.Collections.Queue


    ''' AddinModule.AddinStartupComplete is a good event 
    ''' to use for placing variable definitions since 
    ''' MS Word will be started, its default blank 
    ''' document will be created, and the Addin Module will 
    ''' be done initializing itself. 

    Private Sub AddinModule_AddinStartupComplete( _
    ByVal sender As System.Object, _
    ByVal e As System.EventArgs) _
    Handles MyBase.AddinStartupComplete

        'Me.WordApp is set as an ADX Property by default. 
        'We're just pushing that Property into our existing 
        'WithEvents variable so we can actually trap Events. 
        Me.MS_WordApp = Me.WordApp

        'AddHandler is how we redirect Events from WithEvents 
        'variables to subroutines. We're only concerned 
        ' with handling BEFORESAVE. 
        AddHandler Me.MS_WordApp.DocumentBeforeSave, _
        AddressOf MS_Wordapp_BeforeSave

        'Now we need to instantiate our Delegate and point it 
        'at our repeating codeblock to check for and fire 
        'the AfterSave Event. 
        th_SaveCheck = New del_SaveCheck( _
        AddressOf th_AfterSave)

        'We also need to instantiate our AsyncCallback and point it 
        'at the codeblock that fires every time our Delegate Thread 
        'finishes. 
        th_SaveDone = New System.AsyncCallback( _
        AddressOf th_AfterSaveDone)

        'Last, kick off the repeating background thread. 
        th_SaveCheck.BeginInvoke(th_SaveDone, th_SaveCheck)
    End Sub

    Private Sub MS_WordApp_BeforeSave( _
    ByVal Doc As Word.Document, _
    ByRef SaveUI As Boolean, _
    ByRef Cancel As Boolean)

        'SyncLock the Queue object to prevent thread collision. 
        SyncLock Me.queue_Docs
            'Check if the saving document is already queued. 
            If Not queue_Docs.Contains(Doc) Then
                'If it's not queued, queue it. 
                queue_Docs.Enqueue(Doc)
            End If
        End SyncLock
    End Sub


    ''' The th_AfterSave sub is our delegate target. 
    ''' This codeblock runs repeatedly in a backgrounded thread 
    ''' while the Addin is active. 

    Private Sub th_AfterSave()
        'Check to see if there are any documents in the queue. If not, 
        'save the headache and just keep checking. 
        If Me.queue_Docs.Count > 0 Then
            'SyncLock the queue object to prevent thread collision. 
            SyncLock Me.queue_Docs
                'Queue.Peek allows us to grab the next object in queue 
                'without removing it from queue... 
                Dim curDoc As Word.Document = queue_Docs.Peek
                'Try gets us around two major problems: 
                '1) That while a Save Dialog is up in MS Word, MS Word throws 
                ''' fatal exceptions back through the COM interface. 
                '2) That the ONLY way to precheck for this fatal exception is 
                ''' via Windows API calls, which with DotNET developments is 
                ''' about equivalent to feeding oats and barley to your 
                ''' automobile. 
                Try
                    If curDoc.Saved Then
                        'If MS Word didn't throw back our attempt to check the document.Saved 
                        'property, then no dialogs are open and we can work with the document. 
                        'So if we can work with it, if the document.Saved property is True, 
                        'then the user did not CANCEL the dialog (or did but the document ondisk 
                        'is still identical to the document in memory, so it doesn't matter). 
                        'So, we fire the AfterSave Event. 
                        RaiseEvent WordDoc_AfterSave(queue_Docs.Dequeue)
                    End If
                    curDoc = Nothing
                Catch ex As Exception
                    'CODE HERE IF YOU NEED TO CHECK FOR 
                    ' EXCEPTIONS BEYOND SIMPLY BYPASSING 
                    ' Word.Application BUSY Status. 
                    ' As previously noted, this Try block only exists 
                    ' to bypass fatal exceptions thrown when dialogs are 
                    ' open. I've thoroughly tested this code with 
                    ' multiple documents open in MS Word, with 
                    ' user-saving, auto-saving, click "save", 
                    ' click "save as", close unsaved document and save, 
                    ' and never had a problem - that doesn't mean a 
                    ' problem won't arise. Might be wise to include 
                    ' an event log entry here. 
                    th_SaveCheck.BeginInvoke(th_SaveDone, th_SaveCheck)
                End Try
            End SyncLock
        End If
    End Sub


    ''' The th_AfterSaveDone sub is the target of our AsyncCallback. 
    ''' It serves just one purpose: To restart the background thread 
    ''' when it terminates (finishes processing). 
    ''' Additional code can be added here if needed or desired - 
    ''' just make sure you add it BEFORE the BeginInvoke if you want 
    ''' it performed before it processes again, and be sure to SyncLock 
    ''' if you do any work with the Queue Object. 

    Private Sub th_AfterSaveDone(ByVal ar As System.IAsyncResult)
        th_SaveCheck.BeginInvoke(th_SaveDone, th_SaveCheck)
    End Sub


    ''' Last, the AfterSave EventHandler. 
    ''' The thread delegate fires this event at any time that: 
    ''' BeforeSave has fired, the application is accessible, 
    ''' and the document which BeforeSave fired for returns 
    ''' Document.Saved = True. 

    Private Sub Addin_AfterSave( _
    ByVal Doc As Word.Document) _
    Handles Me.WordDoc_AfterSave

        'Run your event code here. 
        'For this example, it's just a messagebox notifying 
        'that the event fired and providing the name of the document 
        'that was just saved. 

        MsgBox("Document: " & Doc.FullName & " AFTERSAVE Complete!")
    End Sub