ValidatingTextBox-Steuerelement

using System;
using System.ComponentModel;
using System.Drawing;
using System.Globalization;
using System.Media;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Unclassified.UI
{
    public class ValidatingTextBoxEventArgs : EventArgs
    {
        string text = "";
        bool accept = true;

        /// <summary>
        /// Gets the text that should be validated or sets a new text to be inserted into the input field.
        /// </summary>
        public string Text
        {
            get
            {
                return text;
            }
            set
            {
                text = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the new text should be accepted.
        /// </summary>
        public bool Accept
        {
            get
            {
                return accept;
            }
            set
            {
                accept = value;
            }
        }

        public ValidatingTextBoxEventArgs(string text)
        {
            this.text = text;
        }
    }

    public enum ValidatingTextBoxType
    {
        /// <summary>
        /// No restriction on the text
        /// </summary>
        Default = 0,
        /// <summary>
        /// Only numeric text is allowed (digits from 0 to 9 only)
        /// </summary>
        Numeric,
        /// <summary>
        /// The list of valid characters is regarded, if not empty
        /// </summary>
        ValidCharacters,
        /// <summary>
        /// The regular expression is regarded, if not empty
        /// </summary>
        RegularExpression,
        /// <summary>
        /// The <code>ValidateText</code> event is fired to delegate the text validation
        /// </summary>
        Custom
    }
   
    public class ValidatingTextBox : TextBox
    {
        private string prevText = "";
        private int prevSelStart = 0;
        private int prevSelLen = 0;
        private ValidatingTextBoxType type = ValidatingTextBoxType.Default;
        private string validCharacters = "";
        private string regexString = "";
        private Regex regex = null;
        private string finalRegexString = "";
        private Regex finalRegex = null;
        private bool requireInput = false;
        private bool trimOnLeaving = false;
        private ToolTip errorNoticeTooltip = null;
        private string expectedFormatDescription = "";
        private bool deferFinalCheck = false;
        private bool autoHeight = false;

        /// <summary>
        /// Validate the new text before it is applied. Only used if Type is <code>Custom</code>.
        /// </summary>
        [Category("Behavior")]
        [Description("Validate the new text before it is applied. Only used if Type is Custom.")]
        public event EventHandler<ValidatingTextBoxEventArgs> ValidateText;

        /// <summary>
        /// Validate the new text before the focus leaves.
        /// </summary>
        [Category("Behavior")]
        [Description("Validate the new text before the focus leaves.")]
        public event EventHandler<ValidatingTextBoxEventArgs> FinalValidateText;

        /// <summary>
        /// Standard type of text input to be accepted
        /// </summary>
        [Category("Behavior")]
        [Description("Standard type of text input to be accepted")]
        [DefaultValue(ValidatingTextBoxType.Default)]
        public ValidatingTextBoxType Type
        {
            get
            {
                return type;
            }
            set
            {
                type = value;
            }
        }

        /// <summary>
        /// Characters to be accepted
        /// </summary>
        [Category("Behavior")]
        [Description("Characters to be accepted")]
        [DefaultValue("")]
        public string ValidCharacters
        {
            get
            {
                return validCharacters;
            }
            set
            {
                validCharacters = value;
            }
        }

        /// <summary>
        /// Regex pattern to be accepted
        /// </summary>
        [Category("Behavior")]
        [Description("Regex to be accepted")]
        [DefaultValue("")]
        public string RegularExpression
        {
            get
            {
                return regexString;
            }
            set
            {
                if (!string.IsNullOrEmpty(value))
                    regex = new Regex(value);
                else
                    regex = null;
                regexString = value;
            }
        }

        /// <summary>
        /// Regex pattern to be matched when leaving the focus
        /// </summary>
        [Category("Behavior")]
        [Description("Regex pattern to be matched when leaving the focus")]
        [DefaultValue("")]
        public string FinalRegularExpression
        {
            get
            {
                return finalRegexString;
            }
            set
            {
                if (!string.IsNullOrEmpty(value))
                    finalRegex = new Regex(value);
                else
                    finalRegex = null;
                finalRegexString = value;
            }
        }

        /// <summary>
        /// Require input. Checked as part of the final check.
        /// </summary>
        [Category("Behavior")]
        [Description("Require input. Checked as part of the final check.")]
        [DefaultValue(false)]
        public bool RequireInput
        {
            get
            {
                return requireInput;
            }
            set
            {
                requireInput = value;
            }
        }

        /// <summary>
        /// Trim the text when leaving the focus
        /// </summary>
        [Category("Behavior")]
        [Description("Trim the text when leaving the focus")]
        [DefaultValue(false)]
        public bool TrimOnLeaving
        {
            get
            {
                return trimOnLeaving;
            }
            set
            {
                trimOnLeaving = value;
            }
        }

        /// <summary>
        /// Description of the expected format to be displayed to the user
        /// </summary>
        [Category("Behavior")]
        [Description("Description of the expected format to be displayed to the user")]
        [DefaultValue("")]
        public string ExpectedFormatDescription
        {
            get
            {
                return expectedFormatDescription;
            }
            set
            {
                expectedFormatDescription = value;
            }
        }

        /// <summary>
        /// Defer the final checks. They will only be applied when the FinalCheck method is invoked.
        /// </summary>
        [Category("Behavior")]
        [Description("Defer the final checks. They will only be applied when the FinalCheck method is invoked.")]
        [DefaultValue(false)]
        public bool DeferFinalCheck
        {
            get { return deferFinalCheck; }
            set { deferFinalCheck = value; }
        }

        /// <summary>
        /// Adjust the height of the control depending on its contents
        /// </summary>
        [Category("Layout")]
        [Description("Adjust the height of the control depending on its contents")]
        [DefaultValue(false)]
        public bool AutoHeight
        {
            get
            {
                return autoHeight;
            }
            set
            {
                autoHeight = value;
                UpdateAutoHeight();
            }
        }

        protected override void OnTextChanged(EventArgs e)
        {
            bool accept = true;

            HideErrorNotice();
            if (type == ValidatingTextBoxType.Numeric)
            {
                string valid = "0123456789";
                foreach (char c in Text.ToCharArray())
                {
                    if (valid.IndexOf(c) == -1)
                    {
                        accept = false;
                        break;
                    }
                }
            }
            else if (type == ValidatingTextBoxType.ValidCharacters && !string.IsNullOrEmpty(validCharacters))
            {
                foreach (char c in Text.ToCharArray())
                {
                    if (validCharacters.IndexOf(c) == -1)
                    {
                        accept = false;
                        break;
                    }
                }
            }
            else if (type == ValidatingTextBoxType.RegularExpression && regex != null)
            {
                accept = regex.IsMatch(Text);
            }
            else if (type == ValidatingTextBoxType.Custom && ValidateText != null)
            {
                ValidatingTextBoxEventArgs e2 = new ValidatingTextBoxEventArgs(Text);
                ValidateText(this, e2);
                accept = e2.Accept;
            }
           
            if (!accept)
            {
                SystemSounds.Beep.Play();
                Console.Beep(50, 10);
                Text = prevText;
                SelectionStart = prevSelStart;
                SelectionLength = prevSelLen;
                ShowErrorNotice();
            }
            else
            {
                prevText = Text;
            }
           
            base.OnTextChanged(e);

            UpdateAutoHeight();
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            // Add some comfort here
            if (e.KeyCode == Keys.Back && !e.Alt && e.Control && !e.Shift ||
                e.KeyCode == Keys.W && !e.Alt && e.Control && !e.Shift)
            {
                // Delete word to the left
                int sel = SelectionStart;
                if (sel > 0)
                {
                    int pos = Text.Substring(0, sel - 1).LastIndexOfAny(new char[] { ' ', '\t' });
                    //if (pos == -1) pos = 0;
                    pos++;
                    Text = Text.Substring(0, pos) + Text.Substring(sel);
                    SelectionStart = pos;
                }
                e.SuppressKeyPress = e.Handled = true;
            }
            if (e.KeyCode == Keys.U && !e.Alt && e.Control && !e.Shift)
            {
                // Delete all
                Text = "";
                e.SuppressKeyPress = e.Handled = true;
            }
            if (e.KeyCode == Keys.A && !e.Alt && e.Control && !e.Shift)
            {
                // Select all
                SelectionStart = 0;
                SelectionLength = Text.Length;
                e.SuppressKeyPress = e.Handled = true;
            }
            if (e.KeyCode == Keys.Up && !e.Alt && e.Control && !e.Shift && Multiline)
            {
                // Scroll line up
                SendMessage(Handle, EM_SCROLL, new IntPtr(SB_LINEUP), IntPtr.Zero);
                e.SuppressKeyPress = e.Handled = true;
            }
            if (e.KeyCode == Keys.Down && !e.Alt && e.Control && !e.Shift && Multiline)
            {
                // Scroll line down
                SendMessage(Handle, EM_SCROLL, new IntPtr(SB_LINEDOWN), IntPtr.Zero);
                e.SuppressKeyPress = e.Handled = true;
            }

            prevSelStart = SelectionStart;
            prevSelLen = SelectionLength;

            base.OnKeyDown(e);
        }

        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);

            prevSelStart = SelectionStart;
            prevSelLen = SelectionLength;
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            prevSelStart = SelectionStart;
            prevSelLen = SelectionLength;
           
            base.OnMouseDown(e);
        }

        protected override void OnLeave(EventArgs e)
        {
            if (trimOnLeaving)
            {
                Text = Text.Trim();
            }
           
            HideErrorNotice();
            if (!deferFinalCheck)
            {
                FinalCheck();
            }
           
            base.OnLeave(e);
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);

            UpdateAutoHeight();
        }

        /// <summary>
        /// Performs the deferred final checks. Shows the error message, plays the beep sound and focuses the control if errors were found.
        /// </summary>
        /// <returns>true if the check is successful, false if errors were found</returns>
        public bool FinalCheck()
        {
            bool accept = true;

            HideErrorNotice();
            if (accept && requireInput && Text.Length == 0)
            {
                accept = false;
            }
            if (accept && finalRegex != null)
            {
                accept = finalRegex.IsMatch(Text);
            }
            if (accept && FinalValidateText != null)
            {
                ValidatingTextBoxEventArgs e2 = new ValidatingTextBoxEventArgs(Text);
                FinalValidateText(this, e2);
                accept = e2.Accept;
                Text = e2.Text;
            }

            if (!accept)
            {
                ShowErrorNotice();
                SystemSounds.Beep.Play();
                Console.Beep(50, 10);
                Focus();
            }
            return accept;
        }

        protected void ShowErrorNotice()
        {
            string msg;
            switch (CultureInfo.CurrentUICulture.TwoLetterISOLanguageName)
            {
                case "de":
                    msg = "Die Eingabe hat ein ungültiges Format.";
                    if (!string.IsNullOrEmpty(expectedFormatDescription))
                        msg += "\r\nErwartet: " + expectedFormatDescription;
                    else if (Type == ValidatingTextBoxType.Numeric)
                        msg += "\r\nEs sind nur nummerische Eingaben (0-9) zulässig.";
                    if (requireInput)
                        msg += "\r\nEine Eingabe ist erforderlich.";
                    break;
                default:
                    msg = "The input format is invalid.";
                    if (!string.IsNullOrEmpty(expectedFormatDescription))
                        msg += "\r\nExpected: " + expectedFormatDescription;
                    else if (Type == ValidatingTextBoxType.Numeric)
                        msg += "\r\nOnly numeric values (0-9) are accepted.";
                    if (requireInput)
                        msg += "\r\nInput is required.";
                    break;
            }

            if (errorNoticeTooltip != null)
            {
                errorNoticeTooltip.Dispose();
            }
            errorNoticeTooltip = new ToolTip();
            errorNoticeTooltip.ForeColor = SystemColors.WindowText;
            errorNoticeTooltip.BackColor = MixedColor(SystemColors.Window, Color.Red, 0.25);
            errorNoticeTooltip.Show(msg, this, 0, Height, 10000);
        }

        protected void HideErrorNotice()
        {
            if (errorNoticeTooltip != null)
            {
                errorNoticeTooltip.Dispose();
            }
        }

        private void UpdateAutoHeight()
        {
            if (autoHeight && Multiline)
            {
                Size prefSize = GetPreferredSize(new Size(Width, 0));
                Height = prefSize.Height;
            }
        }

        #region Unclassified.WinApi
        [DllImport("user32")]
        private static extern IntPtr SendMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

        private const uint EM_SCROLL = 0xB5;
        private const uint SB_LINEUP = 0;
        private const uint SB_LINEDOWN = 1;
        #endregion

        #region Unclassified.Drawing.ColorMath
        private static Color MixedColor(Color color1, Color color2, double ratio)
        {
            int a = (int) Math.Round(color1.A * (1 - ratio) + color2.A * ratio);
            int r = (int) Math.Round(color1.R * (1 - ratio) + color2.R * ratio);
            int g = (int) Math.Round(color1.G * (1 - ratio) + color2.G * ratio);
            int b = (int) Math.Round(color1.B * (1 - ratio) + color2.B * ratio);
            return Color.FromArgb(a, r, g, b);
        }
        #endregion
    }
}