DataGridView扩展：NumericUpDown ，并显示比例

代码是自己写的，实现功能：NumericUpDown编辑单元格，显示值与最大值的比例

using  System;
using  System.Drawing;
using  System.Windows.Forms;

namespace  CuteDataView
{
     public   class  NumericUpDownColumn : DataGridViewColumn
    {
         public  NumericUpDownColumn():  base ( new  NumericUpDownCell())
        {
        }
         public  NumericUpDownColumn( decimal  max,  decimal  min,  decimal  increment, decimal  defaultValue, bool  showRect,Color rectColor)
            :  base ( new  NumericUpDownCell{Maximum = max,Minimum = min,DefaultValue = defaultValue,Increment = increment,RectColor = rectColor,ShowRect = showRect})
        {
        }

         public   decimal  Maximum {  get ;  set ; }
         public   decimal  Minimum {  get ;  set ; }
         public   decimal  Increment {  get ;  set ; }
         public   decimal  DefaultValue {  get ;  set ; }
         public   bool  ShowRect {  get ;  set ; }
         public  Color RectColor {  get ;  set ; }

         public   override  DataGridViewCell CellTemplate
        {
             get  {  return   base .CellTemplate; }
             set
            {
                 if  (value  !=   null   &&   ! value.GetType().IsAssignableFrom( typeof  (NumericUpDownCell)))
                {
                     throw   new  InvalidCastException( " Must   be   a   NumericUpDownCell  " );
                }
                 base .CellTemplate  =  value;
            }
        }
    }

     public   class  NumericUpDownCell : DataGridViewTextBoxCell
    {
         public   decimal  Maximum {  get ;  set ; }
         public   decimal  Minimum {  get ;  set ; }
         public   decimal  Increment {  get ;  set ; }
         public   decimal  DefaultValue {  get ;  set ; }
         public   bool  ShowRect {  get ;  set ; }
         public  Color RectColor {  get ;  set ; }

         public  NumericUpDownCell()
        {
            Maximum  =   decimal .MaxValue;
            Minimum  =   decimal .MinValue;
            Increment  =   1 ;
            DefaultValue  =   0 ;
            ShowRect  =   false ;
            RectColor  =  Color.FromArgb( 50 , Color.Magenta);
        }


         public   override  Type EditType
        {
             get  {  return   typeof  (NumericUpDownEditingControl); }
        }

         public   override  Type ValueType
        {
             get  {  return   typeof  ( string ); }
        }

         public   override   object  DefaultNewRowValue
        {
             get  {  return  DefaultValue; }
        }

         public   override   void  InitializeEditingControl( int  rowIndex,  object  initialFormattedValue,
                                                      DataGridViewCellStyle dataGridViewCellStyle)
        {
             base .InitializeEditingControl(rowIndex, initialFormattedValue, dataGridViewCellStyle);
            var ctl  =  DataGridView.EditingControl  as  NumericUpDownEditingControl;
             if  (ctl  !=   null )
            {
                ctl.Maximum  =  Maximum;
                ctl.Minimum  =  Minimum;
                ctl.Increment  =  Increment;
                ctl.Text  =  Value.ToString();
            }
        }

         protected   override   void  Paint(Graphics graphics, Rectangle clipBounds, Rectangle cellBounds,  int  rowIndex, DataGridViewElementStates cellState,  object  value,  object  formattedValue,  string  errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts)
        {
             base .Paint(graphics, clipBounds, cellBounds, rowIndex, cellState, value, formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);
                         if  (ShowRect)
            {
                graphics.FillRectangle( new  SolidBrush(RectColor), cellBounds.Left, cellBounds.Top, (cellBounds.Width  /  Convert.ToSingle(Maximum))  *  Convert.ToSingle(Value), cellBounds.Height  -   1 );
            }
        }


         public   override   object  Clone()
        {
             return   new  NumericUpDownCell
                       {
                           Maximum  =  Maximum,
                           Minimum  =  Minimum,
                           ShowRect  =  ShowRect,
                           RectColor  =  RectColor,
                           Increment  =  Increment,
                           DefaultValue  =  DefaultValue
                       };
        }

    }

     internal   class  NumericUpDownEditingControl : NumericUpDown, IDataGridViewEditingControl
    {
         #region  Implementation of IDataGridViewEditingControl

         private   bool  _editingControlValueChanged;

         ///   <summary>
         ///  Changes the control's user interface (UI) to be consistent with the specified cell style.
         ///   </summary>
         ///   <param name="dataGridViewCellStyle"> The  <see cref="T:System.Windows.Forms.DataGridViewCellStyle"/>  to use as the model for the UI.
         ///                   </param>
         public   void  ApplyCellStyleToEditingControl(DataGridViewCellStyle dataGridViewCellStyle)
        {
            Font  =  dataGridViewCellStyle.Font;
            ForeColor  =  dataGridViewCellStyle.ForeColor;
            BackColor  =  dataGridViewCellStyle.BackColor;
        }

         ///   <summary>
         ///  Determines whether the specified key is a regular input key that the editing control should process or a special key that the  <see cref="T:System.Windows.Forms.DataGridView"/>  should process.
         ///   </summary>
         ///   <returns>
         ///  true if the specified key is a regular input key that should be handled by the editing control; otherwise, false.
         ///   </returns>
         ///   <param name="keyData"> A  <see cref="T:System.Windows.Forms.Keys"/>  that represents the key that was pressed.
         ///                   </param><param name="dataGridViewWantsInputKey"> true when the  <see cref="T:System.Windows.Forms.DataGridView"/>  wants to process the  <see cref="T:System.Windows.Forms.Keys"/>  in  <paramref name="keyData"/> ; otherwise, false.
         ///                   </param>
         public   bool  EditingControlWantsInputKey(Keys keyData,  bool  dataGridViewWantsInputKey)
        {
             switch  (keyData  &  Keys.KeyCode)
            {
                 case  Keys.Left:
                 case  Keys.Up:
                 case  Keys.Down:
                 case  Keys.Right:
                 case  Keys.Home:
                 case  Keys.End:
                 case  Keys.PageDown:
                 case  Keys.PageUp:
                     return   true ;
                 default :
                     return   false ;
            }
        }

         ///   <summary>
         ///  Retrieves the formatted value of the cell.
         ///   </summary>
         ///   <returns>
         ///  An  <see cref="T:System.Object"/>  that represents the formatted version of the cell contents.
         ///   </returns>
         ///   <param name="context"> A bitwise combination of  <see cref="T:System.Windows.Forms.DataGridViewDataErrorContexts"/>  values that specifies the context in which the data is needed.
         ///                   </param>
         public   object  GetEditingControlFormattedValue(DataGridViewDataErrorContexts context)
        {
             return  EditingControlFormattedValue;
        }

         ///   <summary>
         ///  Prepares the currently selected cell for editing.
         ///   </summary>
         ///   <param name="selectAll"> true to select all of the cell's content; otherwise, false.
         ///                   </param>
         public   void  PrepareEditingControlForEdit( bool  selectAll)
        {
        }

         ///   <summary>
         ///  Gets or sets the  <see cref="T:System.Windows.Forms.DataGridView"/>  that contains the cell.
         ///   </summary>
         ///   <returns>
         ///  The  <see cref="T:System.Windows.Forms.DataGridView"/>  that contains the  <see cref="T:System.Windows.Forms.DataGridViewCell"/>  that is being edited; null if there is no associated  <see cref="T:System.Windows.Forms.DataGridView"/> .
         ///   </returns>
         public  DataGridView EditingControlDataGridView {  get ;  set ; }

         ///   <summary>
         ///  Gets or sets the formatted value of the cell being modified by the editor.
         ///   </summary>
         ///   <returns>
         ///  An  <see cref="T:System.Object"/>  that represents the formatted value of the cell.
         ///   </returns>
         public   object  EditingControlFormattedValue
        {
             get  {  return  Value.ToString(); }
             set  { Value  =   decimal .Parse(value.ToString()); }
        }

         ///   <summary>
         ///  Gets or sets the index of the hosting cell's parent row.
         ///   </summary>
         ///   <returns>
         ///  The index of the row that contains the cell, or –1 if there is no parent row.
         ///   </returns>
         public   int  EditingControlRowIndex {  get ;  set ; }

         ///   <summary>
         ///  Gets or sets a value indicating whether the value of the editing control differs from the value of the hosting cell.
         ///   </summary>
         ///   <returns>
         ///  true if the value of the control differs from the cell value; otherwise, false.
         ///   </returns>
         public   bool  EditingControlValueChanged
        {
             get  {  return  _editingControlValueChanged; }
             set  { _editingControlValueChanged  =  value; }
        }

         ///   <summary>
         ///  Gets the cursor used when the mouse pointer is over the  <see cref="P:System.Windows.Forms.DataGridView.EditingPanel"/>  but not over the editing control.
         ///   </summary>
         ///   <returns>
         ///  A  <see cref="T:System.Windows.Forms.Cursor"/>  that represents the mouse pointer used for the editing panel. 
         ///   </returns>
         public  Cursor EditingPanelCursor
        {
             get  {  return   base .Cursor; }
        }

         ///   <summary>
         ///  Gets or sets a value indicating whether the cell contents need to be repositioned whenever the value changes.
         ///   </summary>
         ///   <returns>
         ///  true if the contents need to be repositioned; otherwise, false.
         ///   </returns>
         public   bool  RepositionEditingControlOnValueChange
        {
             get  {  return   false ; }
        }

         #endregion

         protected   override   void  OnValueChanged(EventArgs eventargs)
        {
            _editingControlValueChanged  =   true ;
            EditingControlDataGridView.NotifyCurrentCellDirty( true );
             base .OnValueChanged(eventargs);
        }
    }
}