NumericTextBox.cs :  » GUI » TreeViewAdv » Aga » Controls » C# / CSharp Open Source

using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Globalization;


namespace Aga.Controls{
  /// <summary>
  /// Restricts the entry of characters to digits, the negative sign,
  /// the decimal point, and editing keystrokes (backspace).
  /// It does not handle the AltGr key so any keys that can be created in any
  /// combination with AltGr these are not filtered
  /// </summary>
  public class NumericTextBox : TextBox
  {
    private const int WM_PASTE = 0x302;
    private NumberStyles numberStyle = NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign;

    /// <summary>
    /// Restricts the entry of characters to digits, the negative sign,
    /// the decimal point, and editing keystrokes (backspace).
    /// It does not handle the AltGr key
    /// </summary>
    /// <param name="e"></param>
    protected override void OnKeyPress(KeyPressEventArgs e)
    {
      base.OnKeyPress(e);

      e.Handled = invalidNumeric(e.KeyChar);
    }


    /// <summary>
    /// Main method for verifying allowed keypresses.
    /// This does not catch cut paste copy ... operations.
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    private bool invalidNumeric(char key)
    {
      bool handled = false;

      NumberFormatInfo numberFormatInfo = CultureInfo.CurrentCulture.NumberFormat;
      string decimalSeparator = numberFormatInfo.NumberDecimalSeparator;
      string negativeSign = numberFormatInfo.NegativeSign;

      string keyString = key.ToString();

      if (Char.IsDigit(key))
      {
        // Digits are OK
      }
      else if (AllowDecimalSeparator && keyString.Equals(decimalSeparator))
      {
        if (Text.IndexOf(decimalSeparator) >= 0)
        {
          handled = true;
        }
      }
      else if (AllowNegativeSign && keyString.Equals(negativeSign))
      {
        if (Text.IndexOf(negativeSign) >= 0)
        {
          handled = true;
        }
      }
      else if (key == '\b')
      {
        // Backspace key is OK
      }
      else if ((ModifierKeys & (Keys.Control)) != 0)
      {
        // Let the edit control handle control and alt key combinations
      }
      else
      {
        // Swallow this invalid key and beep
        handled = true;
      }
      return handled;
    }


    /// <summary>
    /// Method invoked when Windows sends a message.
    /// </summary>
    /// <param name="m">Message from Windows.</param>
    /// <remarks>
    /// This is over-ridden so that the user can not use
    /// cut or paste operations to bypass the TextChanging event.
    /// This catches ContextMenu Paste, Shift+Insert, Ctrl+V,
    /// While it is generally frowned upon to override WndProc, no
    /// other simple mechanism was apparent to simultaneously and
    /// transparently intercept so many different operations.
    /// </remarks>
    protected override void WndProc(ref Message m)
    {
      // Switch to handle message...
      switch (m.Msg)
      {
        case WM_PASTE:
          {
            // Get clipboard object to paste
            IDataObject clipboardData = Clipboard.GetDataObject();

            // Get text from clipboard data
            string pasteText = (string)clipboardData.GetData(
                DataFormats.UnicodeText);

            // Get the number of characters to replace
            int selectionLength = SelectionLength;

            // If no replacement or insertion, we are done
            if (pasteText.Length == 0)
            {
              break;
            }
            else if (selectionLength != 0)
            {
              base.Text = base.Text.Remove(SelectionStart, selectionLength);
            }

            bool containsInvalidChars = false;
            foreach (char c in pasteText)
            {
              if (containsInvalidChars)
              {
                break;
              }
              else if (invalidNumeric(c))
              {
                containsInvalidChars = true;
              }
            }

            if (!containsInvalidChars)
            {
              base.Text = base.Text.Insert(SelectionStart, pasteText);
            }

            return;
          }

      }
      base.WndProc(ref m);
    }


    public int IntValue
    {
      get
      {
        int intValue;
        Int32.TryParse(this.Text, numberStyle, CultureInfo.CurrentCulture.NumberFormat, out intValue);
        return intValue;
      }
    }

    public decimal DecimalValue
    {
      get
      {
        decimal decimalValue;
        Decimal.TryParse(this.Text, numberStyle, CultureInfo.CurrentCulture.NumberFormat, out decimalValue);
        return decimalValue;
      }
    }


    private bool allowNegativeSign;
    [DefaultValue(true)]
    public bool AllowNegativeSign
    {
      get { return allowNegativeSign; }
      set { allowNegativeSign = value; }
    }

    private bool allowDecimalSeparator;
    [DefaultValue(true)]
    public bool AllowDecimalSeparator
    {
      get { return allowDecimalSeparator; }
      set { allowDecimalSeparator = value; }
    }

  }

}