public void Tab_WithShift()
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.TabKey, VimKeyModifiers.Shift);
Assert.Equal(VimKeyModifiers.Shift, keyInput.KeyModifiers);
VerifyConvert(VSConstants.VSStd2KCmdID.TAB, VimKeyModifiers.Shift, keyInput, EditCommandKind.UserInput);
}
public void DoubleApplyControl()
{
var keyInput1 = KeyInputUtil.CharWithControlToKeyInput(';');
var keyInput2 = KeyInputUtil.ApplyKeyModifiers(keyInput1, VimKeyModifiers.Control);
Assert.Equal(keyInput1, keyInput2);
}
public void UpperCase()
{
var keyInput = KeyInputUtil.CharToKeyInput('A');
Assert.Equal(keyInput, KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput('a'), VimKeyModifiers.Shift));
Assert.Equal(keyInput, KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput('A'), VimKeyModifiers.Shift));
}
public void Less()
{
var left = KeyInputUtil.CharWithControlToKeyInput('c');
var right = KeyInputUtil.ApplyKeyModifiers(left, VimKeyModifiers.None);
Assert.Equal(left, right);
}
public void ShiftToTab()
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.TabKey, VimKeyModifiers.Shift);
Assert.Equal(VimKeyModifiers.Shift, keyInput.KeyModifiers);
Assert.Equal(VimKey.Tab, keyInput.Key);
Assert.Equal('\t', keyInput.Char);
}
public void CharWithControlToKeyInput_Alpha()
{
foreach (var cur in CharLettersLower)
{
var left = KeyInputUtil.CharWithControlToKeyInput(cur);
var right = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput(cur), VimKeyModifiers.Control);
Assert.Equal(right, left);
}
}
public void ShiftToSpecialChar()
{
var list = new[] { '<', '>', '(', '}' };
foreach (var cur in list)
{
var keyInput = KeyInputUtil.CharToKeyInput(cur);
keyInput = KeyInputUtil.ApplyKeyModifiers(keyInput, VimKeyModifiers.Shift);
Assert.Equal(VimKeyModifiers.None, keyInput.KeyModifiers);
}
}
public void AltMirror()
{
const string expected = "\u00C1\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6\u00B7\u00B8\u00B9";
const string source = "A0123456789";
for (var i = 0; i < source.Length; i++)
{
var left = KeyInputUtil.CharToKeyInput(expected[i]);
var right = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput(source[i]), VimKeyModifiers.Alt);
Assert.Equal(left, right);
}
}
public void AltMirror()
{
const string expected = "Á°±²³´µ¶·¸¹";
const string source = "A0123456789";
for (var i = 0; i < source.Length; i++)
{
var left = KeyInputUtil.CharToKeyInput(expected[i]);
var right = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput(source[i]), VimKeyModifiers.Alt);
Assert.Equal(left, right);
}
}
bool IKeyUtil.TryConvertSpecialToKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
{
if (s_wpfKeyToKeyInputMap.TryGetValue(key, out keyInput))
{
var keyModifiers = ConvertToKeyModifiers(modifierKeys);
keyInput = KeyInputUtil.ApplyKeyModifiers(keyInput, keyModifiers);
return(true);
}
keyInput = null;
return(false);
}
/// <summary>
/// Last chance at custom handling of user input. At this point we have the
/// advantage that WPF has properly converted the user input into a char which
/// can be effeciently mapped to a KeyInput value.
/// </summary>
public override void TextInput(TextCompositionEventArgs args)
{
VimTrace.TraceInfo("VimKeyProcessor::TextInput Text={0} ControlText={1} SystemText={2}",
StringUtil.GetDisplayString(args.Text),
StringUtil.GetDisplayString(args.ControlText),
StringUtil.GetDisplayString(args.SystemText));
var handled = false;
var text = args.Text;
if (string.IsNullOrEmpty(text))
{
text = args.ControlText;
}
if (!string.IsNullOrEmpty(text))
{
// In the case of a failed dead key mapping (pressing the accent key twice for
// example) we will recieve a multi-length string here. One character for every
// one of the mappings. Make sure to handle each of them
for (var i = 0; i < text.Length; i++)
{
var keyInput = KeyInputUtil.CharToKeyInput(text[i]);
handled = TryProcess(keyInput);
}
}
else if (!string.IsNullOrEmpty(args.SystemText))
{
// The system text needs to be processed differently than normal text. When 'a'
// is pressed with control it will come in as control text as the proper control
// character. When 'a' is pressed with Alt it will come in as simply 'a' and we
// have to rely on the currently pressed key modifiers to determine the appropriate
// character
var keyboardDevice = args.Device as KeyboardDevice;
var keyModifiers = keyboardDevice != null
? _keyUtil.GetKeyModifiers(keyboardDevice.Modifiers)
: VimKeyModifiers.Alt;
text = args.SystemText;
for (var i = 0; i < text.Length; i++)
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.CharToKeyInput(text[i]), keyModifiers);
handled = TryProcess(keyInput);
}
}
VimTrace.TraceInfo("VimKeyProcessor::TextInput Handled={0}", handled);
args.Handled = handled;
base.TextInput(args);
}
public void ControlToAlpha()
{
var baseCharCode = 0x1;
for (var i = 0; i < CharLettersLower.Length; i++)
{
var target = (char)(baseCharCode + i);
var keyInput = KeyInputUtil.CharToKeyInput(CharLettersLower[i]);
var found = KeyInputUtil.ApplyKeyModifiers(keyInput, VimKeyModifiers.Control);
Assert.Equal(target, found.Char);
Assert.Equal(VimKeyModifiers.None, found.KeyModifiers);
}
}
public void ShiftToNonSpecialChar()
{
var list = new[]
{
KeyInputUtil.VimKeyToKeyInput(VimKey.Back),
KeyInputUtil.VimKeyToKeyInput(VimKey.Escape),
KeyInputUtil.TabKey
};
foreach (var current in list)
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(current, VimKeyModifiers.Shift);
Assert.Equal(VimKeyModifiers.Shift, keyInput.KeyModifiers);
}
}
internal static bool TryConvert(Guid commandGroup, uint commandId, IntPtr pVariableIn, VimKeyModifiers modifiers, out EditCommand command)
{
if (!TryConvert(commandGroup, commandId, pVariableIn, out KeyInput keyInput, out EditCommandKind kind, out bool isRawText))
{
command = null;
return(false);
}
// When raw text is provided it already includes the active keyboard modifiers. Don't reapply them
// here else it can incorrectly modify the provided character.
if (!isRawText && keyInput != KeyInput.DefaultValue)
{
keyInput = KeyInputUtil.ApplyKeyModifiers(keyInput, modifiers);
}
command = new EditCommand(keyInput, kind, commandGroup, commandId);
return(true);
}
public void BackTab()
{
VerifyConvert(VSConstants.VSStd2KCmdID.BACKTAB, KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.TabKey, VimKeyModifiers.Shift), EditCommandKind.UserInput);
}
private void VerifyConvertWithShift(VSConstants.VSStd2KCmdID cmd, VimKey vimKey, EditCommandKind kind)
{
var keyInput = KeyInputUtil.ApplyKeyModifiers(KeyInputUtil.VimKeyToKeyInput(vimKey), VimKeyModifiers.Shift);
VerifyConvert(cmd, keyInput, kind);
}
private static KeyInput ApplyModifiers(char c, VimKeyModifiers keyModifiers)
{
var keyInput = KeyInputUtil.CharToKeyInput(c);
return(KeyInputUtil.ApplyKeyModifiers(keyInput, keyModifiers));
}
public void GetKeyInput_PoundWithShift()
{
var keyInput = KeyInputUtil.CharToKeyInput('#');
Assert.Equal(keyInput, KeyInputUtil.ApplyKeyModifiers(keyInput, VimKeyModifiers.Shift));
}
bool IKeyUtil.TryConvertSpecialToKeyInput(NSEvent theEvent, out KeyInput keyInput)
{
var key = (NSKey)theEvent.KeyCode;
NSEventModifierMask modifierKeys = theEvent.ModifierFlags;
if (s_CocoaKeyToKeyInputMap.TryGetValue(key, out keyInput))
{
var keyModifiers = ConvertToKeyModifiers(modifierKeys);
keyInput = KeyInputUtil.ApplyKeyModifiers(keyInput, keyModifiers);
return(true);
}
// Vim allows certain "lazy" control keys, such as <C-6> for <C-^>.
if ((modifierKeys == NSEventModifierMask.ControlKeyMask ||
modifierKeys == (NSEventModifierMask.ControlKeyMask | NSEventModifierMask.ShiftKeyMask)) &&
s_CocoaControlKeyToKeyInputMap.TryGetValue(key, out keyInput))
{
return(true);
}
// If the key is not a pure alt or shift key combination and doesn't
// correspond to an ASCII control key (like <C-^>), we need to convert it here.
// This is needed because key combinations like <C-;> won't be passed to
// TextInput, because they can't be represented as system or control text.
// We just have to be careful not to shadow any keys that produce text when
// combined with the AltGr key.
if (modifierKeys != NSEventModifierMask.AlternateKeyMask &&
modifierKeys != NSEventModifierMask.ShiftKeyMask)
{
switch (key)
{
case NSKey.Option:
case NSKey.RightOption:
case NSKey.Control:
case NSKey.RightControl:
case NSKey.Shift:
case NSKey.RightShift:
case NSKey.Command:
// Avoid work for common cases.
break;
default:
VimTrace.TraceInfo("AlternateKeyUtil::TryConvertSpecialKeyToKeyInput {0} {1}",
key, modifierKeys);
if (GetKeyInputFromKey(theEvent, modifierKeys, out keyInput))
{
// Only produce a key input here if the key input we
// found is *not* an ASCII control character.
// Control characters will be handled by TextInput
// as control text.
// Commented out because we are not using TextInput
//if (!System.Char.IsControl(keyInput.Char))
{
return(true);
}
}
break;
}
}
keyInput = null;
return(false);
}
bool IKeyUtil.TryConvertSpecialToKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
{
if (s_wpfKeyToKeyInputMap.TryGetValue(key, out keyInput))
{
var keyModifiers = ConvertToKeyModifiers(modifierKeys);
keyInput = KeyInputUtil.ApplyKeyModifiers(keyInput, keyModifiers);
return(true);
}
// Vim allows certain "lazy" control keys, such as <C-6> for <C-^>.
if ((modifierKeys == ModifierKeys.Control ||
modifierKeys == (ModifierKeys.Control | ModifierKeys.Shift)) &&
s_wpfControlKeyToKeyInputMap.TryGetValue(key, out keyInput))
{
return(true);
}
// If the key is not a pure alt or shift key combination and doesn't
// correspond to an ASCII control key (like <C-^>), we need to convert it here.
// This is needed because key combinations like <C-;> won't be passed to
// TextInput, because they can't be represented as system or control text.
// We just have to be careful not to shadow any keys that produce text when
// combined with the AltGr key.
if (modifierKeys != ModifierKeys.None &&
modifierKeys != ModifierKeys.Alt &&
modifierKeys != ModifierKeys.Shift)
{
switch (key)
{
case Key.LeftAlt:
case Key.RightAlt:
case Key.LeftCtrl:
case Key.RightCtrl:
case Key.LeftShift:
case Key.RightShift:
case Key.System:
// Avoid work for common cases.
break;
default:
VimTrace.TraceInfo("AlternateKeyUtil::TryConvertSpecialKeyToKeyInput {0} {1}",
key, modifierKeys);
if (GetKeyInputFromKey(key, modifierKeys, out keyInput))
{
// Only produce a key input here if the key input we
// found is *not* an ASCII control character.
// Control characters will be handled by TextInput
// as control text.
if (!System.Char.IsControl(keyInput.Char))
{
return(true);
}
}
break;
}
}
keyInput = null;
return(false);
}
