A Keyboard Selection Enabled ComboBox in Silverlight

Hi and thanks for great solution!

But I have a question: why do you use exactly 1500 ms for a timer? Is it documented somewhere? Can user have custom timespan on his/her machine?

Hi
Nice post appreciate the writing

But here I have a problem where I have Binded my combobox to a IDictionary and read it using a KeyValuePair<int,string> kvp = (KeyValuePair<int,string>)combobox.items[i];

Therefore you code does not work as it says cannot convert Keyvaluepair<int,string> to combo-box

Please help me in this regard

for a thrown-together hack, this will probably suffice.

however, a better way to accomplish this is with a Behavior, as described here:
http://www.silverlightshow.net/news/Keyboard-selection-on-Silverlight-ListBox-and-ComboBox.aspx[^]

Also:
1. It's opened now when user is typing.
2. ComboBox.Tag property is not used anymore, I had a conflict with another combobox extension
http://blogs.msdn.com/b/kylemc/archive/2010/06/18/combobox-sample-for-ria-services.aspx

3. Delete clears selection.

Few classes from Caliburn library http://caliburn.codeplex.com/ are needed now.
You can download Caliburn's source code and include only "Caliburn.Core -> MemoryManagement and Threading" to your project.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Reflection;
using System.Collections;
using Caliburn.Core.MemoryManagement;
using Caliburn.Core.Threading;

namespace KeyBoardSelectionComboBox
{
    public static class Extensions
    {
      private static WeakKeyedDictionary<ComboBox, string> _tags = new WeakKeyedDictionary<ComboBox, string>();

      private static string getComboTag(ComboBox cb)
      {
        if (_tags.ContainsKey(cb)) return _tags[cb];
                              else return "";
      }

      private static void setComboTag(ComboBox cb, string value)
      {
        _tags[cb] = value;
      }

      private enum comboCmdName { skipClose };
      private class comboCmd
      {
        public comboCmdName Cmd       { get; set; }
        public DateTime     TimeStamp { get; set; }
      }

      private static WeakKeyedDictionary<ComboBox, comboCmd> _cmds = new WeakKeyedDictionary<ComboBox, comboCmd>();

      private static comboCmd getComboCmd(ComboBox cb)
      {
        if (_cmds.ContainsKey(cb)) return _cmds[cb];
        else return null;
      }

      private static void setComboCmd(ComboBox cb, comboCmd value)
      {
        _cmds[cb] = value;
      }

      private class checkRslt { public bool rslt {get; set; } }
      
      private delegate void checkCombo(ComboBox cb, checkRslt rslt);
      
      private static void checkContainers(ComboBox cb, checkRslt rslt)
      {
        var allReady = true;
        foreach (var i in cb.Items)
        {
          var c = cb.ItemContainerGenerator.ContainerFromItem(i);
          if (c == null) {
            allReady = false;
            break;
          }
        }
        rslt.rslt = allReady;
      }

      private delegate void attachToCombo(ComboBox cb, Delegate handler);

      private static void attachKeyUp(ComboBox cb, Delegate handler)
      {
        if (!(handler is KeyEventHandler)) return;
        foreach (var i in cb.Items)
        {
          var c = cb.ItemContainerGenerator.ContainerFromItem(i);
          if (c is ComboBoxItem) {
            (c as ComboBoxItem).KeyUp += handler as KeyEventHandler;
          }
        }
      }
    
         /*
          * SetKeyboardSelection enables keyboard selection on all
          * ComboBoxItems, as well as on the ComboBox itself (it has not already been added).
          * In addition, it tracks the "search history" that is created as the user types.
          * This is done to allow the user to type in more letters to narrow down
          * results (ie. "Ala" = Alabama, Alaska; "Alab" = Alabama)
          */
        public static void SetKeyboardSelection(this ComboBox comboBox, bool enable)
        {
            string searchStringEnabled = "KeyboardSelectionEnabled";
            string comboBoxTag = getComboTag(comboBox);
            //See if our search history control already exists by analyzing the combobox tag...
            bool isKeyboardEnabled = comboBoxTag.Contains(searchStringEnabled);

            /*
             * KeyPressSearch is defined as an anonymous delegate, that SetKeyboardSelection delegates
             * to the KeyUp events of ComboBoxItems and the parent ComboBox.
            */
            #region KeyPressSearch
            KeyEventHandler keyPressSearch = delegate(object sender, KeyEventArgs e)
            {
                if (e.Key == Key.Delete) {   // clear
                  comboBox.SelectedIndex = -1;
                  return;
                }
                //Since Key has only certain values, A-Z, D0-D9, NumPad0-9, Space, etc. let's just focus on
                //letters, and numbers, and ignore all other keys... if they're pressed, clear the search history
                //another option is to use PlatformKeyCode, but since it's platform specific, let's not.
                string key = e.Key.ToString();
                if (key.Length > 1 && (key.StartsWith("D") && char.IsDigit(key[1]) || key.StartsWith("NumPad")))
                { //remove the D/NumPad prefix to get the digit
                    key = key.Replace("NumPad", "").Replace("D", "");
                }
                else if (key.Length > 1)
                {
                    setComboTag(comboBox, searchStringEnabled + "||");
                    return;
                }
                string searchHistoryPartsString = getComboTag(comboBox);
                if (string.IsNullOrEmpty(searchHistoryPartsString)) searchHistoryPartsString = searchStringEnabled + "||";
                string[] searchHistoryParts = (searchHistoryPartsString.Contains("|")) ? searchHistoryPartsString.Split('|') : new string[0];

                int historyExpiration = 1500; //In 1.5 seconds, clear the history, and start new...
                string searchStringHistory = searchHistoryParts.Length == 3 ? searchHistoryParts[1] : "";
                string searchStringTimeStampString = searchHistoryParts.Length == 3 ? searchHistoryParts[2] : "";
                DateTime searchStringTimeStamp;
                string searchString = key;

                if (DateTime.TryParse(searchStringTimeStampString, out searchStringTimeStamp)
                    && DateTime.Now.Subtract(searchStringTimeStamp).TotalMilliseconds < historyExpiration)
                {   //search history is valid and has not yet expired...
                    searchString = searchStringHistory + key;
                }

                for (int i = 0; i < comboBox.Items.Count; i++)
                {
                  string s = null;  
                  if (comboBox.Items[i] is ComboBoxItem) 
                    s = (comboBox.Items[i] as ComboBoxItem).Content.ToString();
                  else if (!string.IsNullOrWhiteSpace(comboBox.DisplayMemberPath))
                    s = GetValueByPath(comboBox.Items[i], comboBox.DisplayMemberPath);
                  else continue;
                  //
                  if (!string.IsNullOrEmpty(s) && s.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase))
                  {
                    comboBox.SelectedIndex = i;
                    if (!comboBox.IsDropDownOpen) comboBox.IsDropDownOpen = true;
                    else setComboCmd(comboBox, new comboCmd() { Cmd = comboCmdName.skipClose, TimeStamp = DateTime.Now });
                    setComboTag(comboBox, searchStringEnabled + "|" + searchString + "|" + DateTime.Now);
                    break;
                  }
                }
            };
            #endregion

            if (!isKeyboardEnabled && enable)
            {
                setComboTag(comboBox, searchStringEnabled + "||");

                //Reset the search history on open and close
                comboBox.DropDownOpened += delegate
                {
                  setComboTag(comboBox, searchStringEnabled + "||");
                  // the following code is attaching KeyUp handlers to ComboBoxItems
                  var found = false;
                  for (int i = 0; i < comboBox.Items.Count; i++)
                  {
                    if (comboBox.Items[i] is ComboBoxItem)
                    {
                      (comboBox.Items[i] as ComboBoxItem).KeyUp += keyPressSearch;
                      found = true;
                    }
                  }
                  if (!found) { // comboBox.ItemContainerGenerator.StatusChanged is not yet implemented in SL
                    var t = new BackgroundTask(new DefaultThreadPool(),
                      delegate {
                        var r = new checkRslt() { rslt = false };
                        do {
                          Deployment.Current.Dispatcher.BeginInvoke(
                            new checkCombo(checkContainers), comboBox, r
                          );
                          if (!r.rslt) System.Threading.Thread.Sleep(20);
                        }
                        while (!r.rslt);
                        return true;
                      }
                    );
                    t.Completed += delegate {
                      Deployment.Current.Dispatcher.BeginInvoke(
                        new attachToCombo(attachKeyUp), comboBox, keyPressSearch
                      );
                    };
                    t.Enqueue(null/*userState*/);
                  }
                };
                
                comboBox.DropDownClosed += delegate
                {
                  var cmd = getComboCmd(comboBox);
                  if (cmd != null && cmd.Cmd == comboCmdName.skipClose) {
                    if (DateTime.Now.Subtract(cmd.TimeStamp).TotalMilliseconds < 500) 
                    {
                      var save = getComboTag(comboBox);
                      comboBox.IsDropDownOpen = true;
                      setComboTag(comboBox, save);
                      comboBox.Focus();
                      return;
                    }
                    setComboCmd(comboBox, null); // command is expired
                  }
                  setComboTag(comboBox, searchStringEnabled + "||");
                };

                //Add handler to parent control, so that we search even when combobox is closed, yet focused
                comboBox.KeyUp += keyPressSearch;
            }
            else if (isKeyboardEnabled && !enable)
            {
                //Remove handler
                comboBox.KeyUp -= keyPressSearch;
                for (int i = 0; i < comboBox.Items.Count; i++)
                {
                    if (comboBox.Items[i] is ComboBoxItem)
                    {
                      (comboBox.Items[i] as ComboBoxItem).KeyUp -= keyPressSearch;
                    }
                }
                setComboTag(comboBox, "");
            }
            else 
            {
                //Remove handler
                comboBox.KeyUp -= keyPressSearch;
                setComboTag(comboBox, "");
            }
        }
  
        private static string GetValueByPath<T>(T obj, string propertyPath) where T : class
        {
          Type type = obj.GetType();
          PropertyInfo prop = null;

          string[] parts = propertyPath.Split('.');
          object value = obj;

          foreach (string part in parts)
          {
            prop = type.GetProperty(part);
            var x = prop.GetValue(value, null);

            if (x is IList)
            {
              value = (x as IList)[0];
              type = value.GetType();
              continue;
            }
            else type = prop.GetType();

            value = prop.GetValue(value, null);
         }  
         return value.ToString();
       }
       
    }
}

Hi,

I have modified your code to work when using an itemtemplate(I will share the code when it works correctly). This works fine when the combobox is closed and the combobox is handling the event.
I do not know how to add events to the items in the combobox, since the items are not of type ComboBoxItem but of type "MyData".

Any help is appreciated,

Michael

Hi,

The only way that would really work is if the items you're adding have Key events. I've started writing a custom ComboBox that inherits from the base ComboBox. It's used exactly the same way you would with a ComboBox - you bind your items to the ItemsSource, and set the DisplayMemberPath. It then uses reflection to find the object you're looking for when you start typing. It uses a PropertyReflector class I found online which works very well.

Here's the code - keep in mind though, it's only been my first pass at it. I know it has a few issues (for one, the binding of the DisplayMemberPath isn't working...)

Feel free to clean up the code as you like, add your changes, and release it!

XAML

<ComboBox x:Class="SilverlightApp.Client.Controls.KeyboardEnabledComboBox"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" />

Code Behind:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightApp.Client.Controls
{
    private Dictionary<ComboBoxItem, object> _ComboBoxItemValues = new Dictionary<ComboBoxItem, object>();

        private int _HistoryResetDelay = 1500;
        public int HistoryResetDelay
        {
            get { return _HistoryResetDelay / 1000; }
            set { _HistoryResetDelay = value * 1000; }
        }

        private System.Collections.IEnumerable _ItemsSource;
        public new System.Collections.IEnumerable ItemsSource
        {
            get
            {
                return _ItemsSource;
            }
            set
            {
                _ItemsSource = value;
                _ComboBoxItemValues.Clear();
                this.Items.Clear();
                foreach (object item in _ItemsSource)
                {
                    ComboBoxItem comboBoxItem = new ComboBoxItem();

                    if (string.IsNullOrEmpty(this.DisplayMemberPath))
                    {
                        comboBoxItem.Content = item;
                    }
                    else
                    {
                        System.Windows.Data.Binding binding = new System.Windows.Data.Binding(this.DisplayMemberPath);
                        binding.Source = item;
                        comboBoxItem.SetBinding(ComboBoxItem.ContentProperty, binding);
                    }

                    _ComboBoxItemValues.Add(comboBoxItem, item);
                    this.Items.Add(comboBoxItem);
                }
                IsKeboardSelectionEnabled = _IsKeboardSelectionEnabled;
            }
        }
        
        public new object SelectedItem
        {
            get
            {
                ComboBoxItem comboBoxItem = (ComboBoxItem)this.Items[this.SelectedIndex];
                if (_ComboBoxItemValues.ContainsKey(comboBoxItem)) {
                    return this._ComboBoxItemValues[comboBoxItem];
                }
                return null;
            }
            set
            {
                foreach (ComboBoxItem comboBoxItem in this._ComboBoxItemValues.Keys)
                {
                    if (this._ComboBoxItemValues[comboBoxItem] == value)
                    {
                        comboBoxItem.IsSelected = true;
                        break;
                    }
                }
            }
        }

        public KeyboardEnabledComboBox() : base()
        {
            IsKeboardSelectionEnabled = _IsKeboardSelectionEnabled;

            this.Loaded += new RoutedEventHandler(KeyboardEnabledComboBox_Loaded);
            this.LayoutUpdated += new EventHandler(KeyboardEnabledComboBox_LayoutUpdated);
        }

        private void KeyboardEnabledComboBox_LayoutUpdated(object sender, EventArgs e)
        {
            IsKeboardSelectionEnabled = _IsKeboardSelectionEnabled;
            this.LayoutUpdated -= KeyboardEnabledComboBox_LayoutUpdated;
        }

        private void KeyboardEnabledComboBox_Loaded(object sender, RoutedEventArgs e)
        {
            IsKeboardSelectionEnabled = _IsKeboardSelectionEnabled;
            this.Loaded -= KeyboardEnabledComboBox_Loaded;
        }

        private bool _IsKeboardSelectionEnabled = true;
        public bool IsKeboardSelectionEnabled
        {
            get
            {
                return _IsKeboardSelectionEnabled;
            }
            set
            {
                if (_IsKeboardSelectionEnabled != value)
                {
                    SetKeyboardSelection(value);
                }
                else
                {
                    //Reset by flipping switch
                    SetKeyboardSelection(!value);
                    SetKeyboardSelection(value);
                }
            }
        }


        private string _SearchHistory = string.Empty;
        private DateTime _SearchHistoryTimestamp = DateTime.MinValue;

        private void SetKeyboardSelection(bool enable)
        {
            _IsKeboardSelectionEnabled = enable;
            if (enable)
            {
                //Reset the search history on open and close
                this.DropDownOpened += new EventHandler(DropDownChange);
                this.DropDownClosed += new EventHandler(DropDownChange);

                //Add handler to parent control, so that we search even when combobox is closed, yet focused
                this.KeyUp += KeyPressSearch;

                for (int i = 0; i < this.Items.Count; i++)
                {
                    if (this.Items[i].GetType() == typeof(ComboBoxItem))
                    {
                        ComboBoxItem comboBoxItem = (ComboBoxItem)this.Items[i];
                        comboBoxItem.KeyUp += KeyPressSearch;

                        if (!_ComboBoxItemValues.ContainsKey(comboBoxItem))
                        {
                            _ComboBoxItemValues.Add(comboBoxItem, comboBoxItem);
                        }
                    }
                }
            }
            else
            {
                //Remove handler
                this.KeyUp -= KeyPressSearch;
                for (int i = 0; i < this.Items.Count; i++)
                {
                    if (this.Items[i].GetType() == typeof(ComboBoxItem))
                    {
                        ComboBoxItem comboBoxItem = (ComboBoxItem)this.Items[i];
                        comboBoxItem.KeyUp -= KeyPressSearch;

                        if (!_ComboBoxItemValues.ContainsKey(comboBoxItem))
                        {
                            _ComboBoxItemValues.Add(comboBoxItem, comboBoxItem);
                        }
                    }
                }
            }

            ResetSearch();
        }

        private void DropDownChange(object sender, EventArgs e)
        {
            ResetSearch();
        }

        private void KeyPressSearch(object sender, KeyEventArgs e)
        {
            //Since Key has only certain values, A-Z, D0-D9, NumPad0-9, Space, etc. let's just focus on
            //letters, and numbers, and ignore all other keys... if they're pressed, clear the search history
            //another option is to use PlatformKeyCode, but since it's platform specific, let's not.
            string key = e.Key.ToString();
            if (key.Length > 1 && (key.StartsWith("D") || key.StartsWith("NumPad")))
            { //remove the D/NumPad prefix to get the digit
                key = key.Replace("NumPad", "").Replace("D", "");
            }
            else if (key.Length > 1)
            {
                ResetSearch();
                return;
            }

            string searchString = (DateTime.Now.Subtract(_SearchHistoryTimestamp).TotalMilliseconds < _HistoryResetDelay) ? _SearchHistory + key : key;

            for (int i = 0; i < this.Items.Count; i++)
            {
                string comboBoxItemText = string.IsNullOrEmpty(this.DisplayMemberPath) ? ((ComboBoxItem)this.Items[i]).Content.ToString() : PropertyReflector.Instance.GetValue(_ComboBoxItemValues[(ComboBoxItem)this.Items[i]], this.DisplayMemberPath).ToString();
                if (comboBoxItemText.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase))
                {
                    this.SelectedIndex = i;
                    _SearchHistory = searchString;
                    _SearchHistoryTimestamp = DateTime.Now;
                    return;
                }
            }

            ResetSearch();   
        }

        private void ResetSearch()
        {
            _SearchHistory = string.Empty;
            _SearchHistoryTimestamp = DateTime.MinValue;
        }
    }

    /// <summary> 
    /// Helps to get and set property values on objects through reflection. 
    /// Properties of underlying objects can be accessed directly by separating 
    /// the levels in the hierarchy by dots. 
    /// To get/set the name of an Ancestor, for objects that have a Parent property, 
    /// you could use "Parent.Parent.Parent.Name". 
    /// </summary> 
    internal class PropertyReflector
    {
        private static readonly PropertyReflector _Instance = new PropertyReflector();

        public static PropertyReflector Instance { get { return _Instance; } }

        private const char PropertyNameSeparator = '.';

        private static readonly object[] NoParams = new object[0];
        private static readonly Type[] NoTypeParams = new Type[0];

        private IDictionary<Type, PropertyInfoCache> propertyCache = new Dictionary<Type, PropertyInfoCache>();
        private IDictionary<Type, System.Reflection.ConstructorInfo> constructorCache = new Dictionary<Type, System.Reflection.ConstructorInfo>();

        private PropertyReflector()
        {
        }

        public static bool IsGenericList(Type type)
        {
            foreach (Type testinterface in type.GetInterfaces())
            {
                if (testinterface.IsGenericType)
                {
                    if (testinterface.GetGenericTypeDefinition() == typeof(System.Collections.ICollection))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary> 
        /// Gets the Type of the given property of the given targetType. 
        /// The targetType and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="targetType">the target type which contains the property</param> 
        /// <param name="propertyName">the property to get, can be a property on a nested object (eg. "Child.Name")</param>

        public Type GetType(Type targetType, string propertyName)
        {
            if (propertyName.IndexOf(PropertyNameSeparator) > -1)
            {
                string[] propertyList = propertyName.Split(PropertyNameSeparator);
                for (int i = 0; i < propertyList.Length; i++)
                {
                    string currentProperty = propertyList[i];
                    targetType = GetTypeImpl(targetType, currentProperty);
                }
                return targetType;
            }
            else
            {
                return GetTypeImpl(targetType, propertyName);
            }

        }

        /// <summary> 
        /// Gets the value of the given property of the given target. 
        /// If objects within the property hierarchy are null references, null will be returned. 
        /// The target and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="target">the target object to get the value from</param> 
        /// <param name="propertyName">the property to get, can be a property on a nested object (eg. "Child.Name")</param>


        public object GetValue(object target, string propertyName)
        {
            if (propertyName.IndexOf(PropertyNameSeparator) > -1)
            {
                string[] propertyList = propertyName.Split(PropertyNameSeparator);
                for (int i = 0; i < propertyList.Length; i++)
                {
                    string currentProperty = propertyList[i];

                    //Check for Index here
                    int startindex = currentProperty.IndexOf('[');
                    if (startindex > -1)
                    {
                        int index = 0;
                        //Get Index
                        string indexstring = currentProperty.Substring(startindex + 1, currentProperty.IndexOf(']') - (startindex + 1));
                        string collectionname = currentProperty.Substring(0, startindex);

                        System.Reflection.PropertyInfo propertyInfo = GetPropertyInfo(target.GetType(), collectionname);
                        if (propertyInfo != null && typeof(System.Collections.IEnumerable).IsAssignableFrom(propertyInfo.PropertyType))
                        {
                            var test = GetValueImpl(target, collectionname);

                            if (Int32.TryParse(indexstring, out index))
                            {
                                target = GetElementAt(test, index);
                            }
                        }
                    }
                    else
                    {
                        target = GetValueImpl(target, currentProperty);
                    }


                    if (target == null)
                    {
                        return null;
                    }
                }
                return target;
            }
            else
            {
                return GetValueImpl(target, propertyName);
            }
        }

        private object GetElementAt(object target, int index)
        {
            Type tObject = target.GetType();
            Type t = tObject.GetGenericArguments()[0];

            Type tIEnumerable = typeof(IEnumerable<>).MakeGenericType(t);

            System.Reflection.MethodInfo mElementAt =
                typeof(Enumerable)
                .GetMethod("ElementAt")
                .MakeGenericMethod(t);

            return mElementAt.Invoke(null, new Object[] { target, index });
        }

        /// <summary> 
        /// Sets the value of the given property on the given target to the given value. 
        /// If objects within the property hierarchy are null references, an attempt will be 
        /// made to construct a new instance through a parameterless constructor. 
        /// The target and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="target">the target object to set the value on</param> 
        /// <param name="propertyName">the property to set, can be a property on a nested object (eg. "Child.Name")</param>

        /// <param name="value">the new value of the property</param> 
        public void SetValue(object target, string propertyName, object value)
        {
            if (propertyName.IndexOf(PropertyNameSeparator) > -1)
            {
                object originalTarget = target;
                string[] propertyList = propertyName.Split(PropertyNameSeparator);
                for (int i = 0; i < propertyList.Length - 1; i++)
                {
                    propertyName = propertyList[i];
                    target = GetValueImpl(target, propertyName);
                    if (target == null)
                    {
                        string currentFullPropertyNameString = GetPropertyNameString(propertyList, i);
                        target = Construct(GetType(originalTarget.GetType(), currentFullPropertyNameString));
                        SetValue(originalTarget, currentFullPropertyNameString, target);
                    }
                }
                propertyName = propertyList[propertyList.Length - 1];
            }
            SetValueImpl(target, propertyName, value);
        }

        /// <summary> 
        /// Returns a string containing the properties in the propertyList up to the given 
        /// level, separated by dots. 
        /// For the propertyList { "Zero", "One", "Two" } and level 1, the string 
        /// "Zero.One" will be returned. 
        /// </summary> 
        /// <param name="propertyList">the array containing the properties in the corect order</param> 
        /// <param name="level">the level up to wich to include the properties in the returned string</param> 
        /// <returns>a dot-separated string containing the properties up to the given level</returns> 
        private static string GetPropertyNameString(string[] propertyList, int level)
        {
            System.Text.StringBuilder currentFullPropertyName = new System.Text.StringBuilder();
            for (int j = 0; j <= level; j++)
            {
                if (j > 0)
                {
                    currentFullPropertyName.Append(PropertyNameSeparator);
                }
                currentFullPropertyName.Append(propertyList[j]);
            }
            return currentFullPropertyName.ToString();
        }

        /// <summary> 
        /// Returns the type of the given property on the target instance. 
        /// The type and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="targetType">the type of the target instance</param> 
        /// <param name="propertyName">the property to retrieve the type for</param> 
        /// <returns>the typr of the given property on the target type</returns> 
        private Type GetTypeImpl(Type targetType, string propertyName)
        {
            return GetPropertyInfo(targetType, propertyName).PropertyType;
        }

        /// <summary> 
        /// Returns the value of the given property on the target instance. 
        /// The target instance and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="target">the instance on which to get the value</param> 
        /// <param name="propertyName">the property for which to get the value</param> 
        /// <returns>the value of the given property on the target instance</returns> 
        private object GetValueImpl(object target, string propertyName)
        {
            return GetPropertyInfo(target.GetType(), propertyName).GetValue(target, NoParams);
        }

        /// <summary> 
        /// Sets the given property of the target instance to the given value. 
        /// Type mismatches in the parameters of these methods will result in an exception. 
        /// Also, the target instance and propertyName parameters can't be null. 
        /// </summary> 
        /// <param name="target">the instance to set the value on</param> 
        /// <param name="propertyName">the property to set the value on</param> 
        /// <param name="value">the value to set on the target</param> 
        private void SetValueImpl(object target, string propertyName, object value)
        {
            GetPropertyInfo(target.GetType(), propertyName).SetValue(target, value, NoParams);
        }

        /// <summary> 
        /// Obtains the PropertyInfo for the given propertyName of the given type from the cache. 
        /// If it is not already in the cache, the PropertyInfo will be looked up and added to 
        /// the cache. 
        /// </summary> 
        /// <param name="type">the type to resolve the property on</param> 
        /// <param name="propertyName">the name of the property to return the PropertyInfo for</param> 
        /// <returns></returns> 
        private System.Reflection.PropertyInfo GetPropertyInfo(Type type, string propertyName)
        {
            PropertyInfoCache propertyInfoCache = GetPropertyInfoCache(type);
            if (!propertyInfoCache.ContainsKey(propertyName))
            {
                System.Reflection.PropertyInfo propertyInfo = GetBestMatchingProperty(propertyName, type);
                if (propertyInfo == null)
                {
                    throw new ArgumentException(string.Format("Unable to find public property named {0} on type {1}", propertyName, type.FullName), propertyName);

                }
                propertyInfoCache.Add(propertyName, propertyInfo);
            }
            return propertyInfoCache[propertyName];
        }

        /// <summary> 
        /// Gets the best matching property info for the given name on the given type if the same property is defined on 
        /// multiple levels in the object hierarchy. 
        /// </summary> 
        private static System.Reflection.PropertyInfo GetBestMatchingProperty(string propertyName, Type type)
        {
            System.Reflection.PropertyInfo[] propertyInfos = type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.FlattenHierarchy);

            System.Reflection.PropertyInfo bestMatch = null;
            int bestMatchDistance = int.MaxValue;
            for (int i = 0; i < propertyInfos.Length; i++)
            {
                System.Reflection.PropertyInfo info = propertyInfos[i];
                if (info.Name == propertyName)
                {
                    int distance = CalculateDistance(type, info.DeclaringType);
                    if (distance == 0)
                    {
                        // as close as we're gonna get... 
                        return info;
                    }
                    if (distance > 0 && distance < bestMatchDistance)
                    {
                        bestMatch = info;
                        bestMatchDistance = distance;
                    }
                }
            }
            return bestMatch;
        }

        /// <summary> 
        /// Calculates the hierarchy levels between two classes. 
        /// If the targetObjectType is the same as the baseType, the returned distance will be 0. 
        /// If the two types do not belong to the same hierarchy, -1 will be returned. 
        /// </summary> 
        private static int CalculateDistance(Type targetObjectType, Type baseType)
        {
            if (!baseType.IsInterface)
            {
                Type currType = targetObjectType;
                int level = 0;
                while (currType != null)
                {
                    if (baseType == currType)
                    {
                        return level;
                    }
                    currType = currType.BaseType;
                    level++;
                }
            }
            return -1;
        }

        /// <summary> 
        /// Returns the PropertyInfoCache for the given type. 
        /// If there isn't one available already, a new one will be created. 
        /// </summary> 
        /// <param name="type">the type to retrieve the PropertyInfoCache for</param> 
        /// <returns>the PropertyInfoCache for the given type</returns> 
        private PropertyInfoCache GetPropertyInfoCache(Type type)
        {
            if (!propertyCache.ContainsKey(type))
            {
                lock (this)
                {
                    if (!propertyCache.ContainsKey(type))
                    {
                        propertyCache.Add(type, new PropertyInfoCache());
                    }
                }
            }
            return propertyCache[type];
        }

        /// <summary> 
        /// Creates a new object of the given type, provided that the type has a default (parameterless) 
        /// constructor. If it does not have such a constructor, an exception will be thrown. 
        /// </summary> 
        /// <param name="type">the type of the object to construct</param> 
        /// <returns>a new instance of the given type</returns> 
        private object Construct(Type type)
        {
            if (!constructorCache.ContainsKey(type))
            {
                lock (this)
                {
                    if (!constructorCache.ContainsKey(type))
                    {
                        System.Reflection.ConstructorInfo constructorInfo = type.GetConstructor(NoTypeParams);
                        if (constructorInfo == null)
                        {
                            throw new Exception(string.Format("Unable to construct instance, no parameterless constructor found in type {0}", type.FullName));

                        }
                        constructorCache.Add(type, constructorInfo);
                    }
                }
            }
            return constructorCache[type].Invoke(NoParams);
        }
    }

    /// <summary> 
    /// Keeps a mapping between a string and a PropertyInfo instance. 
    /// Simply wraps an IDictionary and exposes the relevant operations. 
    /// Putting all this in a separate class makes the calling code more 
    /// readable. 
    /// </summary> 
    internal class PropertyInfoCache
    {
        private IDictionary<string, System.Reflection.PropertyInfo> propertyInfoCache;

        public PropertyInfoCache()
        {
            propertyInfoCache = new Dictionary<string, System.Reflection.PropertyInfo>();
        }

        public bool ContainsKey(string key)
        {
            return propertyInfoCache.ContainsKey(key);
        }

        public void Add(string key, System.Reflection.PropertyInfo value)
        {
            propertyInfoCache.Add(key, value);
        }

        public System.Reflection.PropertyInfo this[string key]
        {
            get { return propertyInfoCache[key]; }
            set { propertyInfoCache[key] = value; }
        }
    }
}

modified on Monday, September 20, 2010 12:54 PM

I actually solved it by inheriting the ComboBox. The search part of my combobox looks like this:

public string TextSearchValue { get; set; }

public ComboBoxClassic()
{
  SelectionChanged += ComboBoxClassicSelectionChanged;
  KeyDown += KeyPressSearch;
  DropDownClosed += (o, args) =>
                    {
                      _keyboardSearch = "|";
                      foreach (object item in Items)
                      {
                        ComboBoxItem comboBoxItem = (ComboBoxItem)ItemContainerGenerator.ContainerFromItem(item);
                        if (comboBoxItem != null)
                        {
                          comboBoxItem.KeyUp -= KeyPressSearch;
                        }
                      }
                    };
  DropDownOpened += (o, args) =>
                    {
                      _keyboardSearch = "|";
                      foreach (object item in Items)
                      {
                        ComboBoxItem comboBoxItem = (ComboBoxItem)ItemContainerGenerator.ContainerFromItem(item);
                        if (comboBoxItem != null)
                        {
                          comboBoxItem.KeyUp += KeyPressSearch;
                        }
                      }
                    };
}


private void KeyPressSearch(object sender, KeyEventArgs e)
{
  string key = e.Key.ToString();
  if (key.Length > 1)
  {
    if (key.StartsWith("D") || key.StartsWith("NumPad"))
    {
      key = key.Replace("NumPad", "").Replace("D", "");
    }
    else
    {
      _keyboardSearch = "|";
      return;
    }
  }
  string searchHistoryPartsString = _keyboardSearch ?? "|";
  string[] searchHistoryParts = searchHistoryPartsString.Split('|');
  const int historyExpiration = 1500;

  string searchStringHistory = searchHistoryParts.Length == 2 ? searchHistoryParts[0] : "";
  string searchStringTimeStampString = searchHistoryParts.Length == 2 ? searchHistoryParts[1] : "";
  DateTime searchStringTimeStamp;
  string searchString;

  if (DateTime.TryParse(searchStringTimeStampString, out searchStringTimeStamp)
    && (DateTime.Now.Subtract(searchStringTimeStamp).TotalMilliseconds < historyExpiration))
  {
    searchString = searchStringHistory + key;
  }
  else
  {
    searchString = key;
  }

  for(int i=0; i<Items.Count; i++)
  {
    var item = Items[i];
    var text = item.GetType().GetProperty(TextSearchValue).GetValue(item, null) as string;

    if (text != null && text.StartsWith(searchString, StringComparison.InvariantCultureIgnoreCase))
    {
      SelectedIndex = i;
      _keyboardSearch = searchString + "|" + DateTime.Now;
      break;
    }
  }
}

This works for a combobox used like this in xaml:

<hc:ComboBoxClassic Grid.Row="8" Grid.Column="1" x:Name="countryComboBoxClassic" TextSearchValue="Country1"  SelectionChanged="ValidateContents" SelectedValuePath="CountryId" SelectedValue="{Binding Profile.CountryId, Mode=TwoWay}" Margin="3" Padding="6,2,25,2" Height="24">
    <hc:ComboBoxClassic.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding Country1}" />
            </StackPanel>
        </DataTemplate>
    </hc:ComboBoxClassic.ItemTemplate>
</hc:ComboBoxClassic>

The thing to note here is the use of TextSearchValue, that tells the text search method the name of the property containing the string to find. The other thing to note is the use of ItemTemplate.

Alishah,

How Can I make this work with a custom type? It is not possible to override ToString.

for instance I am loading customers from my customer table into the combobox via RIA Services. I would like the combo box to search on the customer name field.

Any ideas?

Russ

What is the Content of each ComboBoxItem? If it's a "Customer" object, then you should be able to modify this like so:

public static void SetKeyboardSelection(this ComboBox comboBox, bool enable)
    {
    ...
                object content = ((ComboBoxItem)comboBox.Items[i]).Content;
                if (comboBox.Items[i].GetType() == typeof(ComboBoxItem) &&
                    ((ComboBoxItem)comboBox.Items[i]).Equals(searchString))
                {
                    comboBox.SelectedIndex = i;
                    comboBox.Tag = searchStringEnabled + "|" + searchString + "|" + DateTime.Now;
                    break;
                }
            }
    ...
}

Then what you'll want to do overload Equals() in your Customer class in the following way:

public override bool Equals(System.Object obj)
{
    if (obj==null)
    {
        return false;
    }

    return this.Name.StartsWith((string)obj, StringComparison.InvariantCultureIgnoreCase);
}

Here's some important guidelines about overloading Equals in .NET:
http://msdn.microsoft.com/en-us/library/ms173147(VS.80).aspx

Pay attention particularly to:
"It is recommended that any class that overrides Equals also override System.Object.GetHashCode. It is also recommended that in addition to implementing Equals(object), any class also implement Equals(type) for their own type, to enhance performance."

Another option:

You could use your own custom method, and avoid overloading the Equals method - you could then call the right one with some type analysis:

object content = ((ComboBoxItem)comboBox.Items[i]).Content;
if (comboBox.Items[i].GetType() == typeof(ComboBoxItem))
{
    if (content==typeof(Customer)) {
       ...
    } else if (content==typeof(string)) {
       ...
    }
}

Hope that helps!

Hi,
I have a combobox in my project and I need to access it from keyboard - your code will help me accessing the items via keyboard, but how I can open the combobox from keyboard too, for example, if I press C key in the keyboard the combobox will open,

any help??

This isn't really related to what I've outlined in this article, but all you would need to do is have the control capture key strokes with the KeyDown or the KeyUp event, and then perform the desired action.

In your case, you'd want something like:

MyComboBox.KeyUp += delegate(object sender, KeyEventArgs e)
{
  if (e.Key == Key.A && !MyComboBox.IsDropDownOpen)
  {
    MyComboBox.IsDropDownOpen = true;
  }
};

OMG!! I didn't thought its simple and straightforward like this!!! I'm newbie to Silverlight Smile | :)

Thank you very much!

Great job done

A Keyboard Selection Enabled ComboBox in Silverlight

Introduction

Background

Using the Code

Points of Interest

History

License

Comments and Discussions