DataGridViewComboBoxCell Class

Another issue I've encountered for my project is the need to have an editable DataGridViewComboBoxCell.  Almost all of the documentation I've found implied it couldn't be done.  I did find some documentation that said the job would be difficult.  What follows is my implementation.

Some caveats (there's always something):  I only needed the ability to add one item.  While I will put advice on how to do more than one, please realize that I haven't tried it, and I could be wrong.  Secondly, my data was not linked to a database table, but rather an object in memory.  This means my example will not account for the elephant-level subtleties of database reads and writes.  Finally, the code presented is in VB, although it can be easily transferred into VC#.

Everything followed the previous example, up until the handler for the DataGridView.RowsAdded handler.  In this handler, I now found the need to use a BindingSource object.

Private Sub CreateLink(sender As System.Object, _
            e As System.Windows.Forms.DataGridViewRowsAddedEventArgs) _
        Handles tbl.RowsAdded
    Dim sentIt As DataGridView = TryCast(sender, DataGridView)
    If Not (sentIt Is tblTop) Then
        Exit Sub
    End If

    Dim comboIt As DataGridViewComboBoxCell
    Dim bindIt As BindingSource

    For nRowsAdd As Integer = 0 To e.RowCount - 1
        If (e.RowIndex + nRowsAdd) >= m_listAllDates.Count Then
            m_listAllDates.Add(New SomeDateList())
        End If
        comboIt = CType(sentIt.Rows(e.RowIndex + nRowsAdd).Cells( _
            ENUM_COLS.RATE_COLUMN), DataGridViewComboBoxCell)
        bindIt = New BindingSource()
        bindIt.DataSource = m_listAllDates(e.RowIndex + nRowsAdd).listRate
        comboIt.DataSource = bindIt
    Next
End Sub

The BindingSource object allows for several new events to be thrown, but you are about to see them as unnecessary.  Also, note that the object m_listAllDates has a listRate field that I added, which is the same as the listDate field from the previous example (a List(Of String) object).  This list was initialized with 4 values: 3 constants that must appear each time the DataGridViewComboBoxCell is created (on every single row), and a fourth value, which is my "edit" value.  The edit value appears in the listRate object node zero (i.e. listRate(0) or listRate.Items(0)).

Next is to handle when the cell is edited.  To do so, you need to handle the DataGridView.EditingControlShowing event.  You will find the recommendation about creating an enumeration for your DataGridView columns to be helpful.

Private Sub PackageCurrentControl(sender As System.Object, _
            e As System.Windows.Forms.DataGridViewEditingControlShowingEventArgs) _
        Handles tblIt.EditingControlShowing
    Dim tblIt As DataGridView = CType(sender, DataGridView)
    Dim comboIt As ComboBox
    Dim textIt As TextBox
    Dim listMiniAmort As List(Of MiniAmortItem) = _
        m_listAllPayDates(tblIt.CurrentCell.RowIndex).listMiniAmort
    If tblIt Is tblPackage Then
        Select Case CType(tblIt.CurrentCell.ColumnIndex, TABLE_PKG_COLS)
            Case ENUM_COLS.RATE_COLUMN
                comboIt = CType(e.Control, ComboBox)


                RemoveHandler comboIt.KeyDown, AddressOf Me.HandleRateCell
                AddHandler comboIt.KeyDown, AddressOf Me.HandleRateCell
                RemoveHandler comboIt.KeyPress, AddressOf Me.IgnoreKeyPress
                AddHandler comboIt.KeyPress, AddressOf Me.IgnoreKeyPress
                RemoveHandler comboIt.KeyUp, AddressOf Me.IgnoreKeyUp
                AddHandler comboIt.KeyUp, AddressOf Me.IgnoreKeyUp
            Case Else
                textIt = TryCast(e.Control, TextBox)
                If Not (textIt Is Nothing) Then
                    RemoveHandler textIt.KeyDown, AddressOf Me.HandleDateCell
                    RemoveHandler textIt.KeyPress, AddressOf Me.IgnoreKeyPress
                    RemoveHandler textIt.KeyUp, AddressOf Me.IgnoreKeyUp
                Else
                    comboIt = TryCast(e.Control, ComboBox)
                    If Not (comboIt Is Nothing) Then 
                        RemoveHandler comboIt.KeyDown, AddressOf Me.HandleRateCell
                        RemoveHandler comboIt.KeyPress, AddressOf Me.IgnoreKeyPress
                        RemoveHandler comboIt.KeyUp, AddressOf Me.IgnoreKeyUp
                    End If
                End If
        End Select
    End If
End Sub

It is important to only handle the columns that you absolutely need to have edit control in this handler, and that you remove the handlers once you enter a column that isn't handled.  I've found that if you do not remove the handlers, they will "bleed" over into unintended columns of your DataGridView.  Another thing to note about the code above is the "Ignore..." methods.  Each of these methods are only one line: e.Handled = True.  I have found, when utilizing the EditingControlShowing event, that if you do not block the other two Key events, you will get your functionality AND the default functionality.  Of course, you should use the event that best describes when you want your changes to fire, but make certain to block the other two.  Also, when using implementing EditingControlShowing, you will need to remove ALL handlers for the events you follow every time.  It's acceptable to use RemoveHandler, even if that handler isn't attached, as no exception is thrown in this case.  It is necessary, however, as adding the same handler twice occassionally does throw an exception.  Also note in VC#, the notation for adding and removing an event handler uses the += and -= operators.

The handler we need to continue with the editable DataGridViewComboBoxCell are the HandleRateCell

Private Sub HandleRateCell(sender As Object, e As KeyEventArgs)
    Dim ecIt As DataGridViewComboBoxEditingControl = _
        CType(sender, DataGridViewComboBoxEditingControl)
    Dim nRow As Integer = tblTop.CurrentCell.RowIndex
    Dim keyIt As Char = e.KeyCode.ToString().Chars(1)
    Dim nIdx As Integer = ecIt.SelectedIndex

    ' Do some stuff, and track the value for nIdx in the actual global list.
    ' In this case, the list is m_AllDates(nRow).listRate(nIdx).
    ' Since the original binding source took from your global object, 
    ' you likely won't need to change nIdx

    Dim bindIt As BindingSource
    Dim colLate As DataGridViewComboBoxCell = _
        CType(tblPackage.Rows(nRow).Cells(TABLE_PKG_COLS.Late_Fee), DataGridViewComboBoxCell)

    bindIt = CType(colLate.DataSource, BindingSource)
    bindIt.ResetBindings(False)
    colLate.Value = m_listAllDates(nRow).listRate(nIdx)
    e.Handled = True
End Sub

How you track your data in this handler is based on your needs.  Once your data is completely tracked and stored in the global object, you now need to recall the BindingSource that you created in the DataGridView.RowAdded event handler.  Notice that you do NOT use the DataGridViewComboEditingControl object that was sent to this method, but rather the actual DataGridViewComboBoxCell that will be the final result.  The two lines before e.Handled=true are the calls that will allow your DataGridViewComboBoxCell to look at the DataSource for the values of the cell, and then set the visible value of the cell to the indexed item on your background object.

For myself, nIdx was always zero for the editing cell.  In the case of needing to add more than one cell, you should maintain a "dummy" cell, either at index 0 or at the end of the list where you will enter new items.  In the case of a dummy cell at index zero, you will need to add/insert into your background list at index 1, and insure that you use the corrected index at the end of the handler above.

The example here shows adding to the .DataSource property of the DataGridViewComboBoxCell, using a database query.  The trouble I had, and others may have, is that my data for the combo box isn't in a database, but rather computed on the fly somehow.  For myself, and the example I'm entering here, I needed a list of dates that were generated from a given date that was typed elsewhere in the table (that is, a DataGridView).

First, you need a list object of some type.  I ended up designing a small, private class object that associated the list of dates with another, larger object list that contained the dates I wanted.  The dates could have been used directly, except for some requirements my superiors had that caused me to massage the dates from the larger object.  Here is the object that contains the data for the DataGridViewComboBoxCell.  It is in Visual Basic, but should work for VC# as well.

Class SomeDateList
    Public listDate As List(Of String)
    Public listDateSrc As List(Of DateSrcItem)
    Public Sub New()
        listDate = New List(Of String)()
        listDateSrc = New List(Of DateSrcItem)
    End Sub

        
    ''' <summary>
    ''' populates the date list
    ''' </summary>
    ''' <param name="dateTop">the date that generates the date list</param>
    Public Sub MakeDateList(ByVal dateTop As Date)
        Dim nStop As Integer = listDateSrc.Count - 1
        listDate.Add(ForceTenCharDate(dateTop)) 'create a string in mm/dd/yyyy format
        For nALoop As Integer = 0 To nStop - 1
            listDate.Add(ForceTenCharDate(listDateSrc(nALoop).DatePropVal))
        Next
    End Sub
End Class

Note the "public" nature of the fields.  SomeDateList is a private class, created in the same form as the DataGridView that uses it.  However, it should be noted, based on the documented example above, that I could have used a function or property, making the fields private.  I believe the result would be the same.  While "bad" practice, public fields in this case were for my personal convenience.

Next, I created a global access object for the form that contains the DataGridView of the type of object above, because I want each row in the DataGridView (each of which uses a DataGridViewComboBoxCell) to contain a different list of dates.  The larger list was instantiated in the form's Load event handler.

Private Sub formIt_Load(ByVal sender As Object, _
    ByVal e As System.EventArgs) Handles Me.Load
    ' Did some stuff (sorry about the formatting)

m_listAllDates = New List(Of SomeDateList)()
    'Did more stuff
End Sub

Finally, (this is the part I couldn't find anywhere) I created a handler on the RowsAdded event for the DataGridView.  This is the location where I bind the DataGridViewComboBoxCell to my dynamic list.  Since my cells may contain a different list for each row, I need to know the row and insure the new object is available.

Private Sub CreateLink(sender As System.Object, _
            e As System.Windows.Forms.DataGridViewRowsAddedEventArgs) _
        Handles tblIt.RowsAdded
    Dim sentIt As DataGridView = TryCast(sender, DataGridView)
    If Not (sentIt Is tblIt) Then
        Exit Sub
    End If
    Dim comboIt As DataGridViewComboBoxCell
    For nRowsAdd As Integer = 0 To e.RowCount - 1
        m_listAllDates.Add(New SomeDateList())
        comboIt = CType(sentIt.Rows(e.RowIndex + nRowsAdd).Cells( _
            ENUM_COLS.DATE_COLUMN), DataGridViewComboBoxCell)
        comboIt.DataSource = m_listAllDates(e.RowIndex + nRowsAdd).listDate
    Next
End Sub

I use the recommendation from the example, and create an enumeration for my table's columns, giving easy access to the columns as needed.  Now, anytime the list of dates changes for some row, the dates automatically appear in the correct DataGridViewComboBoxCell.  I hope this helps.  All the best in all you do while staying true.