Hi Paul,

It seems that your TimeEditorControl class is derived from the
MaskedTextBox class, right?

If so, you can set the Mask property of the TimeEditorControl to "00:00",
set the PromptChar property to '0' and set the TextMaskFormat property to
IncludePromptAndLiterals, so that the Text property of the
TimeEditorControl returns "04:00" if the user enters 4 and leaves the field.

There is another case, e.g. the user enters "56:34" in the
TimeEditorControl, which is not a valid time. So we should also validate
whether the value the user enters is a valid value of time.

As you have mentioned, there're two kinds of options to choose: preventing
the user from leaving the current cell with bad data or correcting the bad
data automatically.

BTW, from the OOP viewpoint, it would be better to valid the data in the
derived DataGridViewCell class level or in the custom editing control
level, rather than in the DataGridView level.

For the first option, we can do this easily in the DataGridView level, i.e.
handle the CellValidating event of the DataGridView. However, it's hard to
do this in the DataGridViewCell level, because DataGridViewCell class
doesn't expose such an event.

For the second option, we can handle the Leave event of the
TimeEditorControl and if the data is invalid, reset the value to the
default value.

The following is a sample for the second option:

class MyMaskedTextBox : MaskedTextBox,IDataGridViewEditingControl
   {
       DataGridView dataGridView;
       private bool valueChanged = false;
       int rowIndex;

       public MyMaskedTextBox()
       {
           this.TextMaskFormat = MaskFormat.IncludePromptAndLiterals;
           this.PromptChar = '0';
           this.Mask = "00:00";
           this.Leave += new EventHandler(MyMaskedTextBox_Leave);
       }

       void MyMaskedTextBox_Leave(object sender, EventArgs e)
       {
           if(!IsValidHHMM(this.Text))
           {
               this.Text = "00:00";
           }
       }
     
       private bool IsValidHHMM(string text)
       {
           DateTime result;
           bool canParse = DateTime.TryParse(text, out result);
           if (canParse)
               return true;
           else
               return false;
       }

       // Implements the
IDataGridViewEditingControl.EditingControlFormattedValue
       // property.
       public object EditingControlFormattedValue
       {
           get
           {              
               return this.Text;
           }
           set
           {
               String newValue = value as String;
               if (newValue != null)
               {
                   if (IsValidHHMM(newValue))
                   {
                       this.Text = newValue;
                   }
               }
           }
       }

       // Implements the
       // IDataGridViewEditingControl.GetEditingControlFormattedValue
method.
       public object GetEditingControlFormattedValue(
           DataGridViewDataErrorContexts context)
       {
           return EditingControlFormattedValue;
       }

       // Implements the
       // IDataGridViewEditingControl.ApplyCellStyleToEditingControl
method.
       public void ApplyCellStyleToEditingControl(
           DataGridViewCellStyle dataGridViewCellStyle)
       {
           this.Font = dataGridViewCellStyle.Font;
           this.ForeColor = dataGridViewCellStyle.ForeColor;
           this.BackColor = dataGridViewCellStyle.BackColor;
       }

       // Implements the
IDataGridViewEditingControl.EditingControlRowIndex
       // property.
       public int EditingControlRowIndex
       {
           get
           {
               return rowIndex;
           }
           set
           {
               rowIndex = value;
           }
       }

       // Implements the
IDataGridViewEditingControl.EditingControlWantsInputKey
       // method.
       public bool EditingControlWantsInputKey(
           Keys key, bool dataGridViewWantsInputKey)
       {
           // Let the DateTimePicker handle the keys listed.
           switch (key & Keys.KeyCode)
           {
               case Keys.Left:                
               case Keys.Right:
               case Keys.Home:
               case Keys.End:              
                   return true;
               default:
                   return false;
           }          
       }

       // Implements the
IDataGridViewEditingControl.PrepareEditingControlForEdit
       // method.
       public void PrepareEditingControlForEdit(bool selectAll)
       {
           // No preparation needs to be done.
       }

       // Implements the IDataGridViewEditingControl
       // .RepositionEditingControlOnValueChange property.
       public bool RepositionEditingControlOnValueChange
       {
           get
           {
               return false;
           }
       }

       // Implements the IDataGridViewEditingControl
       // .EditingControlDataGridView property.
       public DataGridView EditingControlDataGridView
       {
           get
           {
               return dataGridView;
           }
           set
           {
               dataGridView = value;
           }
       }

       // Implements the IDataGridViewEditingControl
       // .EditingControlValueChanged property.
       public bool EditingControlValueChanged
       {
           get
           {
               return valueChanged;
           }
           set
           {
               valueChanged = value;
           }
       }

       // Implements the IDataGridViewEditingControl
       // .EditingPanelCursor property.
       public Cursor EditingPanelCursor
       {
           get
           {
               return base.Cursor;
           }
       }

       protected override void OnTextChanged(EventArgs e)
       {
           // Notify the DataGridView that the contents of the cell
           // have changed.
           if (EditingControlDataGridView != null)
           {
               valueChanged = true;
               
this.EditingControlDataGridView.NotifyCurrentCellDirty(true);
               base.OnTextChanged(e);
           }
       }      
   }

   public class MaskedTextBoxColumn : DataGridViewColumn
   {
       public MaskedTextBoxColumn()
           : base(new MaskedTextBoxCell())
       {
       }

       public override DataGridViewCell CellTemplate
       {
           get
           {
               return base.CellTemplate;
           }
           set
           {
               // Ensure that the cell used for the template is a
CalendarCell.
               if (value != null &&
                   
!value.GetType().IsAssignableFrom(typeof(MaskedTextBoxCell)))
               {
                   throw new InvalidCastException("Must be a
MaskedTextBoxCell");
               }
               base.CellTemplate = value;
           }
       }
   }

   public class MaskedTextBoxCell : DataGridViewTextBoxCell
   {
     
       public MaskedTextBoxCell()
           : base()
       {          
               
       }
       
       public override void InitializeEditingControl(int rowIndex, object
           initialFormattedValue, DataGridViewCellStyle
dataGridViewCellStyle)
       {
           // Set the value of the editing control to the current cell
value.
           base.InitializeEditingControl(rowIndex, initialFormattedValue,
               dataGridViewCellStyle);
           MyMaskedTextBox ctl = DataGridView.EditingControl as
MyMaskedTextBox;
           if (this.Value != null)
           {
               ctl.Text = this.Value.ToString();
           }
       }

       public override Type EditType
       {
           get
           {
               // Return the type of the editing contol that CalendarCell
uses.
               return typeof(MyMaskedTextBox);
           }
       }

       public override Type ValueType
       {
           get
           {
               // Return the type of the value that CalendarCell contains.
               return typeof(string);
           }
       }

       public override object DefaultNewRowValue
       {
           get
           {
               // Use the current date and time as the default value.
               return "00:00";
           }
       }
   }

Hope this helps.
If you have any question, please feel free to let me know.

Sincerely,
Linda Liu
Microsoft Online Community Support

==================================================
Get notification to my posts through email? Please refer to
http://msdn.microsoft.com/subscriptions/managednewsgroups/default.aspx#notif
ications.

Note: The MSDN Managed Newsgroup support offering is for non-urgent issues
where an initial response from the community or a Microsoft Support
Engineer within 1 business day is acceptable. Please note that each follow
up response may take approximately 2 business days as the support
professional working with you may need further investigation to reach the
most efficient resolution. The offering is not appropriate for situations
that require urgent, real-time or phone-based interactions or complex
project analysis and dump analysis issues. Issues of this nature are best
handled working with a dedicated Microsoft Support Engineer by contacting
Microsoft Customer Support Services (CSS) at
http://msdn.microsoft.com/subscriptions/support/default.aspx.
==================================================

This posting is provided "AS IS" with no warranties, and confers no rights.