MCCB - Multi Column ComboBox - How to create a simple (UserControl) DLL

• Download source - 71.3 KB
• Download demo - 197.1 KB

First of all

CodeProject is for programmers of all levels. This article is intended only for beginners and VB programmers who have never built a DLL. For a more complex ComboBox, see my first article: ExCB - Extended Multi Column ComboBox

Introduction

The downloadable files contain complete projects, but I'll show the basic steps in creating this Control, one ComboBox able to permanently display one or more Columns (say 'field boxes', labeled or not) and a List for 'record' selection.

A DLL is often a Control, made up with other System.Windows.Form Controls, created by the user for a particular purpose, often flexible, parametrizable, and ready to execute several tasks.

Like any other Control, a UserControl has its own Properties, Methods and Events, some of them created by us.

When developing a DLL, it's good practice to have another simple WinForms project for testing the Control, both projects in a Solution, so we can deeply test and debug the Control's behavior.

Building the UserControl

1. Open Visual Studio, Start a New Project, choose Class Library and give it the Name MCCB, which will be the Project name, the Assembly name and the Root namespace - but VS gives you a VB Public Class Class1
2. Menu PROJECT, choose Add User Control and give it the Name MCCB, which will be the future Name of your Control - VS creates another Class and shows the template - a 150x150 square, more like a Panel than like a Form...

In this example, the goal is to create a ComboBox that expose permanently one or more columns, with labels. We create the first column, all others will be created at runtime. We also need a drop-down List and a Button for opening the List.

3. Resize the Control to appx. 200x200 and change its BackColor to any other (slight). At runtime, this color will be changed to Color.Control, but at design time we need a visual reference, when resizing the Control.
4. Lets start with the Label (Title/Header): Pick a Label from the Toolbox. Change the following properties: Name="Hdr0", AutoSize=False, BackColor=WhiteSmoke, BorderStyle=FixedSingle, Location=0;0, Size=100;19, Text="Hdr0", TextAlign=MiddleLeft
5. Now the Box to show the field value. Instead of a TextBox, we'll use a Label... is a lighter control, furthermore, values are not to be written or changed. Pick another Label and change the following properties: Name="Box0", AutoSize=False, BackColor=White, BorderStyle=FixedSingle, ForeColor=Navy, Location=0;18, Size=100;20, Text="Box0", TextAlign=MiddleLeft
6. Next, the List. Pick a ListView and change the properties: Name="MyLV", View=Details, BorderStyle=FixedSingle, FullRowSelect=True, GridLines=True, HeaderStyle=None, Location=0;37, MultiSelect=False, Size=119;138. Its a List with 8 Rows, without Header ... We'll also create the first Column: Add a Column and change the properties: Name="lvCol0", Text="", Width=97. Why 97? To perfectly align the lines, the ListView Column's Width must be the Width of the corresponding Label/Box minus 1, except the first Column, which must be minus 3...
7. Finally, the Button, which must show any kind of "down arrow". It can be a Button, a PictureBox, even a simple Label. Lets do it with a Label. Pick a Label and change properties: Name="LblDrop", AutoSize=False, BackColor=WhiteSmoke, BorderStyle=FixedSingle, Location=99;18, Size=20;20, Text="". In property Image - Local resource - Import: DArrow.png, located in folder .\Image

8. Everything is OK and aligned, right? But when the Control is to be placed on a Form, the List must be hidden... So, to prevent vertical resizing at design time, and because the actual height of Header+Box is 38, add this very first code, in the UserControl's Resize Event:

Private Sub MCCB_Resize(sender As Object, e As EventArgs) Handles Me.Resize
	Me.Height = 38
End Sub

9. Its time to create the project for testing and debugging the Control. Save the Project and start a New Project of the type Windows Forms Application, naming it as MCCB_Test - VS gives you a Form template (Form1). Save this 2nd project.
10. Add the UserControl project: Menu FILE - Add - Existing Project - Browse MCCB project and open MCCB.vbproj - A Solution 'MCCB_Test' is created, with both projects in Solution Explorer. Select MCCB project, Menu BUILD - Build MCCB. Open the Toolbox and look at the top ... The Control MCCB is already there. Double-click it - the Control is placed in the Form, with the Name Mccb1. Resize it - as you can see, only horizontal resizing is allowed. Start the Solution - Great, the Control is there!!! Now you can manage both projects. Insert a piece of code, Menu BUILD - Rebuild MCCB, if necessary check or change Control Properties in Form1, define breakpoint(s) for Debug porposes, if needed, and Start the Solution. Easy.

We're about to create a set of Properties. Usually, Properties must be Public and specify its Data Type. Custom Properties values can be viewed and changed, like any other Property in the IDE Properties Window, or at runtime. All of our Properties, except one, are likely to be read and altered in the IDE Properties Window. Some of them will alter the Control's appearance: Height of Header(s) and Box(es), BorderStyle, ForeColor and BackColor of Header(s), Box(es) and List. These Properties imply the Control to be redrawn, we'll see later. They have their defined Data Types - Integer, Byte, Color, BorderStyle - which can be changed with pre-defined Dialogs, ComboBoxes or TextBoxes. But, although the properties ListFontStyle and LayerOrder deal with Byte values, instead of a simple TextBox for typing a digit, we prefer a ComboBox with descriptive text for the allowed values. For that, we have to declare Data Types of our Enumeration lists. Finally, property SelectedIndex is to be used only at runtime, i.e., must be non-browsable and hidden. See all Properties here

11. Select and Open MCCB.vb Code tab. Lets Import a reference, needed to specify some Properties Attributes, like Category, Description, Browsable or DesignerSerializationVisibility, and declare two Enum types and a couple of Variables - some for Property values (the _Name of the variable is the Name of the Property, preceded by an underscore), some for internal use:

Imports System.ComponentModel   ' For PropertyAttributes

Public Class MCCB

   Public Enum LFStyle         ' for Property ListFontStyle
        SameAsControl = 0
        AlwaysRegular = 1
  End Enum

    Public Enum LayOrder        ' for Property LayerOrder
        Normal = 0
        BringToFront = 1
        SendToBack = 2
   End Enum

    ' Property variables
    Private _MaxItemsDisp As Integer = 8
    Private _HeaderHeight As Byte = 19
    Private _HeaderBackColor As Color = Color.WhiteSmoke
    Private _HeaderForeColor As Color = Color.Black
    Private _HeaderBorderStyle As BorderStyle = Windows.Forms.BorderStyle.FixedSingle
    Private _BoxHeight As Byte = 20
    Private _BoxBackColor As Color = Color.White
    Private _BoxForeColor As Color = Color.MediumBlue
    Private _BoxBorderStyle As BorderStyle = Windows.Forms.BorderStyle.FixedSingle
    Private _ListBackColor As Color = Color.White
    Private _ListForeColor As Color = Color.Black
    Private _ListBorderStyle As BorderStyle = Windows.Forms.BorderStyle.FixedSingle
    Private _ListFontStyle As Byte = 0      ' 0-SameAsControl, 1-AlwaysRegular
    Private _LayerOrder As Byte = 0         ' 0-Normal, 1-BringToFront, 2-SendToBack
    Private _SelectedIndex As Integer = -1
    ' Internal variables
    Private _ColumnCount As Integer = 0
    Private _ColumnIndex As Integer = 0
    Private _TotalWidth As Integer = 99
    Private _LeftLocation As Integer = 0
    Private _ItemsCount As Integer = 0
    Private _Me_MinHeight As Integer = _HeaderHeight + _BoxHeight - 1
    Private _ListHeight As Integer = 0
    Private _ShowList As Boolean = False    ' used in Resize event
    Private _FNIlastIdx As Integer = -1     ' Last ColumnIndex searched
    Private _FNIlastStr As String = ""      ' Last String searched
    Private _FNI_iFrom As Integer = -1
    Private _Error As String = "Error"

12. As said before, most Properties imply the Control to be redrawn. And redraw the Control implies the Resize Event to be raised. Resize Event will be also called whenever the List is dropped down or hidden, i.e., when the 'button' LblDrop is clicked. So, Resize Event must deal with two different situations: 1) The List is to be dropped down (if there are Items to show), with its correct Height. 2) The list is to be hidden. And for controlling its behavior, we created a variable _ShowList, whose initial value is False, thus ensuring the correct scaling in design mode. So, let's change the UserControl's Resize Event. Note that _Me_MinHeight = _HeaderHeight + _BoxHeight - 1, so _Me_MinHeight represents always the (minimum) height of the Control, without List, and the height of the List is the number of rows to display, each one 17 pixels [16 (row height) + 1 (separator line)] plus 1 (last line):

    Private Sub MCCB_Resize(sender As Object, e As EventArgs) Handles Me.Resize
        'Me.Height = 38     ' Replaced by the code below:
        If _ShowList And _ItemsCount > 0 Then
            _ListHeight = Math.Min(_ItemsCount, _MaxItemsDisp) * 17 + 1
        Else
            _ListHeight = 0
        End If
        Me.Height = _Me_MinHeight + _ListHeight
        MyLV.Height = _ListHeight
    End Sub

13. Resize Event is to be called (also) from several other situations, but the variable _ShowList must be set to the desired value. So, let's create a unique Sub that sets the value of the variable and invokes the Resize Event, which will be called in each of these situations:

    Private Sub ShowHideList(Show As Boolean)
        _ShowList = Show
        MCCB_Resize(Nothing, Nothing)
    End Sub

14. Now, lets provide a mechanism to Drop-down or Hide the List, when the label LblDrop is Clicked. And more, when the Mouse passes over the label, it's BackColor becomes Orange and the Cursor changes to Hand. So, let's use the Events MouseHover, MouseLeave and Click:

    Private Sub LblDrop_MouseHover(sender As Object, e As EventArgs) Handles LblDrop.MouseHover
        Me.Cursor = Cursors.Hand
        sender.BackColor = Color.Orange
    End Sub

    Private Sub LblDrop_MouseLeave(sender As Object, e As EventArgs) Handles LblDrop.MouseLeave
        Me.Cursor = Cursors.Default
        sender.BackColor = Color.WhiteSmoke
    End Sub

    Private Sub LblDrop_Click(sender As Object, e As EventArgs) Handles LblDrop.Click
        ShowHideList(Show:=(Me.Height <= _Me_MinHeight))
    End Sub

15. It's time to create our first Property. By default, Properties are readable (the Get part) and writable (the Set path). However, they can also be declared as ReadOnly (only Get part) or WriteOnly (only Set part). Also, some Attributes can be specified. In this case, Category (existing or new, where the Property is to be included) and Description (the explanation that appears at the bottom of the Properties Window). For reading a property, Return the value of the associated variable. For writing a property, set it's associated variable to the specified value, and, if the value is to take immediate effect, code the action. In this case, just a call to the Sub ShowHideList, with the argument True, to set the variable _ShowList and Drop-down the List:

<Category("_MCCB specifics")> _
<Description("Maximum Items Displyed by the List")> _
    Public Property MaxItemsDisp() As Byte
        Get
            ' Get - if the Property is readable (or ReadOnly)
            Return _MaxItemsDisp
        End Get
        Set(ByVal value As Byte)
            ' Set - if the Property is writable (or WriteOnly)
            _MaxItemsDisp = value
            ShowHideList(True) ' Action
        End Set
    End Property

16. For now, let's create our first Method, which will allow adding Columns and set some (fixed) Properties. To be accessible from the outside, the Method must be Public. The first call to this Method will not create a new Column, but change the one already existing. The Method will accept three parameters:

1. Width - Required. The Width of the Column, in pixels. A value of 0 will create a hidden Column.
2. Text - Required. The title (Header) of the Column.
3. Align - Optional. The Horizontal Alignment of the Column. Default (if not specified) is Left. HorizontalAlignment values (0=Left, 1=Right, 2=Center) are used to define the TextAlign property of ListView Columns (or, e.g., TextBoxes). However, Labels use other values (ContentAlignment), which besides the Horizontal position, also reflects the Vertical position (Top, Middle, Bottom). Our 'Headers' and 'Boxes' are to be 'middle' aligned, so HorizontalAlignment values (0, 1 and 2) must be transformed in 'Middle' ContentAlignment values (respectively 16, 64 and 32).

    Public Sub AddColumn(Width As Integer, Text As String, _
                         Optional Align As HorizontalAlignment = 0)
        Dim Lbl_Align As ContentAlignment = If(Align = 1, 64, _
                                               If(Align = 2, 32, 16))
        Dim Hdr As Label
        Dim Box As Label
        Me.SuspendLayout()
        _ColumnCount += 1
        _ColumnIndex = _ColumnCount - 1
        If _ColumnCount = 1 Then   ' First Column, already exists
            Hdr = Hdr0                          ' Existing Header
            Box = Box0                          ' Existing Box
            MyLV.Width = Width + 19             ' Existing List. Initial
            ' value, including the "Button" (LblDrop)
            lvCol0.Width = Width - 3            ' Existing ListView Column
            _TotalWidth = Width - 1             ' Initial value
            Me.BackColor = Color.Transparent
        Else                        ' Column is to be created
            Hdr = New Label                         ' New Header
            Hdr.Name = "Hdr" & _ColumnIndex.ToString
            Hdr.Left = _TotalWidth
            Box = New Label                         ' New Box
            Box.Name = "Box" & _ColumnIndex.ToString
            Box.Left = _TotalWidth
            MyLV.Columns.Add(New ColumnHeader)      ' New ListView Column
            MyLV.Columns(_ColumnIndex).Name = "lvCol" & _ColumnIndex.ToString
            MyLV.Columns(_ColumnIndex).Text = ""
            MyLV.Columns(_ColumnIndex).Width = Math.Max(Width - 1, 0)
            MyLV.Columns(_ColumnIndex).TextAlign = Align
            MyLV.Width += Width - 1     ' Accum.
            _TotalWidth += Width - 1    ' Accum.
        End If
        Hdr.Width = Width           ' Header
        Hdr.Text = Text
        Hdr.TextAlign = Lbl_Align
        Box.Width = Width           ' Box
        Box.Text = ""
        Box.TextAlign = Lbl_Align
        LblDrop.Left = _TotalWidth  ' DropDown "Button"
        LblDrop.Height = _BoxHeight
        If _ColumnCount > 1 Then    ' All but first
            Controls.AddRange({Box, Hdr})
        End If
        Me.ResumeLayout(True)
        RedrawControls()
    End Sub

Example of how to call this Method:

Mccb1.AddColumn(140, "Name")    ' Align not specified = HorizontalAlignment.Left
Mccb1.AddColumn(35, "Age", HorizontalAlignment.Center)
Mccb1.AddColumn(90, "Due date", 2)  ' 2 = HorizontalAlignment.Center
Mccb1.AddColumn(90, "Amount (US$)", HorizontalAlignment.Right)

17. As said before, AddColumn Method creates new Columns, setting up their unalterable Properties. But to properly complete the Components setup, we have to initialize the Properties that can be changed at any time. Therefore, we'll create a specific (Private) Subroutine (RedrawControls), which is also called by the AddColumn Method (last instruction): Note that, because the Size of the Control is changed (Me.Height & Me.Width), the Control's Resize Event will be raised:

    Private Sub RedrawControls()
        Me.SuspendLayout()
        MyLV.Top = _HeaderHeight + _BoxHeight - 2
        MyLV.BackColor = _ListBackColor
        MyLV.ForeColor = _ListForeColor
        MyLV.BorderStyle = _ListBorderStyle
        Dim Name As String
        For iCtr As Integer = 0 To _ColumnIndex ' For each Column...
            Name = "Box" & iCtr.ToString
            Controls(Name).Top = _HeaderHeight - 1
            Controls(Name).Height = _BoxHeight
            Controls(Name).BackColor = _BoxBackColor
            Controls(Name).ForeColor = _BoxForeColor
            Dim Lbl As Label = CType(Controls(Name), Label)
            Lbl.BorderStyle = _BoxBorderStyle
            Name = "Hdr" & iCtr.ToString
            Controls(Name).Height = _HeaderHeight
            Controls(Name).BackColor = _HeaderBackColor
            Controls(Name).ForeColor = _HeaderForeColor
            Lbl = CType(Controls(Name), Label)
            Lbl.BorderStyle = _HeaderBorderStyle
        Next
        LblDrop.Top = _HeaderHeight - 1
        LblDrop.Height = _BoxHeight
        _Me_MinHeight = _HeaderHeight + _BoxHeight - 1
        Me.Height = _Me_MinHeight
        Me.Width = _TotalWidth + 20 ' 20=LblDrop.Width
        Me.ResumeLayout(True)
    End Sub

18. Look at the provided Source Project. Code or copy all the other Properties which call RedrawControls. Special attention to two Properties whose action is different: The first, ListFontStyle, whose Type is defined by the Enum LFStyle, sets the variable _ListFontStyle and calls the Event (FontChanged) that occurs whenever the Font changes. The second, LayerOrder, whose Type is defined by the Enum LayOrder, sets the variable _LayerOrder, but its action is taken before, depending on its previous value. Why? Because, if a and b offer no doubts, setting the value to 0 (Normal) implies to change the last behavior. That action must also be taken when the Control is loaded, in the Control's Load Event. Let's see the Load and the FontChanged Events, and the two Properties:

    Private Sub MCCB_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        If _LayerOrder = 1 Then
            Me.BringToFront()
        ElseIf _LayerOrder = 2 Then
            Me.SendToBack()
        End If
    End Sub

    Private Sub MCCB_FontChanged(sender As Object, e As EventArgs) Handles Me.FontChanged
        MyLV.Font = New Font(Me.Font, If(_ListFontStyle = 0, _
                                        Me.Font.Style, FontStyle.Regular))
    End Sub

    <Category("_MCCB specifics")> _
    <Description("Action in List when Control's Font changes to Bold")> _
    Public Property ListFontStyle() As LFStyle
        Get
            Return _ListFontStyle
        End Get
        Set(ByVal value As LFStyle)
            _ListFontStyle = value
            MCCB_FontChanged(Nothing, Nothing)
        End Set
    End Property

    <Category("_MCCB specifics")> _
    <Description("Control's Layer Order Action")> _
    Public Property LayerOrder() As LayOrder
        Get
            Return _LayerOrder
        End Get
        Set(ByVal value As LayOrder)
            If value = 1 OrElse (value = 0 And _LayerOrder = 2) Then
                Me.BringToFront()
            ElseIf value = 2 OrElse (value = 0 And _LayerOrder = 1) Then
                Me.SendToBack()
            End If
            _LayerOrder = value
        End Set
    End Property

19. Let's create a Method to feed the List. It requires an array of Strings, one for each SubItem, including any hidden Columns. It's simple, because such array is directly convertible in the required ListViewItem type. A Boolean is returned, indicating the Success (True) or Failure (False) of the operation:

    Public Function AddRow(SubItems As Array) As Boolean
        Dim OK As Boolean = False
        If SubItems.Length > _ColumnIndex + 1 Then
            MsgBox("SubItems (" & SubItems.Length.ToString & _
                   ") exceeds the number of Columns (" & _
                   (_ColumnIndex + 1).ToString & ")...", _
                   MsgBoxStyle.Critical, _Error)
        Else
            Try
                MyLV.Items.Add(New ListViewItem(SubItems))
                _ItemsCount += 1
                OK = True
            Catch ex As Exception
                MsgBox(ex.Message, MsgBoxStyle.Critical, _Error)
            End Try
        End If
        Return OK
    End Function

Example of how to call this Method:

Dim vAge As Byte = 35
Dim vDate As String = Today.ToShortDateString
Dim vValue As Single = 1234.56
If Mccb1.AddRow({"John Smith", vAge.ToString, vDate, Format(vValue, "#,###.00")}) = False Then
   ' Something went wrong...
End If

20. When a List Row is selected, the SubItem(s) of the Row must be shown in the corresponding Box(es). To perform the task, let's create a Sub ShowSelectedItem, as well as the three situations where the task is to be performed: 1-Our Control's Property (Non-browsable and hidden) SelectedIndex, 2-our Control's Method FindNextItem and 3-the ListView Event ItemSelectionChanged., which fires our Control's Event (ItemSelectionChanged) (code fragment #1) that is to be raised whenever a new Row is selected and provides an array of Strings with the values of all the SubItems of the selected Row, also a simple Sub () (code fragment #2) used to display an error message when an invalid negative index is detected, and a Function (GetSubItems) that prepares the above mentioned array of Strings, also used in Method FindNextItem:

    Public Event ItemSelectionChanged(SubItems As Array)

    Private Sub MsgNoNeg(Prefx As String)
        MsgBox(Prefx & " cannot be negative...", _
               MsgBoxStyle.Critical, _Error)
    End Sub

    Private Sub ShowSelectedItem()
        Dim BoxName As String
        For iCtr As Integer = 0 To _ColumnIndex
            BoxName = "Box" & iCtr.ToString
            Controls(BoxName).Text = MyLV.Items(_SelectedIndex).SubItems(iCtr).Text
        Next
    End Sub

    Private Function GetSubItems() As Array
        Dim SubItems(_ColumnIndex) As String
        For iSI As Integer = 0 To _ColumnIndex
            SubItems(iSI) = MyLV.Items(_SelectedIndex).SubItems(iSI).Text
        Next
        Return SubItems
    End Function

     <Browsable(False)> _
    <DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)> _
    Public Property SelectedIndex() As Integer
        Get
            Return _SelectedIndex
        End Get
        Set(ByVal value As Integer)
            If value < 0 Then
                MsgNoNeg("Index")
            Else
                If value >= _ItemsCount Then
                    MsgBox("Last Index = " & (_ItemsCount - 1).ToString, _
                           MsgBoxStyle.Critical, _Error)
                Else
                    If _SelectedIndex >= 0 Then
                        MyLV.Items(_SelectedIndex).Selected = False
                    End If
                    _SelectedIndex = value
                    MyLV.Items(_SelectedIndex).Selected = True
                    ShowSelectedItem()
                    ShowHideList(Show:=False)    'Close List
                End If
            End If
        End Set
    End Property

    Public Function FindNextItem(ColumnIndex As Integer, SearchString As String) As Array
        Dim FoundItem(_ColumnIndex) As String
        If ColumnIndex >= 0 Then
            If ColumnIndex > _ColumnIndex Then
                MsgBox("Maximum ColumnIndex is " & _ColumnIndex.ToString & "...", _
                       MsgBoxStyle.Critical, _Error)
            Else
                If ColumnIndex = _FNIlastIdx And SearchString = _FNIlastStr Then
                    ' Same values, serch next
                    _FNI_iFrom += 1
                Else
                    ' New values, search first
                    _FNI_iFrom = 0
                    _FNIlastIdx = ColumnIndex
                    _FNIlastStr = SearchString
                End If
                If _FNI_iFrom >= 0 Then

                    Dim Found As Boolean = False
                    Dim iCtr As Integer
                    For iCtr = _FNI_iFrom To _ItemsCount - 1
                        If Strings.InStr(MyLV.Items(iCtr).SubItems(ColumnIndex).Text, _
                                         SearchString, CompareMethod.Text) > 0 Then
                            ' Item found...
                            Found = True
                            _SelectedIndex = iCtr
                            FoundItem = GetSubItems()
                            ' Select Item
                            If _SelectedIndex >= 0 Then
                                MyLV.Items(_SelectedIndex).Selected = False
                            End If
                            MyLV.Items(_SelectedIndex).Selected = True
                            ShowSelectedItem()
                            ShowHideList(True)
                            Exit For
                        End If
                    Next
                    _FNI_iFrom = iCtr
                    If Found = False And iCtr = _ItemsCount Then
                        MsgBox("No match...", MsgBoxStyle.Information, "Info")
                        FoundItem = Nothing
                    End If
                End If
            End If
        Else
            MsgNoNeg("ColumnIndex")
        End If
        Return FoundItem
    End Function

    Private Sub MyLV_ItemSelectionChanged(sender As Object, e As ListViewItemSelectionChangedEventArgs) _
                Handles MyLV.ItemSelectionChanged
        Dim FoundItem(_ColumnIndex) As String
        If e.IsSelected Then
            _SelectedIndex = e.ItemIndex
            ShowSelectedItem()
            ShowHideList(False)     ' Close List
            RaiseEvent ItemSelectionChanged(GetSubItems)
        End If
    End Sub

21. Just two more simple Methods, Clear and DropDown:

    Public Sub Clear()
        MyLV.Items.Clear()
        _ItemsCount = 0
        For iCtr As Integer = 0 To _ColumnIndex
            Controls("Box" & iCtr.ToString).Text = ""
        Next
        ShowHideList(False)     ' Close the List
    End Sub

    Public Sub DropDown()
        ShowHideList(True)      ' Drop-down the List
    End Sub

That's all. I organized the Control's Code in Regions:

Imports
Enums & Variables
Public Properties
Public Methods
Public Event
Control Events
Private Subs/Functions
Initialization

#Region "Initialization" is the code generated by the Designer.

Finally, in your WinForms Application:

1. Copy MCCB.dll to its StartupPath ( \bin\Debug or \bin\Release within the Project ) , and after to the Folder of your final .EXE
2. In Visual Studio, Add a Reference: Menu PROJECT - Add Reference... - Browse... - MCCB.dll
3. Put an Icon ( ) in the Toolbox: Menu TOOLS - Choose Toolbox Items... - .NET Framework Components - Browse... - MCCB.dll . The Icon will appear under All Windows Forms group.

Brief description of the Control's own Properties, Methods and Event

Properties

• BoxBackColor - Back Color of the Box(es).
• BoxBorderStyle - Border Style of the Box(es).
• BoxForeColor - Fore Color of the Box(es).
• BoxHeight - Height of the Box(es).
• HeaderBackColor - Back Color of the Header(s).
• HeaderBorderStyle - Border Style of the Header(s).
• HeaderForeColor - Fore Color of the Header(s).
• HeaderHeight - Height of the Header(s).
• LayerOrder - Control's Layer Order Action.
• ListBackColor - Back Color of the List.
• ListBorderStyle - Border Style of the List.
• ListFontStyle - Action in List when Control's Font changes to Bold.
• ListForeColor - Fore Color of the List.
• MaxItemsDisp - Maximum Items Displayed by the List.
• SelectedIndex - Index of the Item that is (or is to be) Selected in the List.

Methods

• AddColumn(Width As Integer, Text As String, [Align As HorizontalAlignment = HorizontalAlignment.Left]) - Adds a Column, given its Width (in pixels), its (header)Text and its Alignment (Left, Center, Right).
• AddRow(SubItems As Array) As Boolean - Adds a Row to the List, given an array of Strings. Returns a Boolean indicating Success (True) or Failure (False) of the operation.
• Clear - Clears the List and the Box(es) of the Control.
• DropDown - Drops Down the List.
• FindNextItem(ColumnIndex As Integer, SearchString As String) As Array - Finds the next occurrence of a given String within the values of a Column, given its Index. The Row where the match occurs is selected and an array of its SubItems is returned. When no more matches, the array is Nothing, but the last selected Row remains selected.

Event

• ItemSelectionChanged(SubItems As Array) - Occurs whenever a new Row is selected from the List.

History

09.Mar.2016 - First post