ComboBox with Suggestions Based on Loose Character Search

If type suggestion text "coll" some text in the dropdown are overlapping

For example
Abington & Witney College (C is overlapping over y)
Advanced Procurement for Universities & College (both ll in College overlapping over

private StringMatch buildNoWildcard(string source)
{
    string pattern = (string)m_pattern;
    string lsource = source.ToLower();

    int pOffset = 0;
    int pLength = pattern.Length;
    int sOffset = 0;
    var tuples = new List<Tuple<int, int>>();

    while (pLength > 0)
    {
        int n = lsource.Substring(sOffset)
                    .IndexOf(pattern.Substring(pOffset, pLength));
        if (n >= 0) // got a match
        {
            tuples.Add(new Tuple<int, int>(sOffset + n, pLength)); // add it to the list
            sOffset = sOffset + n + pLength;
            pOffset += pLength; // and bump to remaining portion of pattern
            pLength = pattern.Length - pOffset;
        }
        else
        {
            pLength--; // search for a smaller portion of the pattern
            if (pLength == 0)
                return null;
        }
    }

    if (tuples.Count == 0)
        return null;

    bool startsOnMatch = (tuples[0].Item1 == 0);

    // convert tuples to segments
    List<string> segments = new List<string>();
    int offset = 0;
    foreach (var tuple in tuples)
    {
        if (tuple.Item1 > offset)
            segments.Add(source.Substring(offset, tuple.Item1 - offset));
        segments.Add(source.Substring(tuple.Item1, tuple.Item2));
        offset = tuple.Item1 + tuple.Item2;
    }
    if (offset < source.Length)
        segments.Add(source.Substring(offset));

    // rank items based on average tuple length
    double? rank = null;
    if (tuples.Count > 0)
    {
        double total = 0;
        foreach (var tuple in tuples)
        {
            total += tuple.Item2; // length

            // boost items that start a word
            if (tuple.Item1 == 0 || tuple.Item1 > 0 && !char.IsLetterOrDigit(lsource[tuple.Item1 - 1]))
                total += 1;
        }
        rank = total / tuples.Count;
        if (tuples.Count == 1 && tuples[0].Item1 == 0)
            rank += ((string)m_pattern).Length; // boost ones that are in fact prefixes
    }

    return new StringMatch
    {
        Text = source,
        Segments = segments,
        Rank = rank,
        StartsOnMatch = startsOnMatch,
    };
}

m_suggestionList.BeginUpdate();
m_suggestionList.Items.Clear();

List<StringMatch> result = new List<StringMatch>();

StringMatcher matcher = new StringMatcher(MatchingMethod, Text);
foreach (object item in Items)
{
    StringMatch sm = matcher.Match(GetItemText(item));
    if (sm != null)
    {
        result.Add(sm);
    }
}

result.Sort((item1, item2) =>
{
    if (item1 == null || item2 == null)
        return 0;
    if (item1.Rank != null && item2.Rank != null)
    {
        var rank = ((double)item2.Rank).CompareTo((double)item1.Rank); // descending
        if (rank != 0) return rank;
    }
    return item1.Text.CompareTo(item2.Text);
});

foreach (var item in result)
    m_suggestionList.Items.Add(item);

if (m_suggestionList.Items.Count > 0)
    m_suggestionList.SelectedIndex = 0;

m_suggestionList.EndUpdate();

   Public Sub New(method As StringMatchingMethod, pattern As String)
       Select Case method
           Case StringMatchingMethod.NoWildcards
               m_pattern = prepareNoWildcard(pattern)
               Match = AddressOf buildNoWildcard
               Exit Select
           Case StringMatchingMethod.UseWildcards
               m_pattern = prepareWithWildcards(pattern)
               Match = AddressOf buildWithWildcards
               Exit Select
           Case StringMatchingMethod.UseRegexs
               m_pattern = prepareRegex(pattern)
               Match = AddressOf buildRegex
               Exit Select
           Case StringMatchingMethod.Simple
               m_pattern = pattern.ToLower
               Match = AddressOf BuildSimple
               Exit Select
           Case Else
               Throw New ArgumentException("Unknown StringMatchingMethod value")
       End Select
   End Sub

Private Function BuildSimple(Source As String) As StringMatch

       Dim pattern As String = DirectCast(m_pattern, String)
       Dim lsource As String = Source.ToLower()

       Dim segments As New List(Of String)()
       Dim sMatch As Boolean = False

       Dim tmpStr As String = ""

       If Not pattern = "" AndAlso lsource.Contains(pattern) = True Then

           Dim i As Integer = 0

           While i <= Source.Length - 1

               If lsource.Substring(i).StartsWith(pattern) Then

                   If Not tmpStr = "" Then
                       segments.Add(tmpStr)
                       tmpStr = ""
                   End If

                   segments.Add(Source.Substring(i, pattern.Length))

                   If i = 0 Then
                       sMatch = True
                   End If

                   i = i + pattern.Length
               Else
                   tmpStr = tmpStr & Source.Substring(i, 1)
                   i = i + 1

                   If Not tmpStr = "" And i = Source.Length Then
                       segments.Add(tmpStr)
                   End If
               End If

           End While

           Return New StringMatch() With { _
                       .Text = Source, _
                       .Segments = segments, _
                       .StartsOnMatch = sMatch _
                       }

       Else
           Return Nothing
       End If

   End Function