Determining if Excel is in Edit mode with Win32 Interop

Hello,
Firstly i want to thank you for the explanations and this tricky solution to enable the detection of Edit mode. As user "spcghst440" already commented, the edit done from formula bar is not detected, his addition to subclass the "Excel<" is working!
But if i open two workbooks under Excel 2016 (under same Excel instance), the detection is only working for the first workbook...

The latest versions of Excel, as of late 2017, get this error (based on the window finding code here)

Great article, I was able to get this to work in .NET 4.0. This solution depends on the private internal implementation details of Excel - how did you figure this out? For example,

C#

Win32.FindWindowEx(workbookContainer,
                                      IntPtr.Zero,
                                      "EXCEL6", String.Empty);

How did you know the class name would be "EXCEL6"? Is this actually documented somewhere?

Thank you for your positive words.

No, this is not documented anywhere, it is really just windowing experience.
I already did some simlar hacks for an Ms Word addin as well, I thought I can repeat this technique for Excel addins.

I am happy about you could build this in your program.

There is another edit mode case.

Open Excel => switch to worksheet2 => click F2 on cell B2 => => type in '=' => switch to worksheet1 => click cell A1

When selecting cells on worksheet 1, the Excel6 window is not visible, but it's still on Edit mode.

Hmm. Indeed this is a hard case and seems to be a limitation.

Anyway thanks for sharing your experience with me.

"XLMAIN"/"EXCEL<" child window can also be checked, please see my reply to engstrocity user. His post was also useful.

I know this is an old post but I wanted to say thanks. This is a huge help.

If you're still around, I do have a question -- this solution only seems to work if the user has the option "Allow editing directly in cells" enabled (Excel Options -> Advanced -> Editing Options). Do you know of any way to work around this requirement? Some functionality of the addin I'm creating requires that this option be disabled. I can't seem to find anything.

Also, I think that anyone using VS & Office 2010 may want to comment out the line:

this.Application = (Excel.Application)Microsoft.Office.Tools.Excel.ExcelLocale1033Proxy.Wrap(typeof(Excel.Application), this.Application);

from ThisAddIn_Startup. The addin works fine without it and I kept getting a reference conflict (Microsoft.Excel.Tools.Common vs ...Common.v9.0)

Thanks again.

Thank you for the very useful note especially for the Direct edit in Cell problem.
What you can do is to hook on the function editor window as a workaround:
"XLMAIN"/"EXCEL<"
the same logic how we checked the "Excel6" window the "Excel<" is the class id of the function editor.
WM_SETFOCUS and KILLFOCUS event could be observed for a desired result.

ExcelEditorModeEventPublisher can be prepared for both the observation styles (based on Excel6 and Excel<).

Viktor, I am trying to implement exactly what you suggested here to no avail. Can you provide some sample code? I tried modifying your code like so:

C#

IntPtr workbookContainer = Win32.FindWindowEx(new IntPtr(excelApp.Hwnd), IntPtr.Zero, "XLDESK", String.Empty);

// check if the search was positive
if (workbookContainer != IntPtr.Zero)
{   // continue with finding the editor window
    IntPtr editorWindow = Win32.FindWindowEx(workbookContainer, IntPtr.Zero, "EXCEL6", String.Empty);

    // subclass it if the search was successful
    if (editorWindow != IntPtr.Zero)
    {
        InitObservation(editorWindow);
        return;
    }
    else
    {
        //they have "Allow editing directly in cells" turned off.
        editorWindow = Win32.FindWindowEx(workbookContainer, IntPtr.Zero, "Excel<", String.Empty);
        if (editorWindow != IntPtr.Zero)
        {
            InitObservation(editorWindow);
            return;
        }
    }
}

However, this does not work as the Excel 6 handle always comes back. Also, I do not see any windows under Excel with the handle "Excel<" using Spy++.

Got it working. Here is the updated code if anyone else is interested:

Notes: the "EXCEL<" window never goes disabled/enabled. So I had to attach to different messages, and test for the option EditDirectlyInCell being true or not for binding to the handle and for testing the windows state.

C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;


namespace ExcelUtil
{


    /// <summary>
    /// Viktor Hamori 09/04/2009 - This class represents the EditMode status of Excel
    /// with safe subclassing the Excel cell editor window 
    /// http://www.codeproject.com/Articles/35398/Determining-if-Excel-is-in-Edit-mode-with-Win32-In
    /// </summary>
    public class ExcelEditorModeEventPublisher : NativeWindow, IDisposable
    {
        private bool _EditDirectlyInCell = false;

        private class Win32
        {
            public enum WM
            {
                WM_WINDOWPOSCHANGED = 0x0047,
                WM_STYLECHANGED = 0x007D,
                WM_SETFOCUS = 0x0007,
                WM_KILLFOCUS = 0x0008
            }

            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            static public extern IntPtr FindWindowEx(IntPtr hWnd, IntPtr hChild, string strClassName, string strName);
            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            static public extern bool IsWindowVisible(IntPtr hWnd);
            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            static public extern bool IsWindowEnabled(IntPtr hWnd);
        }

        #region Declaration
        // disposing ...
        private object _lock = new object();
        private volatile bool _isDisposed = false;
        // editor window status
        private bool _isEditorWindowActive = false;

        // event declarations
        protected event EventHandler _editModeOn;
        protected event EventHandler _editModeOff;
        #endregion

        #region Constructor and Destructor
        /// <summary>
        /// Constructor accepting the editor window
        /// </summary>
        /// <param name="editorWindow"></param>
        internal ExcelEditorModeEventPublisher(IntPtr editorWindow)
        {
            if (editorWindow == IntPtr.Zero)
                return;
            InitObservation(editorWindow);
        }
        /// <summary>
        /// Constructor for finding the Editor Window in Excel window hierarchy
        /// </summary>
        /// <param name="excelApp"></param>
        internal ExcelEditorModeEventPublisher(Microsoft.Office.Interop.Excel.Application excelApp)
        {

            if (excelApp == null)
                throw new ArgumentNullException("excelApp");

            IntPtr editorWindow = IntPtr.Zero;
            _EditDirectlyInCell = excelApp.EditDirectlyInCell;
            if (!_EditDirectlyInCell)
            {
                editorWindow = Win32.FindWindowEx(new IntPtr(excelApp.Hwnd), IntPtr.Zero, "EXCEL<", String.Empty); //FindEditorHandle(excelApp.Hwnd, "XLMAIN", "EXCEL<");
                if (editorWindow != IntPtr.Zero)
                {
                    InitObservation(editorWindow);
                    return;
                }
            }
            else
            {
                editorWindow = FindEditorHandle(excelApp.Hwnd, "XLDESK", "EXCEL6");
                if (editorWindow != IntPtr.Zero)
                {
                    InitObservation(editorWindow);
                    return;
                }
            }


            throw new Exception("Unfortunatelly, Excel editor window cannot be detected!");
        }

        private IntPtr FindEditorHandle(int excelAppHwnd, string mainWindowName, string editorWindow)
        {
            IntPtr workbookContainer = Win32.FindWindowEx(new IntPtr(excelAppHwnd), IntPtr.Zero, mainWindowName, String.Empty);
            IntPtr editWindow = IntPtr.Zero;

            // check if the search was positive
            if (workbookContainer != IntPtr.Zero)
            {   // continue with finding the editor window
                editWindow = Win32.FindWindowEx(workbookContainer, IntPtr.Zero, editorWindow, String.Empty);
            }
            return editWindow;
        }
        /// <summary>
        /// Init the observer mechanism.
        /// </summary>
        private void InitObservation(IntPtr editorWindow)
        {
            AssignHandle(editorWindow);
            CheckWindowState();
        }
        /// <summary>
        /// Releasing the window in the destructor
        /// </summary>
        ~ExcelEditorModeEventPublisher()
        {
            Disposing();
        }
        /// <summary>
        /// The real dispose method
        /// </summary>
        protected void Disposing()
        {
            lock (_lock)
            {
                if (!_isDisposed)
                {
                    ReleaseHandle();
                    _isDisposed = true;
                }
            }
        }
        #region IDisposable Members
        /// <summary>
        /// Explicit clear up
        /// </summary>
        public void Dispose()
        {
            Disposing();
            GC.SuppressFinalize(this);
        }
        #endregion

        #endregion

        #region Window Procedure
        /// <summary>
        /// We have to observe the window changes (visibility, enabled state)
        /// </summary>
        /// <param name="m"></param>
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                // win32 message if style of the targetwindow has changed by any Win32 API call
                // WS_VISIBLE flag or any other
                case (int)Win32.WM.WM_STYLECHANGED:
                    CheckWindowState();
                    break;
                // win32 message if position of the targetwindow has changed by SetWindowPos API call
                // SWP_SHOWWINDOW for instance
                case (int)Win32.WM.WM_WINDOWPOSCHANGED:
                    CheckWindowState();
                    break;
                case (int)Win32.WM.WM_SETFOCUS:
                    CheckWindowState(true);
                    break;
                case (int)Win32.WM.WM_KILLFOCUS:
                    CheckWindowState(false);
                    break;
            }
            base.WndProc(ref m);
        }
        #endregion

        #region Event handling
        /// <summary>
        /// Run the style/pos change checker ..
        /// <param name="isEnabled">This parameter only takes effect if _EditDirectlyInCell is true for the excel application.</param>
        /// </summary>
        private void CheckWindowState(bool isEnabled = false)
        {
            try
            {
                // check if the window now visible andalso enabled
                if (!_EditDirectlyInCell & isEnabled)
                {
                    if (!_isEditorWindowActive)
                    {   // change the state and raise event
                        _isEditorWindowActive = true;
                        OnRaiseSafetyEvent(_editModeOn, new object[] { this, EventArgs.Empty });
                    }
                }
                else if (!_EditDirectlyInCell & !isEnabled)
                {
                    if (_isEditorWindowActive)
                    {   // change the state and raise event
                        _isEditorWindowActive = false;
                        OnRaiseSafetyEvent(_editModeOff, new object[] { this, EventArgs.Empty });
                    }
                }
                else if (Win32.IsWindowVisible(this.Handle) && Win32.IsWindowEnabled(this.Handle))
                {
                    if (!_isEditorWindowActive)
                    {   // change the state and raise event
                        _isEditorWindowActive = true;
                        OnRaiseSafetyEvent(_editModeOn, new object[] { this, EventArgs.Empty });
                    }
                }
                // check if the mode has changed back to non-edit mode
                else
                {
                    if (_isEditorWindowActive)
                    {   // change the state and raise event
                        _isEditorWindowActive = false;
                        OnRaiseSafetyEvent(_editModeOff, new object[] { this, EventArgs.Empty });
                    }
                }
            }
            catch (Exception ex)
            {
                //really do not want the events crashing these messages
                Console.WriteLine("Eating exception: : " + ex.ToString());
            }
        }
        /// <summary>
        /// Protect the Excel message mechanism against client code!
        /// </summary>
        /// <param name="eventHandler"></param>
        /// <param name="args"></param>
        protected static void OnRaiseSafetyEvent(Delegate eventHandler, object[] args)
        {
            if (eventHandler == null)
                return;
            Delegate[] delegates = eventHandler.GetInvocationList();
            if (delegates != null)
            {
                foreach (Delegate del in delegates)
                {
                    try { del.DynamicInvoke(args); }
                    catch { }
                }
            }
        }
        /// <summary>
        /// Edit mode switched on event accessor
        /// </summary>
        public event EventHandler EditModeOn
        {
            add
            {
                _editModeOn += value;
            }
            remove
            {
                _editModeOn -= value;
            }
        }

        /// <summary>
        /// Edit mode switched on event accessor
        /// </summary>
        public event EventHandler EditModeOff
        {
            add
            {
                _editModeOff += value;
            }
            remove
            {
                _editModeOff -= value;
            }
        }


        #endregion

        #region Properties
        /// <summary>
        /// Property reflecting editor mode state
        /// </summary>
        public bool IsExcelInEditMode
        {
            get
            {
                return _isEditorWindowActive;
            }
        }
        #endregion
    }
}

Made a mistake in the code I pasted. Used a single & in the CheckWindowState method. Needs to be &&.

Determining if Excel is in Edit mode with Win32 Interop

Introduction

Background

Using the Code

History

License

Comments and Discussions