Category: Office Development

/// <summary>
/// The deactivate event is called before the application exits.
/// We cannot determine when we exit or not (specifically), but anytime
/// this event fires, we locate the normal template and flip the flag
/// in order to prevent the dreaded "Normal needs to be saved" prompt.
/// </summary>
/// <param name="Doc"></param>
/// <param name="Wn"></param>
void Application_WindowDeactivate(Word.Document Doc, Word.Window Wn)
{
    try
    {
        object objectIndex = 0;
        // loop through all the loaded templates
        for (int idx = 1; idx <= Application.Templates.Count; idx++)
        {
            objectIndex = idx;
            Word.Template t = Application.Templates.get_Item(
                    ref objectIndex);
            // look for normal
            if (t.Name.ToLower().Contains("normal.dotm"))
            {
                // found it – set the flag and leave the loop
                t.Saved = true;
                break;
            }
        }
    }
    catch { } // something bad happened – but we will ignore it
}

// attach to the Window Deactivate event in Word
Application.WindowDeactivate += new Microsoft.Office.Interop.
        Word.ApplicationEvents4_WindowDeactivateEventHandler(
            Application_WindowDeactivate);

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Reflection;

public class UserActivityHook
{
    private static int hMouseHook;
    private delegate int HookProc(int nCode, int wParam, IntPtr lParam);
    private HookProc MouseHookProcedure;
    public delegate void MouseEventHandler(object sender, MouseEventArgs e);
    public event MouseEventHandler OnMouseActivity;

    #region mouse constants
    const int HC_ACTION = 0;
    const int WH_MOUSE_LL = 14;
    const uint WM_MOUSEMOVE = 0x200;
    const uint WM_LBUTTONDOWN = 0x201;
    const uint WM_LBUTTONUP = 0x202;
    const uint WM_LBUTTONDBLCLK = 0x203;
    const uint WM_RBUTTONDOWN = 0x204;
    const uint WM_RBUTTONUP = 0x205;
    const uint WM_RBUTTONDBLCLK = 0x206;
    const uint WM_MBUTTONDOWN = 0x207;
    const uint WM_MBUTTONUP = 0x208;
    const uint WM_MBUTTONDBLCLK = 0x209;
    const uint WM_MOUSEWHEEL = 0x20A;
    const uint WM_MOUSEHWHEEL = 0x20E;

    #endregion

    #region "DLL imports"
    // Methods
    [DllImport("user32.dll")]
    private static extern int CallNextHookEx(int idHook, int nCode,
                                           int wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    private static extern int SetWindowsHookEx(int idHook, HookProc lpfn,
                                        IntPtr hInstance, int threadId);

    [DllImport("user32.dll")]
    private static extern bool UnhookWindowsHookEx(int idHook);
    #endregion

    #region "Structures"
    [StructLayout(LayoutKind.Sequential)]
    public class MouseHookStruct
    {
        // Fields
        public int dwExtraInfo;
        public int hwnd;
        public POINT pt;
        public int wHitTestCode;
    }

    [StructLayout(LayoutKind.Sequential)]
    public class POINT
    {
        // Fields
        public int x;
        public int y;
    }
    #endregion

    /// <summary>
    /// Start hook upon initialization
    /// </summary>
    public UserActivityHook()
    {
        Start();
    }

    /// <summary>
    /// Remove the hook on close.
    /// </summary>
    ~UserActivityHook()
    {
        Stop();
    }

    /// <summary>
    /// Starts the hook for the mouse events
    /// </summary>
    private void Start()
    {
        try
        {
            if (hMouseHook == 0)
            {
                // setup a callback for the WinAPI to this thread
                // instance which is shared by Excel, therefore
                // we are hooking to the message pump for Excel
                // but specificaly looking for mouse events.
                // See the callback:
                //   MouseHookProc()
                //
                MouseHookProcedure = new HookProc(MouseHookProc);
                hMouseHook = SetWindowsHookEx(14, MouseHookProcedure, IntPtr.Zero, 0);
                // hook failed for some reason…
                if (hMouseHook == 0)
                {
                    this.Stop();
                    throw new Exception("SetWindowsHookEx failed.");
                }
            }
        }
        catch (Exception ex)
        {
            throw new Exception("SetWindowsHookEx failed: " + ex.ToString());
        }
    }

    /// <summary>
    /// Is called by Windows when a Mouse event occurs.
    /// This is the main hook procedure setup from the
    /// Start() function.
    /// </summary>
    /// <param name="nCode"></param>
    /// <param name="wParam"></param>
    /// <param name="lParam"></param>
    /// <returns></returns>
    public int MouseHookProc(int nCode, int wParam, IntPtr lParam)
    {
        try
        {
            // is there a code passed?
            // and is the caller hooked to our event
            if (nCode >= 0 && OnMouseActivity != null)
            {
                MouseButtons buttons1 = MouseButtons.None;
                // is it a mouse event
                if (wParam == WM_LBUTTONUP)
                {
                    buttons1 = MouseButtons.Left;
                }
                else if (wParam == WM_RBUTTONUP)
                {
                    buttons1 = MouseButtons.Right;
                }
                else
                {
                    buttons1 = MouseButtons.None;
                }

                // extract the mouse params/struct passed
                // from windows so we can invoke it
                int num1 = 1;
                MouseHookStruct struct1 =
                    (MouseHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseHookStruct));
                // cast into Mouse args and then invoke the event
                MouseEventArgs args1 = new MouseEventArgs(buttons1,
                                    num1, struct1.pt.x, struct1.pt.y, 0);
                OnMouseActivity.Invoke(this, args1);
            }
            return CallNextHookEx(hMouseHook, nCode, wParam, lParam);
        }
        catch
        {
            return 0; // fail silently here
        }
    }

    /// <summary>
    /// Turn off the hook.
    /// </summary>
    private void Stop()
    {
        try
        {
            bool flag = true;
            if (UserActivityHook.hMouseHook != 0)
            {
                // call API to unhook
                flag = UnhookWindowsHookEx(hMouseHook);
                hMouseHook = 0;
            }
            if (!flag)
            {
                throw new Exception("UnhookWindowsHookEx failed.");
            }
        }
        catch { } // ignore on fail
    }
}

void hook_OnMouseActivity(object sender, System.Windows.Forms.MouseEventArgs e)
{
    try
    {
        if (e.Button == MouseButtons.Left)
        {
            object sel = Application.ActiveWindow.Selection;
            // we must pInvoke Excel to get the name property
            // from the selection since it is not exposed in
            // the PIA's…
            object Name = sel.GetType().InvokeMember("Name",
                    BindingFlags.GetProperty, null, sel, null);
            // cheap way to see if it is a textbox…
            if (Name.ToString().ToLower().Contains("text"))
            {
                MessageBox.Show("Got it: " + Name.ToString());
            }
        }
    }
    catch { }
}

public class WordSaveHandler
{
    public delegate void AfterSaveDelegate(Word.Document doc, bool isClosed);
    // public events
    public event AfterSaveDelegate AfterUiSaveEvent;
    public event AfterSaveDelegate AfterAutoSaveEvent;
    public event AfterSaveDelegate AfterSaveEvent;

    // module level
    private bool preserveBackgroundSave;
    private Word.Application oWord;

    /// <summary>
    /// CONSTRUCTOR – takes the Word application object to link to.
    /// </summary>
    /// <param name="oApp"></param>
    public WordSaveHandler(Word.Application oApp)
    {
        oWord = oApp;
        // hook to before save
        oApp.DocumentBeforeSave += new
            Word.ApplicationEvents4_DocumentBeforeSaveEventHandler(
                        oApp_DocumentBeforeSave);
    }

    /// <summary>
    /// WORD EVENT – fires before a save event.
    /// </summary>
    /// <param name="Doc"></param>
    /// <param name="SaveAsUI"></param>
    /// <param name="Cancel"></param>
    void oApp_DocumentBeforeSave(Word.Document Doc,
                                 ref bool SaveAsUI, ref bool Cancel)
    {
        // This could mean one of four things:
        // 1) we have the user clicking the save button
        // 2) Another add-in or process firing a resular Document.Save()
        // 3) A Save As from the user so the dialog came up
        // 4) Or an Auto-Save event…
        // so, we will start off by first:
        // 1) Grabbing the current background save flag. We want to force
        //    the save into the background so that Word will behave
        //    asyncronously. Typically, this feature is on by default,
        //    but we do not want to make any assumptions or this code
        //    will fail.
        // 2) Next, we fire off a thread that will keep checking the
        //    BackgroundSaveStatus of Word. And when that flag is OFF
        //    no know we are AFTER the save event…
        preserveBackgroundSave = oWord.Options.BackgroundSave;
        oWord.Options.BackgroundSave = true;
        // kick off a thread and pass in the document object
        bool UiSave = SaveAsUI; // have to do this because the bool from Word
                                // is passed to us as ByRef…
        ThreadStart starter = delegate {
                Handle_WaitForAfterSave(Doc, UiSave); };
        new Thread(starter).Start();
    }

    /// <summary>
    /// This method is the thread call that waits for the same to compelte.
    /// The way we detect the After Save event is to essentially enter into
    /// a loop where we keep checking the background save status. If the
    /// status changes we know the save is compelte and we finish up by
    /// determineing which type of save it was:
    /// 1) UI
    /// 2) Regular
    /// 3) AutoSave
    /// </summary>
    /// <param name="Doc"></param>
    /// <param name="UiSave"></param>
    private void Handle_WaitForAfterSave(Word.Document Doc, bool UiSave)
    {
        try
        {
            // we have a UI save, so we need to get stuck
            // here until the user gets rid of the SaveAs dialog
            if (UiSave)
            {
                while (isBusy(Doc))
                    Thread.Sleep(1);
            }

            // check to see if still saving in the background
            // we will hang here until this changes.
            while (oWord.BackgroundSavingStatus > 0)
                Thread.Sleep(1);
        }
        catch
        {
            oWord.Options.BackgroundSave = preserveBackgroundSave;
            return; // swallow the exception
        }

        try
        {
            // if it is a UI save, the Save As dialog was shown
            // so we fire the after ui save event
            if (UiSave)
            {
                // we need to check to see if the document is
                // saved, because of the user clicked cancel
                // we do not want to fire this event
                try
                {
                    if (Doc.Saved == true)
                        AfterUiSaveEvent(Doc, false);
                }
                catch
                {
                    // DOC is null or invalid. This occurs because the doc
                    // was closed. So we return doc closed and null as the
                    // document…
                    AfterUiSaveEvent(null, true);
                }
            }
            else
            {
                // if the document is still dirty
                // then we know an AutoSave happened
                try
                {
                    if (Doc.Saved == false)
                        AfterAutoSaveEvent(Doc, false); // fire autosave event
                    else
                        AfterSaveEvent(Doc, false); // fire regular save event
                }
                catch
                {
                    // DOC is closed
                    AfterSaveEvent(null, true);
                }
            }
        }
        catch {}
        finally
        {
            // reset and exit thread
            oWord.Options.BackgroundSave = preserveBackgroundSave;
        }
    }

    /// <summary>
    /// Determines if Word is busy – essentially that the File Save
    /// dialog is currently open
    /// </summary>
    /// <param name="oApp"></param>
    /// <returns></returns>
    private bool isBusy(Word.Document oDoc)
    {
        try
        {
            // if we try to access the application property while
            // Word has a dialog open, we will fail
            Word.Application oApp = oDoc.Application;
            return false; // not busy
        }
        catch
        {
            // so, Word is busy and we return true
            return true;
        }
    }
}

private void ThisAddIn_Startup(object sender,
                               System.EventArgs e)
{
    // attach the save handler
    WordSaveHandler wsh = new
        WordSaveHandler(Application);
    wsh.AfterAutoSaveEvent += new
        WordSaveHandler.AfterSaveDelegate(
            wsh_AfterAutoSaveEvent);
    wsh.AfterSaveEvent += new
        WordSaveHandler.AfterSaveDelegate(
            wsh_AfterSaveEvent);
    wsh.AfterUiSaveEvent += new
        WordSaveHandler.AfterSaveDelegate(
            wsh_AfterUiSaveEvent);
}

void wsh_AfterUiSaveEvent(Word.Document doc, bool isClosed)
{
    if (!isClosed)
        MessageBox.Show("After SaveAs Event");
    else
        MessageBox.Show("After Close and SaveAs Event");
}

void wsh_AfterSaveEvent(Word.Document doc, bool isClosed)
{
    if (!isClosed)
        MessageBox.Show("After Save Event");
    else
        MessageBox.Show("After Close and Save Event");
}

void wsh_AfterAutoSaveEvent(Word.Document doc, bool isClosed)
{
    MessageBox.Show("After AutoSave Event");
}