Minor Issue with Caret Placement after Outlining Collapse

SyntaxEditorEx editor = new SyntaxEditorEx();

// The PendingCommandChord event can be used to display a message in the status bar
// like Visual studio does.  Something like:
//   (Ctrl+K) was pressed. Waiting for the second key of the chord...
ex.PendingCommandChord += new PendingCommandChordEventHandler(editor_PendingCommandChord);

// The CommandChordTriggered event is used to process the command chord
// If the command chord isn't valid, a message can be displayed in the status bar
// like Visual studio does.  Something like:
//   The key combination (Ctrl+K, Esc) is not a command.
ex.CommandChordTriggered += new CommandChordEventHandler(editor_CommandChordTriggered);

using System.Windows.Forms;

public class SyntaxEditorEx : ActiproSoftware.SyntaxEditor.SyntaxEditor
{
    private Keys _firstCommandOfChord = Keys.None;

    public event PendingCommandChordEventHandler PendingCommandChord;
    public event CommandChordEventHandler CommandChordTriggered;

    public SyntaxEditorEx()
    {
    }

    private Keys FirstKeyOfCommandChord
    {
        get { return _firstCommandOfChord; }
        set { _firstCommandOfChord = value; }
    }

    public bool IsPendingCommandChord
    {
        get { return (_firstCommandOfChord != Keys.None); }
    }

    protected override void OnKeyTyping(ActiproSoftware.SyntaxEditor.KeyTypingEventArgs e)
    {
        bool modifiersOnly = false;
        switch (e.KeyData)
        {
            case Keys.Shift | Keys.ShiftKey:
            case Keys.Control | Keys.ControlKey:
            case Keys.Alt | Keys.Menu:
                modifiersOnly = true;
                break;
        }

        if (this.IsPendingCommandChord && !modifiersOnly)
        {
            Keys keys = e.KeyData;
            if (keys == Keys.None)  // Crap, we'll have to reconstruct the Keys from e.KeyChar
            {
                char c = e.KeyChar;
                char upper = Char.ToUpper(c);
                if (Char.IsLetter(c) && c == upper) // It's an upper-case letter
                    keys |= Keys.Shift;
                keys |= (Keys)(int)upper;
            }

            OnCommandChordTrigger(new CommandChordEventArgs(this.FirstKeyOfCommandChord, keys));
            e.Cancel = true;
            return;
        }

        switch (e.KeyData)
        {
            case Keys.Control | Keys.K:
            case Keys.Control | Keys.M:
                OnPendingCommandChord(new PendingCommandChordEventArgs(e.KeyData));
                e.Cancel = true;
                return;
        }

        base.OnKeyTyping(e);
    }

    protected virtual void OnPendingCommandChord(PendingCommandChordEventArgs e)
    {
        this.FirstKeyOfCommandChord = e.Key;

        if (PendingCommandChord != null)
            PendingCommandChord(this, e);
    }

    protected virtual void OnCommandChordTrigger(CommandChordEventArgs e)
    {
        this.FirstKeyOfCommandChord = Keys.None;

        if (CommandChordTriggered != null)
            CommandChordTriggered(this, e);

        if (e.Cancel)
            return;

        switch (e.FirstKey)
        {
            case Keys.Control | Keys.K:
                switch (e.SecondKey)
                {
                    case Keys.Control | Keys.K:
                        break;
                }
                break;
            case Keys.Control | Keys.M:
                break;
        }
    }
}

public delegate void PendingCommandChordEventHandler(object sender, PendingCommandChordEventArgs e);

public class PendingCommandChordEventArgs
{
    private Keys _key;

    public PendingCommandChordEventArgs(Keys key)
    {
        this.Key = key;
    }

    public Keys Key
    {
        get { return _key; }
        private set { _key = value; }
    }
}

public delegate void CommandChordEventHandler(object sender, CommandChordEventArgs e);

public class CommandChordEventArgs
{
    private Keys _firstKey;
    private Keys _secondKey;
    private bool _cancel;

    public CommandChordEventArgs(Keys firstKey, Keys secondKey)
    {
        this.FirstKey = firstKey;
        this.SecondKey = secondKey;
    }


    public Keys FirstKey
    {
        get { return _firstKey; }
        private set { _firstKey = value; }
    }

    public Keys SecondKey
    {
        get { return _secondKey; }
        private set { _secondKey = value; }
    }

    public bool Cancel
    {
        get { return _cancel; }
        set { _cancel = value; }
    }
}