Handy Type Editors. Universal Dropdown Editor

• Download demo project - 15.7 Kb
• Download source - 22.1 Kb

Introduction

In my previous article, Handy Type Editors. Filename Editor, I demonstrated the use of custom attributes for altering the way an editor works. Today, we'll go further and implement a type editor controlled by both attributes and members of an edited type. The purpose of the exercise is creating a dropdown editor suitable for most occasions. Instead of writing nearly the same code over and over again, breaking the main commandment of pragmatic programming (Thou shalt not duplicate thy code), it is sufficient to configure the class by adding one or two attributes.

Main Idea

As mentioned in the previous article, a dropdown editor is meant to display a control below the cell of the edited member. Our control will be a ListBox displaying contents of a collection in the class being edited. The target collection is specified by an attribute. We'll also provide a way to configure what member of an item is displayed, and how the value is determined.

Let's Code!

Prerequisites

We need to provide a way to load our collection to a ListBox. ListControl has a built-in DataSource property which allows binding of an IList implementing object. However, there is a lot of collections out there that do not implement IList. We don't want to miss these either. This is why we'll write a small utility function which loads a collection to a ListBox. It will also act as a type validator (that is, an exception will be thrown if the user passes an invalid property).

Public Shared Sub FillListBoxFromCollection(ByVal lb As ListBox, _
            ByVal coll As ICollection)
    ' prevent flickers and slow downs by entering the mass update mode
    lb.BeginUpdate()
    lb.Items.Clear()
    Dim item As Object
    For Each item in coll
        lb.Items.Add(item)
    Next
    lb.EndUpdate()
    lb.Invalidate()
End Sub

Essential Attributes

As mentioned earlier, custom attributes are used to configure the editor:

• SourceCollectionAttribute. It holds the name and the reference to the type member (or property, to be exact) which serves as a source of ListBox data. Implementation:
  VB

  <Description("Service attribute to point to the source collection."), _
          AttributeUsage(AttributeTargets.All)> _
  Public Class SourceCollectionAttribute
      Inherits Attribute
      Private srcCollName As String
  
      Public ReadOnly Property CollectionName() As String
          Get
              Return Me.srcCollName
          End Get
      End Property
  
      Public ReadOnly Property Collection(ByVal instance As Object) _
              As ICollection
          Get
              Dim pdc As PropertyDescriptorCollection = _
                      TypeDescriptor.GetProperties(instance)
              Dim pd As PropertyDescriptor
              For Each pd In pdc
                  If pd.Name = Me.srcCollName Then
                      Return pd.GetValue(instance)
                  End If
              Next
              Return Nothing
          End Get
      End Property
  
      Public Sub New(ByVal sourceCollectionPropertyName As String)
          Me.srcCollName = sourceCollectionPropertyName
      End Sub
  End Class
  

• ValueMemberAttribute. It holds the name of the listed items' type member which is assigned to the edited value. For the sake of simplicity, if the attribute is not used, the entire selected object is returned. Pay attention to GetValue and SelectByValue functions: we cannot use ListControl.SelectedValue since we're not binding the data through ListControl.DataSource. Implementation:
  VB

  <AttributeUsage(AttributeTargets.All)> _
  Public Class ValueMemberAttribute
      Inherits Attribute
      Private valMemb As String
  
      Public ReadOnly Property ValuePropertyName() As String
          Get
              Return Me.valMemb
          End Get
      End Property
  
      Public Sub SelectByValue(ByVal lb As ListBox, ByVal val As Object)
          lb.SelectedItem = Nothing
          Dim item As Object
          For Each item In lb.Items
              If Me.GetValue(item) = val Then
                  lb.SelectedItem = item
                  Exit Sub
              End If
          Next
      End Sub
  
      Public Function GetValue(ByVal obj As Object) As Object
          If Me.valMemb = String.Empty Then Return obj
          Dim pi As System.Reflection.PropertyInfo = _
            obj.GetType().GetProperty(Me.valMemb)
          If pi Is Nothing Then Return Nothing
          Return pi.GetValue(obj, Nothing)
      End Function
  
      Public Sub New(ByVal valueMemberPropertyName As String)
          Me.valMemb = valueMemberPropertyName
      End Sub
  End Class
  

• DisplayMemberAttribute. It holds the name of the listed items' type member which is used to display items in the list. If omitted, the item's ToString method is used. All we must do is assign the string to the DisplayMember property of the ListBox we created. Implementation:
  VB

  <AttributeUsage(AttributeTargets.All)> _
  Public Class DisplayMemberAttribute
      Inherits Attribute
      Private dispMemb As String
  
      Public ReadOnly Property DisplayPropertyName() As String
          Get
              Return Me.dispMemb
          End Get
      End Property
  
      Public Sub New(ByVal displayMemberPropertyName As String)
          Me.dispMemb = displayMemberPropertyName
      End Sub
  End Class
  

Implementing the Editor

Now, we're ready to implement the editor itself. We'll set the style to DropDown:

Public Overloads Overrides Function GetEditStyle(ByVal context As _
                ITypeDescriptorContext) As UITypeEditorEditStyle
    If Not context Is Nothing AndAlso Not context.Instance Is Nothing Then
        Return UITypeEditorEditStyle.DropDown
    End If
    Return UITypeEditorEditStyle.None
End Function

EditValue and small service functions:

Private edSvc As IWindowsFormsEditorService
Private valMemb As ValueMemberAttribute

<RefreshProperties(RefreshProperties.All)> _
Public Overloads Overrides Function EditValue( _
            ByVal context As ITypeDescriptorContext, _
            ByVal provider As System.IServiceProvider, _
            ByVal value As [Object]) As [Object]
    If context Is Nothing OrElse provider Is Nothing _
            OrElse context.Instance Is Nothing Then
        Return MyBase.EditValue(provider, value)
    End If
    Dim att As SourceCollectionAttribute = _
            context.PropertyDescriptor.Attributes( _
            GetType(SourceCollectionAttribute))
    If att Is Nothing Then
        ' nothing we can do here. Let the default editor handle it
        Return MyBase.EditValue(provider, value)
    End If
    Me.edSvc = provider.GetService(GetType(IWindowsFormsEditorService))
    If Me.edSvc Is Nothing Then
        ' nothing we can do here either
        Return MyBase.EditValue(provider, value)
    End If

    ' prepare the listbox
    Dim lst As New ListBox
    Me.PrepareListBox(lst, att, context)
    If Me.valMemb Is Nothing Then
        lst.SelectedItem = value
    Else
        Me.valMemb.SelectByValue(lst, value)
    End If
    Me.edSvc.DropDownControl(lst)

    ' we're back
    If lst.SelectedItem Is Nothing Then
        value = Nothing ' nothing selected - nothing to return
    ElseIf Me.valMemb Is Nothing Then
        value = lst.SelectedItem ' return the item itself
    Else ' return a field from the selected item
        value = Me.valMemb.GetValue(lst.SelectedItem)
    End If
    Return value
End Function

Private Sub PrepareListBox(ByVal lst As ListBox, _
            ByVal att As SourceCollectionAttribute, _
            ByVal context As ITypeDescriptorContext)
    lst.IntegralHeight = True ' resize to avoid partial items
    Dim coll As ICollection = att.Collection(context.Instance)
    If lst.ItemHeight > 0 Then
        If Not coll Is Nothing AndAlso _
            lst.Height / lst.ItemHeight < coll.Count Then
            ' try to keep the listbox small but sufficient
            Dim adjHei As Integer = coll.Count * lst.ItemHeight
            If adjHei > 200 Then adjHei = 200
            lst.Height = adjHei
        End If
    Else ' safeguard, although it shouldn't happen
        lst.Height = 200
    End If
    lst.Sorted = True ' present in alphabetical order
    FillListBoxFromCollection(lst, coll)
    Me.AssignValueMember(lst, context.PropertyDescriptor)
    Me.AssignDisplayMember(lst, context.PropertyDescriptor)
    ' attach event handler
    AddHandler lst.SelectedIndexChanged, AddressOf Me.handleSelection
End Sub

Private Sub AssignValueMember(ByVal lc As ListControl, _
            ByVal pd As PropertyDescriptor)
    Me.valMemb = pd.Attributes(GetType(ValueMemberAttribute))
    If Me.valMemb Is Nothing Then Return
    ' maybe one day it'll work by itself...
    lc.ValueMember = Me.valMemb.ValuePropertyName
End Sub

Private Sub AssignDisplayMember(ByVal lc As ListControl, _
            ByVal pd As PropertyDescriptor)
    Dim att As DisplayMemberAttribute = pd.Attributes( _
            GetType(DisplayMemberAttribute))
    If att Is Nothing Then Return
    lc.DisplayMember = att.DisplayPropertyName
End Sub

Private Sub handleSelection(ByVal sender As Object, ByVal e As EventArgs)
    If Me.edSvc Is Nothing Then Return
    Me.edSvc.CloseDropDown() ' simply return to the EditValue procedure
End Sub

Ready to go.

Using the code

To use the class, bind it to your property like this:

<Editor(GetType(UniversalDropdownEditor), GetType(UITypeEditor)), _
    SourceCollection("MyMethods"), _
    ValueMember("Name"), DisplayMember("Name")> _
Property SelectedMethodName() As String
' ...
<Browsable(False)> _
Property MyMethods() As System.Reflection.MethodInfo()

Note that if you have a special property created to serve as a source collection, you might want to conceal it by setting the Browsable attribute to False.

That's it. Enjoy!