/// <inheritdoc />
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var input = (string)value; // a ctrl+b ctrl+alt+c space
var items = input.Split(' ');
var rv = new List <Gesture>();
foreach (var item in items)
{
var pair = item.Split('+');
var modifier = ModifierKeys.None;
var key = Key.None;
try
{
modifier = (ModifierKeys)_modifierKeysConverter.ConvertFrom(item);
}
catch (NotSupportedException e)
{
if (pair.Length > 1)
{
var stringModifier = string.Join("+", pair.Take(pair.Length - 1));
modifier = (ModifierKeys)_modifierKeysConverter.ConvertFrom(stringModifier);
}
key = (Key)_keyConverter.ConvertFrom(pair.Last());
}
var gesture = new Gesture(key, modifier);
if (gesture.IsValid())
{
rv.Add(gesture);
}
}
return(rv.Count > 0 ? new MultiKeyGesture(rv) : null);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var keyStrokes = (value as string).Split(',');
List <KeyGesture> gestures = new List <KeyGesture>();
for (var i = 0; i < keyStrokes.Length; i++)
{
String keyStroke = keyStrokes[i];
if (keyStroke.Contains('+'))
{
Key k = this.ConvertKey(keyStroke.Substring(keyStroke.IndexOf('+') + 1));
ModifierKeys modifier = (ModifierKeys)_modifierKeysConverter.ConvertFrom(keyStroke.Substring(0, keyStroke.IndexOf('+')));
if (modifier != ModifierKeys.Shift)
{
gestures.Add(new KeyGesture(k, modifier));
}
else
{
gestures.Add(new ShiftKeyGesture(k));
}
}
else
{
gestures.Add(new UnmodifiedKeyGesture(this.ConvertKey(keyStroke)));
}
}
return(new ComplexInputGesture(gestures, value.ToString()));
}
public static HotKey Str2HotKey(string s)
{
try
{
if (string.IsNullOrEmpty(s))
{
return(null);
}
int offset = s.LastIndexOf("+", StringComparison.OrdinalIgnoreCase);
if (offset <= 0)
{
return(null);
}
string modifierStr = s.Substring(0, offset).Trim();
string keyStr = s.Substring(offset + 1).Trim();
KeyConverter kc = new KeyConverter();
ModifierKeysConverter mkc = new ModifierKeysConverter();
// ReSharper disable once PossibleNullReferenceException
Key key = (Key)kc.ConvertFrom(keyStr.ToUpper());
// ReSharper disable once PossibleNullReferenceException
ModifierKeys modifier = (ModifierKeys)mkc.ConvertFrom(modifierStr.ToUpper());
return(new HotKey(key, modifier));
}
catch (NotSupportedException)
{
return(null);
}
catch (NullReferenceException)
{
return(null);
}
}
/// <inheritdoc />
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object source)
{
if (source is string stringValue)
{
var fullName = stringValue.Trim();
if (fullName == string.Empty)
{
return(new KeyGestureEx(Key.None));
}
string keyToken;
string modifiersToken;
string displayString;
// break apart display string
var 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;
}
var modifiers = ModifierKeys.None;
var resultkey = keyConverter.ConvertFrom(context, culture, keyToken);
if (resultkey != null)
{
var temp = modifierKeysConverter.ConvertFrom(context, culture, modifiersToken);
if (temp != null)
{
modifiers = (ModifierKeys)temp;
}
return(new KeyGestureEx((Key)resultkey, modifiers, displayString));
}
}
throw this.GetConvertFromException(source);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object source)
{
if ((source != null) && (source is string))
{
string str2;
string str3;
string str4;
string str = ((string)source).Trim();
if (str == string.Empty)
{
return(new UnrestrictedKeyGesture(Key.None));
}
int index = str.IndexOf(',');
if (index >= 0)
{
str4 = str.Substring(index + 1).Trim();
str = str.Substring(0, index).Trim();
}
else
{
str4 = string.Empty;
}
index = str.LastIndexOf('+');
if (index >= 0)
{
str3 = str.Substring(0, index);
str2 = str.Substring(index + 1);
}
else
{
str3 = string.Empty;
str2 = str;
}
ModifierKeys none = ModifierKeys.None;
object obj3 = keyConverter.ConvertFrom(context, culture, str2);
if (obj3 != null)
{
object obj2 = modifierKeysConverter.ConvertFrom(context, culture, str3);
if (obj2 != null)
{
none = (ModifierKeys)obj2;
}
return(new UnrestrictedKeyGesture((Key)obj3, none, str4));
}
}
throw base.GetConvertFromException(source);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var keyStrokes = (value as string).Split(',');
var firstKeyStroke = keyStrokes[0];
var firstKeyStrokeParts = firstKeyStroke.Split('+');
var modifierKeys = (ModifierKeys)_modifierKeysConverter.ConvertFrom(firstKeyStrokeParts[0]);
var keys = new List <Key>();
keys.Add((Key)_keyConverter.ConvertFrom(firstKeyStrokeParts[1]));
for (var i = 1; i < keyStrokes.Length; ++i)
{
keys.Add((Key)_keyConverter.ConvertFrom(keyStrokes[i]));
}
return(new MultiKeyGesture(keys, modifierKeys));
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value != null && value is string source)
{
if (String.IsNullOrWhiteSpace(source))
{
return(KeyCombination.None);
}
string modifiersString, keyString;
// split into modifiers and key
int index = source.LastIndexOf(DELIMITER);
if (index > 0)
{
modifiersString = source.Substring(0, index).Trim();
keyString = source.Substring(index + 1).Trim();
}
else
{
modifiersString = String.Empty;
keyString = source.Trim();
}
var outKey = keyConv.ConvertFrom(context, culture, keyString);
if (outKey != null)
{
if (String.IsNullOrEmpty(modifiersString))
{
return(new KeyCombination((Key)outKey));
}
else
{
var outMod = modifiersConv.ConvertFrom(context, culture, modifiersString);
if (outMod != null)
{
return(new KeyCombination((Key)outKey, (ModifierKeys)outMod));
}
}
}
}
throw GetConvertFromException(value);
}
private static void GetModifiersAndKey(string keyStroke, out ModifierKeys modifiers, out Key key)
{
if (string.IsNullOrEmpty(keyStroke))
{
modifiers = ModifierKeys.None;
key = Key.None;
return;
}
int index = keyStroke.LastIndexOf(ModifiersDelimiter);
if (index == -1)
{
modifiers = ModifierKeys.None;
key = (Key)KeyConverter.ConvertFrom(keyStroke);
}
else
{
string modifierString = keyStroke.Substring(0, index).Trim();
string keyString = keyStroke.Substring(index + 1).Trim();
modifiers = (ModifierKeys)ModifierKeysConverter.ConvertFrom(modifierString);
key = (Key)KeyConverter.ConvertFrom(keyString);
}
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var keyStrokes = (value as string).Split(',');
var firstKeyStroke = keyStrokes[0];
var plusParts = firstKeyStroke.Split('+');
var modifierKeys = ModifierKeys.None;
plusParts.Take(plusParts.Length - 1).ForEach(x => modifierKeys |= (ModifierKeys)_modifierKeysConverter.ConvertFrom(x));
var keys = new List <Key>
{
(Key)_keyConverter.ConvertFrom(plusParts.Last())
};
keyStrokes.Skip(1).ForEach(x => keys.Add((Key)_keyConverter.ConvertFrom(x)));
return(new MultiKeyGesture(keys, modifierKeys));
}
protected virtual ModifierKeys ConvertFrom(string value)
{
ModifierKeysConverter c = new ModifierKeysConverter();
return((ModifierKeys)c.ConvertFrom(value));
}