//---------------------------------------------------------------------------
//
// <copyright file="KeyGestureConverter.cs" company="Microsoft">
//    Copyright (C) Microsoft Corporation.  All rights reserved.
// </copyright>
//
//
// Description: KeyGestureConverter - Converts a KeyGesture string
//              to the *Type* that the string represents
//
//
// History:
//  05/01/2004    : Chandrasekhar Rentachintala - Created
//
//---------------------------------------------------------------------------
 
using System;
using System.ComponentModel;    // for TypeConverter
using System.Globalization;     // for CultureInfo
using System.Reflection;
using MS.Internal;
using System.Windows;
using System.Windows.Input;
using MS.Utility;
 
namespace System.Windows.Input
{
    /// <summary>
    /// KeyGesture - Converter class for converting between a string and the Type of a KeyGesture
    /// </summary>
    public class KeyGestureConverter : TypeConverter
    {
        private const char MODIFIERS_DELIMITER = '+' ;
        internal const char DISPLAYSTRING_SEPARATOR = ',' ;
 
        ///<summary>
        ///CanConvertFrom()
        ///</summary>
        ///<param name="context">ITypeDescriptorContext</param>
        ///<param name="sourceType">type to convert from</param>
        ///<returns>true if the given type can be converted, false otherwise</returns>
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            // We can only handle string.
            if (sourceType == typeof(string))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
 
 
        ///<summary>
        ///TypeConverter method override.
        ///</summary>
        ///<param name="context">ITypeDescriptorContext</param>
        ///<param name="destinationType">Type to convert to</param>
        ///<returns>true if conversion	is possible</returns>
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            // We can convert to an InstanceDescriptor or to a string.
            if (destinationType == typeof(string))
            {
                // When invoked by the serialization engine we can convert to string only for known type
                if (context != null && context.Instance != null)
                {
                    KeyGesture keyGesture = context.Instance as KeyGesture;
                    if (keyGesture != null)
                    {
                        return (ModifierKeysConverter.IsDefinedModifierKeys(keyGesture.Modifiers)
                                && IsDefinedKey(keyGesture.Key));
                    }
                }
            }
            return false;
        }
 
        /// <summary>
        /// ConvertFrom()
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="source"></param>
        /// <returns></returns>
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object source)
        {
            if (source != null && source is string)
            {
                string fullName = ((string)source).Trim();
                if (fullName == String.Empty)
                    return new KeyGesture(Key.None);
 
                string keyToken;
                string modifiersToken;
                string displayString;
 
                // break apart display string
                int index = fullName.IndexOf(DISPLAYSTRING_SEPARATOR);
                if (index >= 0)
                {
                    displayString = fullName.Substring(index + 1).Trim();
                    fullName      = fullName.Substring(0, index).Trim();
                }
                else
                {
                    displayString = String.Empty;
                }
 
                // break apart key and modifiers
                index = fullName.LastIndexOf(MODIFIERS_DELIMITER);
                if (index >= 0)
                {   // modifiers exists
                    modifiersToken = fullName.Substring(0, index);
                    keyToken       = fullName.Substring(index + 1);
                }
                else
                {
                    modifiersToken = String.Empty;
                    keyToken       = fullName;
                }
 
                ModifierKeys modifiers = ModifierKeys.None;
                object resultkey = keyConverter.ConvertFrom(context, culture, keyToken);
                if (resultkey != null)
                {
                    object temp = modifierKeysConverter.ConvertFrom(context, culture, modifiersToken);
                    if (temp != null)
                    {
                        modifiers = (ModifierKeys)temp;
                    }
                    return new KeyGesture((Key)resultkey, modifiers, displayString);
                }
            }
            throw GetConvertFromException(source);
        }
 
        /// <summary>
        /// ConvertTo()
        /// </summary>
        /// <param name="context"></param>
        /// <param name="culture"></param>
        /// <param name="value"></param>
        /// <param name="destinationType"></param>
        /// <returns></returns>
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == null)
                throw new ArgumentNullException("destinationType");
 
            if (destinationType == typeof(string))
            {
                if (value != null)
                {
                    KeyGesture keyGesture = value as KeyGesture;
                    if (keyGesture != null)
                    {
                        if (keyGesture.Key == Key.None)
                            return String.Empty;
 
                        string strBinding = "" ;
                        string strKey = (string)keyConverter.ConvertTo(context, culture, keyGesture.Key, destinationType) as string;
                        if (strKey != String.Empty)
                        {
                            strBinding += modifierKeysConverter.ConvertTo(context, culture, keyGesture.Modifiers, destinationType) as string;
                            if (strBinding != String.Empty)
                            {
                                strBinding += MODIFIERS_DELIMITER;
                            }
                            strBinding += strKey;
 
                            if (!String.IsNullOrEmpty(keyGesture.DisplayString))
                            {
                                strBinding += DISPLAYSTRING_SEPARATOR + keyGesture.DisplayString;
                            }
                        }
                        return strBinding;
                    }
                }
                else
                {
                    return String.Empty;
                }
            }
            throw GetConvertToException(value,destinationType);
        }
 
        // Check for Valid enum, as any int can be casted to the enum.
        internal static bool IsDefinedKey(Key key)
        {
            return (key >= Key.None && key <= Key.OemClear);
        }
 
        private static KeyConverter keyConverter = new KeyConverter();
        private static ModifierKeysConverter modifierKeysConverter = new ModifierKeysConverter();
    }
}