public void Parse3()
{
var b = KeyBinding.Parse("::f2");
Assert.Equal(Char.MinValue, b.FirstKeyStroke.Char);
Assert.Equal(VimKey.F2, b.FirstKeyStroke.KeyInput.Key);
}
public void Parse6()
{
var b = KeyBinding.Parse("::ctrl+D");
Assert.Equal('d', b.FirstKeyStroke.Char);
Assert.Equal(KeyModifiers.Control, b.FirstKeyStroke.KeyModifiers);
}
public void Parse4()
{
var b = KeyBinding.Parse("::,");
Assert.Equal(',', b.FirstKeyStroke.Char);
Assert.Equal(KeyModifiers.None, b.FirstKeyStroke.KeyModifiers);
}
public void Parse1()
{
var b = KeyBinding.Parse("foo::e");
Assert.Equal("foo", b.Scope);
Assert.Equal('e', b.FirstKeyStroke.KeyInput.Char);
}
public void Parse2()
{
var b = KeyBinding.Parse("::b");
Assert.Equal(String.Empty, b.Scope);
Assert.Equal('b', b.FirstKeyStroke.Char);
}
public void ParseMultiple2()
{
var b = KeyBinding.Parse("::,, f");
Assert.Equal(2, b.KeyStrokes.Count());
Assert.Equal(',', b.KeyStrokes.ElementAt(0).Char);
Assert.Equal('f', b.KeyStrokes.ElementAt(1).Char);
}
public void Parse5()
{
var b = KeyBinding.Parse("::ctrl+shift+f");
Assert.Equal('f', b.FirstKeyStroke.Char);
Assert.True(0 != (KeyModifiers.Shift & b.FirstKeyStroke.KeyModifiers));
Assert.True(0 != (KeyModifiers.Control & b.FirstKeyStroke.KeyModifiers));
}
public void Ctor1()
{
var binding = KeyBinding.Parse("Global::Ctrl+Left Arrow");
var command = new CommandKeyBinding(new CommandId(), "Foo", binding);
var data = new KeyBindingData(new ReadOnlyCollection <CommandKeyBinding>(new CommandKeyBinding[] { command }));
Assert.Equal("Ctrl+Left Arrow", data.KeyName);
Assert.False(data.HandledByVsVim);
}
public void Ctor1()
{
var binding = KeyBinding.Parse("Global::Ctrl+Left Arrow");
var command = new CommandKeyBinding("Foo", binding);
var data = new KeyBindingData(new CommandKeyBinding[] { command });
Assert.AreEqual("Ctrl+Left Arrow", data.KeyName);
Assert.IsFalse(data.HandledByVsVim);
}
private CommandId AddRemovedBinding(string keyStroke, string name = "comment")
{
var keyBinding = KeyBinding.Parse(keyStroke);
var commandId = new CommandId(Guid.NewGuid(), 0);
_removedBindingList.Add(new CommandKeyBinding(commandId, name, keyBinding));
_vimApplicationSettings
.Raise(x => x.SettingsChanged += null, new ApplicationSettingsEventArgs());
return(commandId);
}
private static KeyBinding GetKeyBinding(Dictionary <string, string> dic, string name, KeyBinding defaultValue)
{
string stringValue;
if (dic.TryGetValue(name, out stringValue))
{
return(KeyBinding.Parse(stringValue));
}
return(defaultValue);
}
/// <summary>
/// Get conflicting key bindings stored in our application settings
/// </summary>
private void GetKeyBindings()
{
// Construct a list of all fallback commands keys we had to unbind.
// We are only interested in the bindings scoped to text views and global.
_fallbackCommandList = _vimApplicationSettings.RemovedBindings
.Where(binding => IsTextViewBinding(binding))
.Select(binding => new FallbackCommand(
_scopeData.GetScopeKind(binding.KeyBinding.Scope),
KeyBinding.Parse(binding.KeyBinding.CommandString),
binding.Id
))
.ToLookup(fallbackCommand => fallbackCommand.KeyBindings[0].Char);
}
public void Equality1()
{
var value = EqualityUnit
.Create(KeyBinding.Parse("::b"))
.WithEqualValues(KeyBinding.Parse("::b"))
.WithNotEqualValues(KeyBinding.Parse("local::b"))
.WithNotEqualValues(KeyBinding.Parse("::Shift+b"))
.WithNotEqualValues(KeyBinding.Parse("::Left Arrow"));
EqualityUtil.RunAll(
(x, y) => x == y,
(x, y) => x != y,
values: value);
}
static MiscTest()
{
var list = new List <CommandKeyBinding>();
var commandId = new CommandId(Guid.NewGuid(), 42);
var name = "Name";
foreach (var bindingText in KeyBindingTest.SampleCommands)
{
var keyBinding = KeyBinding.Parse(bindingText);
var commandKeyBinding = new CommandKeyBinding(commandId, name, keyBinding);
list.Add(commandKeyBinding);
}
CommandKeyBindings = list;
}
public void KeyBindings()
{
var id = new CommandId(Guid.NewGuid(), 42);
var keyBinding1 = KeyBinding.Parse("Global::Enter");
var keyBinding2 = KeyBinding.Parse("Global::h");
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
false,
EqualityUnit.Create(new CommandKeyBinding(id, "Test", keyBinding1))
.WithEqualValues(new CommandKeyBinding(id, "Test", keyBinding1))
.WithNotEqualValues(new CommandKeyBinding(id, "Test", keyBinding2)));
}
public void CommandId()
{
var id1 = new CommandId(Guid.NewGuid(), 42);
var id2 = new CommandId(id1.Group, 13);
var id3 = new CommandId(Guid.NewGuid(), 42);
var keyBinding = KeyBinding.Parse("Global::Enter");
EqualityUtil.RunAll(
(left, right) => left == right,
(left, right) => left != right,
false,
false,
EqualityUnit.Create(new CommandKeyBinding(id1, "Test", keyBinding))
.WithEqualValues(new CommandKeyBinding(id1, "Test", keyBinding))
.WithNotEqualValues(new CommandKeyBinding(id2, "Test", keyBinding))
.WithNotEqualValues(new CommandKeyBinding(id3, "Test", keyBinding)));
}
/// <summary>
/// Version 1.4.0 of VsVim introduced a bug which would strip the Visual Studio mappings for the
/// Enter and Backspace key if the user ran the key bindings dialog. This meant that neither key
/// would work in places that VsVim didn't run (immediate window, command window, etc ...). This
/// bug is fixed so that it won't happen going forward. But we need to fix machines that we already
/// messed up with the next install
/// </summary>
internal void FixKeyMappingIssue()
{
if (_vimApplicationSettings.KeyMappingIssueFixed)
{
return;
}
try
{
// Make sure we write out the string for the localized scope name
var globalScopeName = _scopeData.GlobalScopeName;
foreach (var command in _dte.Commands.GetCommands())
{
CommandId commandId;
if (!command.TryGetCommandId(out commandId))
{
continue;
}
if (VSConstants.VSStd2K == commandId.Group)
{
switch ((VSConstants.VSStd2KCmdID)commandId.Id)
{
case VSConstants.VSStd2KCmdID.RETURN:
if (!command.GetBindings().Any())
{
command.SafeSetBindings(KeyBinding.Parse(globalScopeName + "::Enter"));
}
break;
case VSConstants.VSStd2KCmdID.BACKSPACE:
if (!command.GetBindings().Any())
{
command.SafeSetBindings(KeyBinding.Parse(globalScopeName + "::Bkspce"));
}
break;
}
}
}
}
finally
{
_vimApplicationSettings.KeyMappingIssueFixed = true;
}
}
/// <summary>
/// Get conflicting key bindings stored in our application settings
/// </summary>
private void GetKeyBindings()
{
// Construct a list of all fallback commands keys we had to unbind.
// We are only interested in the bindings scoped to text views and
// consisting of a single keystroke. Sort the bindings in order of
// more specific bindings first
_fallbackCommandList = _vimApplicationSettings.RemovedBindings
.Where(binding => IsTextViewBinding(binding))
.Select(binding => Tuple.Create(
binding.KeyBinding.Scope,
KeyBinding.Parse(binding.KeyBinding.CommandString),
binding.Id
))
.Where(tuple => tuple.Item2.KeyStrokes.Count == 1)
.OrderBy(tuple => GetScopeOrder(tuple.Item1))
.Select(tuple => new FallbackCommand(
tuple.Item2.FirstKeyStroke.AggregateKeyInput,
tuple.Item3
))
.ToList();
}
public void VsKeyBackSpace()
{
var b = KeyBinding.Parse("::Bkspce");
Assert.Equal(VimKey.Back, b.FirstKeyStroke.KeyInput.Key);
}
public void ParseMultiple1()
{
var b = KeyBinding.Parse("::e, f");
Assert.Equal(2, b.KeyStrokes.Count());
}
public void BadParse2()
{
Assert.Throws <ArgumentException>(() => KeyBinding.Parse("::ctrl+notavalidkey"));
}
public void VsNum2()
{
var b = KeyBinding.Parse("::Num *");
Assert.Equal(VimKey.KeypadMultiply, b.FirstKeyStroke.Key);
}
public void VsKeyRightArrow()
{
var b = KeyBinding.Parse("::Right Arrow");
Assert.Equal(VimKey.Right, b.FirstKeyStroke.KeyInput.Key);
}
public void VsNum1()
{
var b = KeyBinding.Parse("::Num +");
Assert.Equal(VimKey.KeypadPlus, b.FirstKeyStroke.Key);
}
public void VsKeyPageUp()
{
var b = KeyBinding.Parse("::PgUp");
Assert.Equal(VimKey.PageUp, b.FirstKeyStroke.Key);
}
public void VsKeyPageDown()
{
var b = KeyBinding.Parse("::PgDn");
Assert.Equal(VimKey.PageDown, b.FirstKeyStroke.Key);
}
public void VsKeyDownArrow2()
{
var b = KeyBinding.Parse("::Shift+Down Arrow");
Assert.Equal(VimKey.Down, b.FirstKeyStroke.Key);
}
public void VsKeyUpArrow()
{
var b = KeyBinding.Parse("::Up Arrow");
Assert.Equal(VimKey.Up, b.FirstKeyStroke.Key);
}
public void VsKeyLeftArrow()
{
var b = KeyBinding.Parse("::Left Arrow");
Assert.Equal(VimKey.Left, b.FirstKeyStroke.Key);
}
public void BadParse2()
{
KeyBinding.Parse("::ctrl+notavalidkey");
}