From 938f399c85f8b6d18a47bf6dfc750bd540e47df6 Mon Sep 17 00:00:00 2001 From: Alex Dima Date: Mon, 20 Mar 2017 16:52:12 +0100 Subject: [PATCH] Add IKeyboardEvent.resolveKeyboardEvent & more tests --- .../keybinding/common/keyboardEventCode.ts | 18 +- .../keybinding/common/keyboardMapper.ts | 2 + .../common/macLinuxKeyboardMapper.ts | 13 +- .../common/windowsKeyboardMapper.ts | 7 + .../test/keyboardMapperTestUtils.ts | 40 +- .../test/macLinuxKeyboardMapper.test.ts | 506 +++++++++++++++++- .../test/windowsKeyboardMapper.test.ts | 102 +++- 7 files changed, 653 insertions(+), 35 deletions(-) diff --git a/src/vs/workbench/services/keybinding/common/keyboardEventCode.ts b/src/vs/workbench/services/keybinding/common/keyboardEventCode.ts index 168a684c754..64f812e1a79 100644 --- a/src/vs/workbench/services/keybinding/common/keyboardEventCode.ts +++ b/src/vs/workbench/services/keybinding/common/keyboardEventCode.ts @@ -525,7 +525,7 @@ export const IMMUTABLE_CODE_TO_KEY_CODE: KeyCode[] = []; define(KeyboardEventCode.NumpadMultiply, KeyCode.NUMPAD_MULTIPLY); define(KeyboardEventCode.NumpadSubtract, KeyCode.NUMPAD_SUBTRACT); define(KeyboardEventCode.NumpadAdd, KeyCode.NUMPAD_ADD); - define(KeyboardEventCode.NumpadEnter, KeyCode.Enter); // TODO + define(KeyboardEventCode.NumpadEnter, KeyCode.Enter); // Duplicate define(KeyboardEventCode.Numpad1, KeyCode.NUMPAD_1); define(KeyboardEventCode.Numpad2, KeyCode.NUMPAD_2); define(KeyboardEventCode.Numpad3, KeyCode.NUMPAD_3); @@ -588,14 +588,14 @@ export const IMMUTABLE_CODE_TO_KEY_CODE: KeyCode[] = []; define(KeyboardEventCode.NumpadMemorySubtract, KeyCode.Unknown); define(KeyboardEventCode.NumpadClear, KeyCode.Unknown); define(KeyboardEventCode.NumpadClearEntry, KeyCode.Unknown); - define(KeyboardEventCode.ControlLeft, KeyCode.Ctrl); // TODO - define(KeyboardEventCode.ShiftLeft, KeyCode.Shift); // TODO - define(KeyboardEventCode.AltLeft, KeyCode.Alt); // TODO - define(KeyboardEventCode.MetaLeft, KeyCode.Meta); // TODO - define(KeyboardEventCode.ControlRight, KeyCode.Ctrl); // TODO - define(KeyboardEventCode.ShiftRight, KeyCode.Shift); // TODO - define(KeyboardEventCode.AltRight, KeyCode.Alt); // TODO - define(KeyboardEventCode.MetaRight, KeyCode.Meta); // TODO + define(KeyboardEventCode.ControlLeft, KeyCode.Ctrl); // Duplicate + define(KeyboardEventCode.ShiftLeft, KeyCode.Shift); // Duplicate + define(KeyboardEventCode.AltLeft, KeyCode.Alt); // Duplicate + define(KeyboardEventCode.MetaLeft, KeyCode.Meta); // Duplicate + define(KeyboardEventCode.ControlRight, KeyCode.Ctrl); // Duplicate + define(KeyboardEventCode.ShiftRight, KeyCode.Shift); // Duplicate + define(KeyboardEventCode.AltRight, KeyCode.Alt); // Duplicate + define(KeyboardEventCode.MetaRight, KeyCode.Meta); // Duplicate define(KeyboardEventCode.BrightnessUp, KeyCode.Unknown); define(KeyboardEventCode.BrightnessDown, KeyCode.Unknown); define(KeyboardEventCode.MediaPlay, KeyCode.Unknown); diff --git a/src/vs/workbench/services/keybinding/common/keyboardMapper.ts b/src/vs/workbench/services/keybinding/common/keyboardMapper.ts index 6c6f6d419bd..c31a69a2ac3 100644 --- a/src/vs/workbench/services/keybinding/common/keyboardMapper.ts +++ b/src/vs/workbench/services/keybinding/common/keyboardMapper.ts @@ -6,8 +6,10 @@ 'use strict'; import { Keybinding, ResolvedKeybinding } from 'vs/base/common/keyCodes'; +import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding'; export interface IKeyboardMapper { dumpDebugInfo(): string; resolveKeybinding(keybinding: Keybinding): ResolvedKeybinding[]; + resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): ResolvedKeybinding; } diff --git a/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts b/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts index f2dcf364798..e3acb79648b 100644 --- a/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts +++ b/src/vs/workbench/services/keybinding/common/macLinuxKeyboardMapper.ts @@ -12,6 +12,7 @@ import { CharCode } from 'vs/base/common/charCode'; import { IHTMLContentElement } from 'vs/base/common/htmlContent'; import { UILabelProvider, AriaLabelProvider, UserSettingsLabelProvider, ElectronAcceleratorLabelProvider } from 'vs/platform/keybinding/common/keybindingLabels'; import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper'; +import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding'; export interface IKeyMapping { value: string; @@ -605,13 +606,6 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper { // maps to different keyCode return -1; } - - // Check that the inverse is true - const inverse = this._kbToHw[kbEncoded]; - if (inverse.length !== 1) { - // multiple hw keypresses map to this kb - return -1; - } } return constantKeyCode; @@ -645,6 +639,11 @@ export class MacLinuxKeyboardMapper implements IKeyboardMapper { return result; } + public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): NativeResolvedKeybinding { + const keypress = new HardwareKeypress(keyboardEvent.ctrlKey, keyboardEvent.shiftKey, keyboardEvent.altKey, keyboardEvent.metaKey, KeyboardEventCodeUtils.toEnum(keyboardEvent.code)); + return new NativeResolvedKeybinding(this, this._OS, keypress, null); + } + private static _charCodeToKb(charCode: number): { keyCode: KeyCode; shiftKey: boolean } { if (charCode < CHAR_CODE_TO_KEY_CODE.length) { return CHAR_CODE_TO_KEY_CODE[charCode]; diff --git a/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts b/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts index a94f8dd0313..20fd743b548 100644 --- a/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts +++ b/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.ts @@ -12,6 +12,7 @@ import { UILabelProvider, AriaLabelProvider, ElectronAcceleratorLabelProvider, U import { OperatingSystem } from 'vs/base/common/platform'; import { IHTMLContentElement } from 'vs/base/common/htmlContent'; import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper'; +import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding'; export interface IKeyMapping { vkey: string; @@ -346,6 +347,12 @@ export class WindowsKeyboardMapper implements IKeyboardMapper { return [new WindowsNativeResolvedKeybinding(this, keybinding, null)]; } } + + public resolveKeyboardEvent(keyboardEvent: IKeyboardEvent): WindowsNativeResolvedKeybinding { + const keybinding = new SimpleKeybinding(keyboardEvent.ctrlKey, keyboardEvent.shiftKey, keyboardEvent.altKey, keyboardEvent.metaKey, keyboardEvent.keyCode); + return new WindowsNativeResolvedKeybinding(this, keybinding, null); + } + } diff --git a/src/vs/workbench/services/keybinding/test/keyboardMapperTestUtils.ts b/src/vs/workbench/services/keybinding/test/keyboardMapperTestUtils.ts index 404ed562fe2..74675c890b4 100644 --- a/src/vs/workbench/services/keybinding/test/keyboardMapperTestUtils.ts +++ b/src/vs/workbench/services/keybinding/test/keyboardMapperTestUtils.ts @@ -8,10 +8,11 @@ import * as assert from 'assert'; import { IHTMLContentElement } from 'vs/base/common/htmlContent'; import { IKeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper'; -import { Keybinding } from 'vs/base/common/keyCodes'; +import { Keybinding, ResolvedKeybinding } from 'vs/base/common/keyCodes'; import { TPromise } from 'vs/base/common/winjs.base'; import { readFile, writeFile } from 'vs/base/node/pfs'; import { OperatingSystem } from 'vs/base/common/platform'; +import { IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding'; export interface IResolvedKeybinding { label: string; @@ -27,22 +28,29 @@ export interface IResolvedKeybinding { dispatchParts: [string, string]; } +function toIResolvedKeybinding(kb: ResolvedKeybinding): IResolvedKeybinding { + return { + label: kb.getLabel(), + ariaLabel: kb.getAriaLabel(), + HTMLLabel: kb.getHTMLLabel(), + electronAccelerator: kb.getElectronAccelerator(), + userSettingsLabel: kb.getUserSettingsLabel(), + isChord: kb.isChord(), + hasCtrlModifier: kb.hasCtrlModifier(), + hasShiftModifier: kb.hasShiftModifier(), + hasAltModifier: kb.hasAltModifier(), + hasMetaModifier: kb.hasMetaModifier(), + dispatchParts: kb.getDispatchParts(), + }; +} + export function assertResolveKeybinding(mapper: IKeyboardMapper, keybinding: Keybinding, expected: IResolvedKeybinding[]): void { - let actual: IResolvedKeybinding[] = mapper.resolveKeybinding(keybinding).map((kb => { - return { - label: kb.getLabel(), - ariaLabel: kb.getAriaLabel(), - HTMLLabel: kb.getHTMLLabel(), - electronAccelerator: kb.getElectronAccelerator(), - userSettingsLabel: kb.getUserSettingsLabel(), - isChord: kb.isChord(), - hasCtrlModifier: kb.hasCtrlModifier(), - hasShiftModifier: kb.hasShiftModifier(), - hasAltModifier: kb.hasAltModifier(), - hasMetaModifier: kb.hasMetaModifier(), - dispatchParts: kb.getDispatchParts(), - }; - })); + let actual: IResolvedKeybinding[] = mapper.resolveKeybinding(keybinding).map(toIResolvedKeybinding); + assert.deepEqual(actual, expected); +} + +export function assertResolveKeyboardEvent(mapper: IKeyboardMapper, keyboardEvent: IKeyboardEvent, expected: IResolvedKeybinding): void { + let actual = toIResolvedKeybinding(mapper.resolveKeyboardEvent(keyboardEvent)); assert.deepEqual(actual, expected); } diff --git a/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts b/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts index fa0817b1639..332187da8c1 100644 --- a/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts +++ b/src/vs/workbench/services/keybinding/test/macLinuxKeyboardMapper.test.ts @@ -14,7 +14,7 @@ import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayo import { KeyboardEventCodeUtils } from 'vs/workbench/services/keybinding/common/keyboardEventCode'; import { IHTMLContentElement } from 'vs/base/common/htmlContent'; import { TPromise } from 'vs/base/common/winjs.base'; -import { readRawMapping, assertMapping, IResolvedKeybinding, assertResolveKeybinding, simpleHTMLLabel, chordHTMLLabel } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils'; +import { readRawMapping, assertMapping, IResolvedKeybinding, assertResolveKeybinding, simpleHTMLLabel, chordHTMLLabel, assertResolveKeyboardEvent } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils'; function createKeyboardMapper(file: string, OS: OperatingSystem): TPromise { return readRawMapping(file).then((rawMappings) => { @@ -114,6 +114,33 @@ suite('keyboardMapper - MAC de_ch', () => { ); }); + test('resolveKeyboardEvent Cmd+[KeyY]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: false, + shiftKey: false, + altKey: false, + metaKey: true, + keyCode: -1, + code: 'KeyY' + }, + { + label: '⌘Z', + ariaLabel: 'Command+Z', + HTMLLabel: [_simpleHTMLLabel(['⌘', 'Z'])], + electronAccelerator: 'Cmd+Z', + userSettingsLabel: 'cmd+z', + isChord: false, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: true, + dispatchParts: ['meta+[KeyY]', null], + } + ); + }); + test('resolveKeybinding Cmd+]', () => { _assertResolveKeybinding( KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET, @@ -133,6 +160,33 @@ suite('keyboardMapper - MAC de_ch', () => { ); }); + test('resolveKeyboardEvent Cmd+[BracketRight]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: false, + shiftKey: false, + altKey: false, + metaKey: true, + keyCode: -1, + code: 'BracketRight' + }, + { + label: '⌘¨', + ariaLabel: 'Command+¨', + HTMLLabel: [_simpleHTMLLabel(['⌘', '¨'])], + electronAccelerator: null, + userSettingsLabel: 'cmd+[BracketRight]', + isChord: false, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: true, + dispatchParts: ['meta+[BracketRight]', null], + } + ); + }); + test('resolveKeybinding Shift+]', () => { _assertResolveKeybinding( KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET, @@ -265,6 +319,52 @@ suite('keyboardMapper - MAC de_ch', () => { }] ); }); + + test('resolveKeybinding Ctrl+Home', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.Home, + [{ + label: '⌘Home', + ariaLabel: 'Command+Home', + HTMLLabel: [_simpleHTMLLabel(['⌘', 'Home'])], + electronAccelerator: 'Cmd+Home', + userSettingsLabel: 'cmd+home', + isChord: false, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: true, + dispatchParts: ['meta+[Home]', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+[Home]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: false, + shiftKey: false, + altKey: false, + metaKey: true, + keyCode: -1, + code: 'Home' + }, + { + label: '⌘Home', + ariaLabel: 'Command+Home', + HTMLLabel: [_simpleHTMLLabel(['⌘', 'Home'])], + electronAccelerator: 'Cmd+Home', + userSettingsLabel: 'cmd+home', + isChord: false, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: true, + dispatchParts: ['meta+[Home]', null], + } + ); + }); }); suite('keyboardMapper - LINUX de_ch', () => { @@ -351,6 +451,33 @@ suite('keyboardMapper - LINUX de_ch', () => { ); }); + test('resolveKeyboardEvent Ctrl+[KeyY]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'KeyY' + }, + { + label: 'Ctrl+Z', + ariaLabel: 'Control+Z', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])], + electronAccelerator: 'Ctrl+Z', + userSettingsLabel: 'ctrl+z', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyY]', null], + } + ); + }); + test('resolveKeybinding Ctrl+]', () => { _assertResolveKeybinding( KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET, @@ -358,6 +485,33 @@ suite('keyboardMapper - LINUX de_ch', () => { ); }); + test('resolveKeyboardEvent Ctrl+[BracketRight]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'BracketRight' + }, + { + label: 'Ctrl+¨', + ariaLabel: 'Control+¨', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', '¨'])], + electronAccelerator: null, + userSettingsLabel: 'ctrl+[BracketRight]', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[BracketRight]', null], + } + ); + }); + test('resolveKeybinding Shift+]', () => { _assertResolveKeybinding( KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET, @@ -490,9 +644,55 @@ suite('keyboardMapper - LINUX de_ch', () => { }] ); }); + + test('resolveKeybinding Ctrl+Home', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.Home, + [{ + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Home]', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+[Home]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'Home' + }, + { + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Home]', null], + } + ); + }); }); -suite('keyboardMapper - LINUX de_ch', () => { +suite('keyboardMapper - LINUX en_us', () => { let mapper: MacLinuxKeyboardMapper; @@ -506,6 +706,308 @@ suite('keyboardMapper - LINUX de_ch', () => { test('mapping', (done) => { assertMapping(mapper, 'linux_en_us.txt', done); }); + + function _assertResolveKeybinding(k: number, expected: IResolvedKeybinding[]): void { + assertResolveKeybinding(mapper, createKeybinding(k, OperatingSystem.Linux), expected); + } + + function _simpleHTMLLabel(pieces: string[]): IHTMLContentElement { + return simpleHTMLLabel(pieces, OperatingSystem.Linux); + } + + function _chordHTMLLabel(firstPart: string[], chordPart: string[]): IHTMLContentElement { + return chordHTMLLabel(firstPart, chordPart, OperatingSystem.Linux); + } + + test('resolveKeybinding Ctrl+A', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.KEY_A, + [{ + label: 'Ctrl+A', + ariaLabel: 'Control+A', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'A'])], + electronAccelerator: 'Ctrl+A', + userSettingsLabel: 'ctrl+a', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyA]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+Z', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.KEY_Z, + [{ + label: 'Ctrl+Z', + ariaLabel: 'Control+Z', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])], + electronAccelerator: 'Ctrl+Z', + userSettingsLabel: 'ctrl+z', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyZ]', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+[KeyZ]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'KeyZ' + }, + { + label: 'Ctrl+Z', + ariaLabel: 'Control+Z', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])], + electronAccelerator: 'Ctrl+Z', + userSettingsLabel: 'ctrl+z', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyZ]', null], + } + ); + }); + + test('resolveKeybinding Ctrl+]', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.US_CLOSE_SQUARE_BRACKET, + [{ + label: 'Ctrl+]', + ariaLabel: 'Control+]', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', ']'])], + electronAccelerator: 'Ctrl+]', + userSettingsLabel: 'ctrl+]', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[BracketRight]', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+[BracketRight]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'BracketRight' + }, + { + label: 'Ctrl+]', + ariaLabel: 'Control+]', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', ']'])], + electronAccelerator: 'Ctrl+]', + userSettingsLabel: 'ctrl+]', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[BracketRight]', null], + } + ); + }); + + test('resolveKeybinding Shift+]', () => { + _assertResolveKeybinding( + KeyMod.Shift | KeyCode.US_CLOSE_SQUARE_BRACKET, + [{ + label: 'Shift+]', + ariaLabel: 'Shift+]', + HTMLLabel: [_simpleHTMLLabel(['Shift', ']'])], + electronAccelerator: 'Shift+]', + userSettingsLabel: 'shift+]', + isChord: false, + hasCtrlModifier: false, + hasShiftModifier: true, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['shift+[BracketRight]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+/', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.US_SLASH, + [{ + label: 'Ctrl+/', + ariaLabel: 'Control+/', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', '/'])], + electronAccelerator: 'Ctrl+/', + userSettingsLabel: 'ctrl+/', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Slash]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+Shift+/', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH, + [{ + label: 'Ctrl+Shift+/', + ariaLabel: 'Control+Shift+/', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Shift', '/'])], + electronAccelerator: 'Ctrl+Shift+/', + userSettingsLabel: 'ctrl+shift+/', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: true, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+shift+[Slash]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+K Ctrl+\\', () => { + _assertResolveKeybinding( + KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_BACKSLASH), + [{ + label: 'Ctrl+K Ctrl+\\', + ariaLabel: 'Control+K Control+\\', + HTMLLabel: [_chordHTMLLabel(['Ctrl', 'K'], ['Ctrl', '\\'])], + electronAccelerator: null, + userSettingsLabel: 'ctrl+k ctrl+\\', + isChord: true, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyK]', 'ctrl+[Backslash]'], + }] + ); + }); + + test('resolveKeybinding Ctrl+K Ctrl+=', () => { + _assertResolveKeybinding( + KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.US_EQUAL), + [{ + label: 'Ctrl+K Ctrl+=', + ariaLabel: 'Control+K Control+=', + HTMLLabel: [_chordHTMLLabel(['Ctrl', 'K'], ['Ctrl', '='])], + electronAccelerator: null, + userSettingsLabel: 'ctrl+k ctrl+=', + isChord: true, + hasCtrlModifier: false, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[KeyK]', 'ctrl+[Equal]'], + }] + ); + }); + + test('resolveKeybinding Ctrl+DownArrow', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.DownArrow, + [{ + label: 'Ctrl+DownArrow', + ariaLabel: 'Control+DownArrow', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'DownArrow'])], + electronAccelerator: 'Ctrl+Down', + userSettingsLabel: 'ctrl+down', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[ArrowDown]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+NUMPAD_0', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.NUMPAD_0, + [{ + label: 'Ctrl+NumPad0', + ariaLabel: 'Control+NumPad0', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'NumPad0'])], + electronAccelerator: null, + userSettingsLabel: 'ctrl+numpad0', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Numpad0]', null], + }] + ); + }); + + test('resolveKeybinding Ctrl+Home', () => { + _assertResolveKeybinding( + KeyMod.CtrlCmd | KeyCode.Home, + [{ + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Home]', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+[Home]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: -1, + code: 'Home' + }, + { + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+[Home]', null], + } + ); + }); }); function _assertKeybindingTranslation(mapper: MacLinuxKeyboardMapper, OS: OperatingSystem, kb: number, _expected: string | string[]): void { diff --git a/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts b/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts index f55591911e7..115f34b52ff 100644 --- a/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts +++ b/src/vs/workbench/services/keybinding/test/windowsKeyboardMapper.test.ts @@ -9,7 +9,7 @@ import { OperatingSystem } from 'vs/base/common/platform'; import { TPromise } from 'vs/base/common/winjs.base'; import { WindowsKeyboardMapper, IKeyboardMapping } from 'vs/workbench/services/keybinding/common/windowsKeyboardMapper'; import { createKeybinding, KeyMod, KeyCode, KeyChord } from 'vs/base/common/keyCodes'; -import { IResolvedKeybinding, assertResolveKeybinding, readRawMapping, assertMapping, simpleHTMLLabel, chordHTMLLabel } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils'; +import { IResolvedKeybinding, assertResolveKeybinding, readRawMapping, assertMapping, simpleHTMLLabel, chordHTMLLabel, assertResolveKeyboardEvent } from 'vs/workbench/services/keybinding/test/keyboardMapperTestUtils'; import { IHTMLContentElement } from 'vs/base/common/htmlContent'; function createKeyboardMapper(file: string): TPromise { @@ -85,6 +85,33 @@ suite('keyboardMapper - WINDOWS de_ch', () => { ); }); + test('resolveKeyboardEvent Ctrl+Z', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: KeyCode.KEY_Z, + code: null + }, + { + label: 'Ctrl+Z', + ariaLabel: 'Control+Z', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Z'])], + electronAccelerator: 'Ctrl+Z', + userSettingsLabel: 'ctrl+z', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+Z', null], + } + ); + }); + test('resolveKeybinding Ctrl+]', () => { _assertResolveKeybinding( mapper, @@ -105,6 +132,32 @@ suite('keyboardMapper - WINDOWS de_ch', () => { ); }); + test('resolveKeyboardEvent Ctrl+]', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: KeyCode.US_CLOSE_SQUARE_BRACKET, + code: null + }, + { + label: 'Ctrl+^', + ariaLabel: 'Control+^', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', '^'])], + electronAccelerator: 'Ctrl+]', + userSettingsLabel: 'ctrl+]', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+]', null], + } + ); + }); test('resolveKeybinding Shift+]', () => { _assertResolveKeybinding( @@ -233,6 +286,53 @@ suite('keyboardMapper - WINDOWS de_ch', () => { }] ); }); + + test('resolveKeybinding Ctrl+Home', () => { + _assertResolveKeybinding( + mapper, + KeyMod.CtrlCmd | KeyCode.Home, + [{ + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+Home', null], + }] + ); + }); + + test('resolveKeyboardEvent Ctrl+Home', () => { + assertResolveKeyboardEvent( + mapper, + { + ctrlKey: true, + shiftKey: false, + altKey: false, + metaKey: false, + keyCode: KeyCode.Home, + code: null + }, + { + label: 'Ctrl+Home', + ariaLabel: 'Control+Home', + HTMLLabel: [_simpleHTMLLabel(['Ctrl', 'Home'])], + electronAccelerator: 'Ctrl+Home', + userSettingsLabel: 'ctrl+home', + isChord: false, + hasCtrlModifier: true, + hasShiftModifier: false, + hasAltModifier: false, + hasMetaModifier: false, + dispatchParts: ['ctrl+Home', null], + } + ); + }); }); suite('keyboardMapper - WINDOWS en_us', () => { -- GitLab