Notification on Redo events in Office 2010/2013

Office.CommandBarComboBox undoComboBox = null;
Office.CommandBarButton redoButton = null;
private void ReadUndoandRedo_OnClick(object sender, IRibbonControl control, bool pressed) {
    Office.CommandBars commandBars = ExcelApp.CommandBars;
    undoComboBox = commandBars.FindControl(Office.MsoControlType.msoControlSplitDropdown, 128, Type.Missing, false) as Office.CommandBarComboBox;
    if (undoComboBox != null) {
        int count = 0;
        try {
            count = undoComboBox.ListCount;
        } catch { }
        System.Diagnostics.Debug.WriteLine("!!! printing undoComboBox. ListCount=" + count.ToString());

        for (int i = 1; i <= count; i++) {
            System.Diagnostics.Debug.WriteLine("!!! " + i.ToString() + ". " + undoComboBox.get_List(i));
        }
    } else {
        System.Diagnostics.Debug.WriteLine("!!! undoComboBox is null");
    }
    redoButton = commandBars.FindControl(Office.MsoControlType.msoControlButton, 37, Type.Missing, false) as Office.CommandBarButton;
    if (redoButton != null) {
        System.Diagnostics.Debug.WriteLine("!!! redoControl != null. Enabled=" + redoButton.Enabled.ToString() + ". Text=" + redoButton.Caption );
    } else {
        System.Diagnostics.Debug.WriteLine("!!! redoControl is null");
    }
    Marshal.ReleaseComObject(commandBars);
}

HiddenWindow hiddenWindow = null;
private void ConnectClipboardEvents() {
    if (hiddenWindow != null)
        hiddenWindow.Dispose();
    hiddenWindow = new HiddenWindow("hidden window caption", this);
    // the HiddenWindow handles clipboard events. When the clipboard changes, the ClipboardChanged method is called (see below)
}

private void DisconnectClipboardEvents() {
    if (hiddenWindow != null) {
        hiddenWindow.Dispose();
    }
    if (wasRedoDisabled) EnableRedo(true);
}

/// <summary>
/// Called by the HiddenWindow class when the clipboard changes
/// </summary>
public void ClipboardChanged() {
    EnableRedo(false);
}

bool wasRedoDisabled = false;
private void EnableRedo(bool newState) {
    wasRedoDisabled = !newState;
    adxRibbonCommandRedo.Enabled = newState;

    // optionaly disable the CommandBar-style version of Redo
    Office.CommandBars commandBars = ExcelApp.CommandBars;
    redoButton = commandBars.FindControl(Office.MsoControlType.msoControlButton, 37, Type.Missing, false) as Office.CommandBarButton;
    if (redoButton != null) {
        redoButton.Enabled = newState;
    } else {
        System.Diagnostics.Debug.WriteLine("!!! redoControl is null");
    }
    Marshal.ReleaseComObject(redoButton);
    Marshal.ReleaseComObject(commandBars);
}

/// <summary>
/// This class is based on code from https://web.archive.org/web/20131104125500/http://www.radsoftware.com.au/articles/clipboardmonitor.aspx.
/// </summary>
class HiddenWindow : System.Windows.Forms.NativeWindow, IDisposable {

    private bool disposed = false;
    private AddinExpress.MSO.ADXAddinModule module;
    public int resultValue = 0;

    /// <summary>
    /// allows ignoring the very first WM_DRAWCLIPBOARD; it looks like WM_DRAWCLIPBOARD occurs as soon as SetClipboardViewer is called
    /// </summary>
    private bool isReady = false;

    public HiddenWindow(string caption, AddinExpress.MSO.ADXAddinModule module) {
        this.module = module;
        CreateParams Params = new CreateParams();
        Params.Caption = caption;
        this.CreateHandle(Params);
        RegisterClipboardViewer();
        isReady = true;
    }

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing) {
        if (!this.disposed) {
            UnregisterClipboardViewer();
        }
        if (!this.disposed) {
            if (!this.Handle.Equals(IntPtr.Zero)) {
                this.DestroyHandle();
            }
        }
        disposed = true;
    }

    ~HiddenWindow() {
        Dispose(false);
    }

    IntPtr _clipboardViewerNext = IntPtr.Zero;

    private void RegisterClipboardViewer() {
        _clipboardViewerNext = User32.SetClipboardViewer(this.Handle);
        Debug.WriteLine("!!! HiddenWindow. Clipboard events connected");
    }

    /// <summary>
    /// Remove this form from the Clipboard Viewer list
    /// </summary>
    private void UnregisterClipboardViewer() {
        User32.ChangeClipboardChain(this.Handle, _clipboardViewerNext);
        Debug.WriteLine("!!! HiddenWindow. Clipboard events disconnected");
    }

    protected override void WndProc(ref Message m) {
        if (!isReady) {
            // Let the window process the messages that we are
            // not interested in
            //
            base.WndProc(ref m);
            return;
        }
        switch ((Msgs)m.Msg) {
            //
            // The WM_DRAWCLIPBOARD message is sent to the first window 
            // in the clipboard viewer chain when the content of the 
            // clipboard changes. This enables a clipboard viewer 
            // window to display the new content of the clipboard. 
            //
            case Msgs.WM_DRAWCLIPBOARD:
                Debug.WriteLine("!!! WindowProc DRAWCLIPBOARD: " + m.Msg, "WndProc");
                // notify the module
                _ExcelPanes.AddinModule.CurrentInstance.ClipboardChanged();
                //
                // Each window that receives the WM_DRAWCLIPBOARD message 
                // must call the SendMessage function to pass the message 
                // on to the next window in the clipboard viewer chain.
                //
                User32.SendMessage(_clipboardViewerNext, m.Msg, m.WParam, m.LParam);
                break;
            //
            // The WM_CHANGECBCHAIN message is sent to the first window 
            // in the clipboard viewer chain when a window is being 
            // removed from the chain. 
            //
            case Msgs.WM_CHANGECBCHAIN:
                Debug.WriteLine("!!! WM_CHANGECBCHAIN: lParam: " + m.LParam, "WndProc");
                // When a clipboard viewer window receives the WM_CHANGECBCHAIN message, 
                // it should call the SendMessage function to pass the message to the 
                // next window in the chain, unless the next window is the window 
                // being removed. In this case, the clipboard viewer should save 
                // the handle specified by the lParam parameter as the next window in the chain. 
                //
                // wParam is the Handle to the window being removed from 
                // the clipboard viewer chain 
                // lParam is the Handle to the next window in the chain 
                // following the window being removed. 
                if (m.WParam == _clipboardViewerNext) {
                    //
                    // If wParam is the next clipboard viewer then it
                    // is being removed so update pointer to the next
                    // window in the clipboard chain
                    //
                    _clipboardViewerNext = m.LParam;
                } else {
                    User32.SendMessage(_clipboardViewerNext, m.Msg, m.WParam, m.LParam);
                }
                break;
            default:
                //
                // Let the window process the messages that we are
                // not interested in
                //
                base.WndProc(ref m);
                break;
        }
    }
}