XML Editor Control

///---------------------------------------------------------------------------
/// File Name:      XmlEditor.cs
/// Description:    Editor that does Xml formatting and syntax highlighting.
/// 
/// Author:         Ali Badereddin, Joseph Tignor
/// Created:        26/12/2009 - Ali Badereddin
/// Modified:       06/04/2020 - Joseph Tignor
///---------------------------------------------------------------------------

#region Using Directives

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

#endregion

/// <summary>
/// Editor that does Xml formatting and syntax highlighting.
/// </summary>
public partial class XmlEditor : UserControl
{
    #region Instance Variables

    private static Color specialCharColor = Color.Blue;   //  Color for special characters
    private static Color escapeColor = Color.Orchid;      //  Color for escape sequences
    private static Color elementColor = Color.DarkRed;    //  Color for Xml elements
    private static Color attributeColor = Color.Red;      //  Color for Xml attributes
    private static Color valueColor = Color.DarkBlue;     //  Color for attribute values
    private static Color commentColor = Color.DarkGreen;  //  Color for Xml comments

    private bool allowXmlFormatting = true;               //  Whether to do Xml formatting when text changes

    private bool tokenizing;                              //  If the control is currently in the process of tokenizing the contents.

    #endregion

    #region Constructor

    /// <summary>
    /// Constructor
    /// </summary>
    public XmlEditor()
    {
        InitializeComponent();
    }

    #endregion

    #region Properties

    /// <summary>
    /// Set or get the text of the xml editor.
    /// </summary>
    public override string Text
    {
        set
        {
            xmlTextBox.Text = value;
        }
        get
        {
            return xmlTextBox.Text;
        }
    }

    /// <summary>
    /// Tells whether to format the editor's Xml or not.
    /// </summary>
    [Category("Behavior"),Description("Allow XML formatting of the editor contents.")]
    public bool AllowXmlFormatting
    {
        set
        {
            allowXmlFormatting = value;
        }
        get
        {
            return allowXmlFormatting;
        }
    }

    /// <summary>
    /// Whether to allow the user to change text.
    /// </summary>
    [Category("Behavior"), Description("Whether to allow the user to change text.")]
    public bool ReadOnly
    {
        set
        {
            this.xmlTextBox.ReadOnly = value;
        }
        get
        {
            return this.xmlTextBox.ReadOnly;
        }
    }

    #endregion

    #region UI Events
    
    /// <summary>
    /// Start the timer to format new XML changes.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void xmlTextBox_TextChanged(object sender, EventArgs e)
    {
        if (allowXmlFormatting && !tokenizing)
        {
            this.tokenizerTimer.Stop();
            this.tokenizerTimer.Start();
        }
    }

    /// <summary>
    /// Format new XML changes.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void tokenizerTimer_Tick(object sender, EventArgs e)
    {
        tokenizerTimer.Stop();

        tokenizing = true;
        FormatXml(this.xmlTextBox);
        tokenizing = false;
    }

    #endregion

    #region Methods

    /// <summary>
    /// Format Xml in the passed rich text box.
    /// </summary>
    /// <param name="xmlEditor"></param>
    public static void FormatXml(RichTextBox xmlEditor)
    {
        //  Stop redrawing
        RichTextDrawing.StopRedraw(xmlEditor);

        // Get first and last displayed character
        int start = xmlEditor.GetCharIndexFromPosition(new Point(0, 0));
        int end = xmlEditor.GetCharIndexFromPosition(new Point(xmlEditor.ClientSize.Width, xmlEditor.ClientSize.Height));

        // Save cursor position
        int cursor_position = xmlEditor.SelectionStart;
        int cursor_lenght = xmlEditor.SelectionLength;

        //  Tokenize the Xml string
        List<XmlToken> tokens = XmlTokenizer.Tokenize(xmlEditor.Text);
        foreach (XmlToken token in tokens)
        {
            xmlEditor.Select(token.Index, token.Text.Length);
            switch (token.Type)
            {
                case XmlTokenType.None:
                    xmlEditor.SelectionColor = xmlEditor.ForeColor;
                    break;
                case XmlTokenType.SpecialChar:
                    xmlEditor.SelectionColor = specialCharColor;
                    break;
                case XmlTokenType.Escape:
                    xmlEditor.SelectionColor = escapeColor;
                    break;
                case XmlTokenType.Element:
                    xmlEditor.SelectionColor = elementColor;
                    break;
                case XmlTokenType.Attribute:
                    xmlEditor.SelectionColor = attributeColor;
                    break;
                case XmlTokenType.Value:
                    xmlEditor.SelectionColor = valueColor;
                    break;
                case XmlTokenType.Comment:
                    xmlEditor.SelectionColor = commentColor;
                    break;
            }
        }

        // Scroll to the last character and then to the first + line width
        xmlEditor.SelectionLength = 0;
        xmlEditor.SelectionStart = end;
        xmlEditor.ScrollToCaret();
        xmlEditor.SelectionStart = start + xmlEditor.Lines[xmlEditor.GetLineFromCharIndex(start)].Length + 1;
        xmlEditor.ScrollToCaret();

        // Finally, set cursor to original position
        xmlEditor.SelectionStart = cursor_position;
        
        //  Resume redraw
        RichTextDrawing.RestoreRedraw(xmlEditor);
    }

    #endregion

}

#region Helper Class

/// <summary>
/// Helper class to change colors on a RichTextBox without flickering.
/// </summary>
public class RichTextDrawing
{
    private static int lastSelection;

    [DllImport("user32.dll")]
    public static extern bool LockWindowUpdate(IntPtr hWndLock);

    public static void StopRedraw(RichTextBox richTextBox)
    {
        LockWindowUpdate(richTextBox.Handle);

        //  Save the last location 
        lastSelection = richTextBox.SelectionStart;

        // Refresh colors
        richTextBox.SelectAll();
        richTextBox.SelectionColor = richTextBox.ForeColor;
    }

    public static void RestoreRedraw(RichTextBox richTextBox)
    {
        LockWindowUpdate(IntPtr.Zero);

        //  Restore selection and color state
        richTextBox.SelectionStart = lastSelection;
        richTextBox.SelectionLength = 0;
        richTextBox.SelectionColor = richTextBox.ForeColor;
    }
}

#endregion

private void xmlTextBox_KeyPress(object sender, KeyPressEventArgs e)
  {
    if (e.KeyChar == '>')
    {
      int s = this.xmlTextBox.SelectionStart;
      StringBuilder sb = new StringBuilder();
      if (s <= 1) return;
      while (s >= 1)
      {
        s--;
        char c = this.xmlTextBox.Text[s];
        if (c == '>') return;
        if (c == '<')
        {
          char[] arr = sb.ToString().ToCharArray();
          Array.Reverse(arr);
          string tag = new string(arr);
          this.xmlTextBox.Text = this.xmlTextBox.Text.Insert(s + tag.Length+1, string.Format("></{0}>", tag));
          this.xmlTextBox.SelectionStart = s + tag.Length + 2;
          e.Handled = true;
        }
        sb.Append(c);
      }
    }
  }