Introduce keyboardMapper

src/vs/workbench/services/keybinding/common/keyboardEventCode.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+const codeIntToStr: string[] = [];
+const codeStrToInt: { [code: string]: number; } = Object.create(null);
+
+export const KeyboardEventCodeUtils = {
+	toEnum: (code: string) => codeStrToInt[code] || KeyboardEventCode.None,
+	toString: (code: KeyboardEventCode) => codeIntToStr[code] || 'None'
+};
+
+function d(int: KeyboardEventCode, str: string): void {
+	codeIntToStr[int] = str;
+	codeStrToInt[str] = int;
+}
+(function () {
+	d(KeyboardEventCode.None, 'None');
+	d(KeyboardEventCode.Hyper, 'Hyper');
+	d(KeyboardEventCode.Super, 'Super');
+	d(KeyboardEventCode.Fn, 'Fn');
+	d(KeyboardEventCode.FnLock, 'FnLock');
+	d(KeyboardEventCode.Suspend, 'Suspend');
+	d(KeyboardEventCode.Resume, 'Resume');
+	d(KeyboardEventCode.Turbo, 'Turbo');
+	d(KeyboardEventCode.Sleep, 'Sleep');
+	d(KeyboardEventCode.WakeUp, 'WakeUp');
+	d(KeyboardEventCode.KeyA, 'KeyA');
+	d(KeyboardEventCode.KeyB, 'KeyB');
+	d(KeyboardEventCode.KeyC, 'KeyC');
+	d(KeyboardEventCode.KeyD, 'KeyD');
+	d(KeyboardEventCode.KeyE, 'KeyE');
+	d(KeyboardEventCode.KeyF, 'KeyF');
+	d(KeyboardEventCode.KeyG, 'KeyG');
+	d(KeyboardEventCode.KeyH, 'KeyH');
+	d(KeyboardEventCode.KeyI, 'KeyI');
+	d(KeyboardEventCode.KeyJ, 'KeyJ');
+	d(KeyboardEventCode.KeyK, 'KeyK');
+	d(KeyboardEventCode.KeyL, 'KeyL');
+	d(KeyboardEventCode.KeyM, 'KeyM');
+	d(KeyboardEventCode.KeyN, 'KeyN');
+	d(KeyboardEventCode.KeyO, 'KeyO');
+	d(KeyboardEventCode.KeyP, 'KeyP');
+	d(KeyboardEventCode.KeyQ, 'KeyQ');
+	d(KeyboardEventCode.KeyR, 'KeyR');
+	d(KeyboardEventCode.KeyS, 'KeyS');
+	d(KeyboardEventCode.KeyT, 'KeyT');
+	d(KeyboardEventCode.KeyU, 'KeyU');
+	d(KeyboardEventCode.KeyV, 'KeyV');
+	d(KeyboardEventCode.KeyW, 'KeyW');
+	d(KeyboardEventCode.KeyX, 'KeyX');
+	d(KeyboardEventCode.KeyY, 'KeyY');
+	d(KeyboardEventCode.KeyZ, 'KeyZ');
+	d(KeyboardEventCode.Digit1, 'Digit1');
+	d(KeyboardEventCode.Digit2, 'Digit2');
+	d(KeyboardEventCode.Digit3, 'Digit3');
+	d(KeyboardEventCode.Digit4, 'Digit4');
+	d(KeyboardEventCode.Digit5, 'Digit5');
+	d(KeyboardEventCode.Digit6, 'Digit6');
+	d(KeyboardEventCode.Digit7, 'Digit7');
+	d(KeyboardEventCode.Digit8, 'Digit8');
+	d(KeyboardEventCode.Digit9, 'Digit9');
+	d(KeyboardEventCode.Digit0, 'Digit0');
+	d(KeyboardEventCode.Enter, 'Enter');
+	d(KeyboardEventCode.Escape, 'Escape');
+	d(KeyboardEventCode.Backspace, 'Backspace');
+	d(KeyboardEventCode.Tab, 'Tab');
+	d(KeyboardEventCode.Space, 'Space');
+	d(KeyboardEventCode.Minus, 'Minus');
+	d(KeyboardEventCode.Equal, 'Equal');
+	d(KeyboardEventCode.BracketLeft, 'BracketLeft');
+	d(KeyboardEventCode.BracketRight, 'BracketRight');
+	d(KeyboardEventCode.Backslash, 'Backslash');
+	d(KeyboardEventCode.IntlHash, 'IntlHash');
+	d(KeyboardEventCode.Semicolon, 'Semicolon');
+	d(KeyboardEventCode.Quote, 'Quote');
+	d(KeyboardEventCode.Backquote, 'Backquote');
+	d(KeyboardEventCode.Comma, 'Comma');
+	d(KeyboardEventCode.Period, 'Period');
+	d(KeyboardEventCode.Slash, 'Slash');
+	d(KeyboardEventCode.CapsLock, 'CapsLock');
+	d(KeyboardEventCode.F1, 'F1');
+	d(KeyboardEventCode.F2, 'F2');
+	d(KeyboardEventCode.F3, 'F3');
+	d(KeyboardEventCode.F4, 'F4');
+	d(KeyboardEventCode.F5, 'F5');
+	d(KeyboardEventCode.F6, 'F6');
+	d(KeyboardEventCode.F7, 'F7');
+	d(KeyboardEventCode.F8, 'F8');
+	d(KeyboardEventCode.F9, 'F9');
+	d(KeyboardEventCode.F10, 'F10');
+	d(KeyboardEventCode.F11, 'F11');
+	d(KeyboardEventCode.F12, 'F12');
+	d(KeyboardEventCode.PrintScreen, 'PrintScreen');
+	d(KeyboardEventCode.ScrollLock, 'ScrollLock');
+	d(KeyboardEventCode.Pause, 'Pause');
+	d(KeyboardEventCode.Insert, 'Insert');
+	d(KeyboardEventCode.Home, 'Home');
+	d(KeyboardEventCode.PageUp, 'PageUp');
+	d(KeyboardEventCode.Delete, 'Delete');
+	d(KeyboardEventCode.End, 'End');
+	d(KeyboardEventCode.PageDown, 'PageDown');
+	d(KeyboardEventCode.ArrowRight, 'ArrowRight');
+	d(KeyboardEventCode.ArrowLeft, 'ArrowLeft');
+	d(KeyboardEventCode.ArrowDown, 'ArrowDown');
+	d(KeyboardEventCode.ArrowUp, 'ArrowUp');
+	d(KeyboardEventCode.NumLock, 'NumLock');
+	d(KeyboardEventCode.NumpadDivide, 'NumpadDivide');
+	d(KeyboardEventCode.NumpadMultiply, 'NumpadMultiply');
+	d(KeyboardEventCode.NumpadSubtract, 'NumpadSubtract');
+	d(KeyboardEventCode.NumpadAdd, 'NumpadAdd');
+	d(KeyboardEventCode.NumpadEnter, 'NumpadEnter');
+	d(KeyboardEventCode.Numpad1, 'Numpad1');
+	d(KeyboardEventCode.Numpad2, 'Numpad2');
+	d(KeyboardEventCode.Numpad3, 'Numpad3');
+	d(KeyboardEventCode.Numpad4, 'Numpad4');
+	d(KeyboardEventCode.Numpad5, 'Numpad5');
+	d(KeyboardEventCode.Numpad6, 'Numpad6');
+	d(KeyboardEventCode.Numpad7, 'Numpad7');
+	d(KeyboardEventCode.Numpad8, 'Numpad8');
+	d(KeyboardEventCode.Numpad9, 'Numpad9');
+	d(KeyboardEventCode.Numpad0, 'Numpad0');
+	d(KeyboardEventCode.NumpadDecimal, 'NumpadDecimal');
+	d(KeyboardEventCode.IntlBackslash, 'IntlBackslash');
+	d(KeyboardEventCode.ContextMenu, 'ContextMenu');
+	d(KeyboardEventCode.Power, 'Power');
+	d(KeyboardEventCode.NumpadEqual, 'NumpadEqual');
+	d(KeyboardEventCode.F13, 'F13');
+	d(KeyboardEventCode.F14, 'F14');
+	d(KeyboardEventCode.F15, 'F15');
+	d(KeyboardEventCode.F16, 'F16');
+	d(KeyboardEventCode.F17, 'F17');
+	d(KeyboardEventCode.F18, 'F18');
+	d(KeyboardEventCode.F19, 'F19');
+	d(KeyboardEventCode.F20, 'F20');
+	d(KeyboardEventCode.F21, 'F21');
+	d(KeyboardEventCode.F22, 'F22');
+	d(KeyboardEventCode.F23, 'F23');
+	d(KeyboardEventCode.F24, 'F24');
+	d(KeyboardEventCode.Open, 'Open');
+	d(KeyboardEventCode.Help, 'Help');
+	d(KeyboardEventCode.Select, 'Select');
+	d(KeyboardEventCode.Again, 'Again');
+	d(KeyboardEventCode.Undo, 'Undo');
+	d(KeyboardEventCode.Cut, 'Cut');
+	d(KeyboardEventCode.Copy, 'Copy');
+	d(KeyboardEventCode.Paste, 'Paste');
+	d(KeyboardEventCode.Find, 'Find');
+	d(KeyboardEventCode.AudioVolumeMute, 'AudioVolumeMute');
+	d(KeyboardEventCode.AudioVolumeUp, 'AudioVolumeUp');
+	d(KeyboardEventCode.AudioVolumeDown, 'AudioVolumeDown');
+	d(KeyboardEventCode.NumpadComma, 'NumpadComma');
+	d(KeyboardEventCode.IntlRo, 'IntlRo');
+	d(KeyboardEventCode.KanaMode, 'KanaMode');
+	d(KeyboardEventCode.IntlYen, 'IntlYen');
+	d(KeyboardEventCode.Convert, 'Convert');
+	d(KeyboardEventCode.NonConvert, 'NonConvert');
+	d(KeyboardEventCode.Lang1, 'Lang1');
+	d(KeyboardEventCode.Lang2, 'Lang2');
+	d(KeyboardEventCode.Lang3, 'Lang3');
+	d(KeyboardEventCode.Lang4, 'Lang4');
+	d(KeyboardEventCode.Lang5, 'Lang5');
+	d(KeyboardEventCode.Abort, 'Abort');
+	d(KeyboardEventCode.Props, 'Props');
+	d(KeyboardEventCode.NumpadParenLeft, 'NumpadParenLeft');
+	d(KeyboardEventCode.NumpadParenRight, 'NumpadParenRight');
+	d(KeyboardEventCode.NumpadBackspace, 'NumpadBackspace');
+	d(KeyboardEventCode.NumpadMemoryStore, 'NumpadMemoryStore');
+	d(KeyboardEventCode.NumpadMemoryRecall, 'NumpadMemoryRecall');
+	d(KeyboardEventCode.NumpadMemoryClear, 'NumpadMemoryClear');
+	d(KeyboardEventCode.NumpadMemoryAdd, 'NumpadMemoryAdd');
+	d(KeyboardEventCode.NumpadMemorySubtract, 'NumpadMemorySubtract');
+	d(KeyboardEventCode.NumpadClear, 'NumpadClear');
+	d(KeyboardEventCode.NumpadClearEntry, 'NumpadClearEntry');
+	d(KeyboardEventCode.ControlLeft, 'ControlLeft');
+	d(KeyboardEventCode.ShiftLeft, 'ShiftLeft');
+	d(KeyboardEventCode.AltLeft, 'AltLeft');
+	d(KeyboardEventCode.MetaLeft, 'MetaLeft');
+	d(KeyboardEventCode.ControlRight, 'ControlRight');
+	d(KeyboardEventCode.ShiftRight, 'ShiftRight');
+	d(KeyboardEventCode.AltRight, 'AltRight');
+	d(KeyboardEventCode.MetaRight, 'MetaRight');
+	d(KeyboardEventCode.BrightnessUp, 'BrightnessUp');
+	d(KeyboardEventCode.BrightnessDown, 'BrightnessDown');
+	d(KeyboardEventCode.MediaPlay, 'MediaPlay');
+	d(KeyboardEventCode.MediaRecord, 'MediaRecord');
+	d(KeyboardEventCode.MediaFastForward, 'MediaFastForward');
+	d(KeyboardEventCode.MediaRewind, 'MediaRewind');
+	d(KeyboardEventCode.MediaTrackNext, 'MediaTrackNext');
+	d(KeyboardEventCode.MediaTrackPrevious, 'MediaTrackPrevious');
+	d(KeyboardEventCode.MediaStop, 'MediaStop');
+	d(KeyboardEventCode.Eject, 'Eject');
+	d(KeyboardEventCode.MediaPlayPause, 'MediaPlayPause');
+	d(KeyboardEventCode.MediaSelect, 'MediaSelect');
+	d(KeyboardEventCode.LaunchMail, 'LaunchMail');
+	d(KeyboardEventCode.LaunchApp2, 'LaunchApp2');
+	d(KeyboardEventCode.LaunchApp1, 'LaunchApp1');
+	d(KeyboardEventCode.SelectTask, 'SelectTask');
+	d(KeyboardEventCode.LaunchScreenSaver, 'LaunchScreenSaver');
+	d(KeyboardEventCode.BrowserSearch, 'BrowserSearch');
+	d(KeyboardEventCode.BrowserHome, 'BrowserHome');
+	d(KeyboardEventCode.BrowserBack, 'BrowserBack');
+	d(KeyboardEventCode.BrowserForward, 'BrowserForward');
+	d(KeyboardEventCode.BrowserStop, 'BrowserStop');
+	d(KeyboardEventCode.BrowserRefresh, 'BrowserRefresh');
+	d(KeyboardEventCode.BrowserFavorites, 'BrowserFavorites');
+	d(KeyboardEventCode.ZoomToggle, 'ZoomToggle');
+	d(KeyboardEventCode.MailReply, 'MailReply');
+	d(KeyboardEventCode.MailForward, 'MailForward');
+	d(KeyboardEventCode.MailSend, 'MailSend');
+})();
+
+/**
+ * keyboardEvent.code
+ */
+export const enum KeyboardEventCode {
+	None,
+
+	Hyper,
+	Super,
+	Fn,
+	FnLock,
+	Suspend,
+	Resume,
+	Turbo,
+	Sleep,
+	WakeUp,
+	KeyA,
+	KeyB,
+	KeyC,
+	KeyD,
+	KeyE,
+	KeyF,
+	KeyG,
+	KeyH,
+	KeyI,
+	KeyJ,
+	KeyK,
+	KeyL,
+	KeyM,
+	KeyN,
+	KeyO,
+	KeyP,
+	KeyQ,
+	KeyR,
+	KeyS,
+	KeyT,
+	KeyU,
+	KeyV,
+	KeyW,
+	KeyX,
+	KeyY,
+	KeyZ,
+	Digit1,
+	Digit2,
+	Digit3,
+	Digit4,
+	Digit5,
+	Digit6,
+	Digit7,
+	Digit8,
+	Digit9,
+	Digit0,
+	Enter,
+	Escape,
+	Backspace,
+	Tab,
+	Space,
+	Minus,
+	Equal,
+	BracketLeft,
+	BracketRight,
+	Backslash,
+	IntlHash,
+	Semicolon,
+	Quote,
+	Backquote,
+	Comma,
+	Period,
+	Slash,
+	CapsLock,
+	F1,
+	F2,
+	F3,
+	F4,
+	F5,
+	F6,
+	F7,
+	F8,
+	F9,
+	F10,
+	F11,
+	F12,
+	PrintScreen,
+	ScrollLock,
+	Pause,
+	Insert,
+	Home,
+	PageUp,
+	Delete,
+	End,
+	PageDown,
+	ArrowRight,
+	ArrowLeft,
+	ArrowDown,
+	ArrowUp,
+	NumLock,
+	NumpadDivide,
+	NumpadMultiply,
+	NumpadSubtract,
+	NumpadAdd,
+	NumpadEnter,
+	Numpad1,
+	Numpad2,
+	Numpad3,
+	Numpad4,
+	Numpad5,
+	Numpad6,
+	Numpad7,
+	Numpad8,
+	Numpad9,
+	Numpad0,
+	NumpadDecimal,
+	IntlBackslash,
+	ContextMenu,
+	Power,
+	NumpadEqual,
+	F13,
+	F14,
+	F15,
+	F16,
+	F17,
+	F18,
+	F19,
+	F20,
+	F21,
+	F22,
+	F23,
+	F24,
+	Open,
+	Help,
+	Select,
+	Again,
+	Undo,
+	Cut,
+	Copy,
+	Paste,
+	Find,
+	AudioVolumeMute,
+	AudioVolumeUp,
+	AudioVolumeDown,
+	NumpadComma,
+	IntlRo,
+	KanaMode,
+	IntlYen,
+	Convert,
+	NonConvert,
+	Lang1,
+	Lang2,
+	Lang3,
+	Lang4,
+	Lang5,
+	Abort,
+	Props,
+	NumpadParenLeft,
+	NumpadParenRight,
+	NumpadBackspace,
+	NumpadMemoryStore,
+	NumpadMemoryRecall,
+	NumpadMemoryClear,
+	NumpadMemoryAdd,
+	NumpadMemorySubtract,
+	NumpadClear,
+	NumpadClearEntry,
+	ControlLeft,
+	ShiftLeft,
+	AltLeft,
+	MetaLeft,
+	ControlRight,
+	ShiftRight,
+	AltRight,
+	MetaRight,
+	BrightnessUp,
+	BrightnessDown,
+	MediaPlay,
+	MediaRecord,
+	MediaFastForward,
+	MediaRewind,
+	MediaTrackNext,
+	MediaTrackPrevious,
+	MediaStop,
+	Eject,
+	MediaPlayPause,
+	MediaSelect,
+	LaunchMail,
+	LaunchApp2,
+	LaunchApp1,
+	SelectTask,
+	LaunchScreenSaver,
+	BrowserSearch,
+	BrowserHome,
+	BrowserBack,
+	BrowserForward,
+	BrowserStop,
+	BrowserRefresh,
+	BrowserFavorites,
+	ZoomToggle,
+	MailReply,
+	MailForward,
+	MailSend,
+}
\ No newline at end of file

src/vs/workbench/services/keybinding/common/keyboardMapper.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { OperatingSystem } from 'vs/base/common/platform';
+import { SimpleKeybinding, KeyCode } from 'vs/base/common/keyCodes';
+import { KeyboardEventCode, KeyboardEventCodeUtils } from "vs/workbench/services/keybinding/common/keyboardEventCode";
+import { PrintableKeypress } from "vs/platform/keybinding/common/keybindingLabels";
+import { CharCode } from "vs/base/common/charCode";
+
+export interface IKeyMapping {
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+
+	valueIsDeadKey?: boolean;
+	withShiftIsDeadKey?: boolean;
+	withAltGrIsDeadKey?: boolean;
+	withShiftAltGrIsDeadKey?: boolean;
+}
+
+export interface IKeyboardMapping {
+	[code: string]: IKeyMapping;
+}
+
+/**
+ * -1 if a KeyCode => keyboardEvent.code mapping depends on kb layout.
+ */
+const IMMUTABLE_KEY_CODE_TO_CODE: KeyboardEventCode[] = [];
+
+/**
+ * Chars that will be remapped.
+ */
+const REMAP_CHARS = [
+	CharCode.a, CharCode.b, CharCode.c, CharCode.d, CharCode.e, CharCode.f, CharCode.g,
+	CharCode.h, CharCode.i, CharCode.j, CharCode.k, CharCode.l, CharCode.m, CharCode.n,
+	CharCode.o, CharCode.p, CharCode.q, CharCode.r, CharCode.s, CharCode.t, CharCode.u,
+	CharCode.v, CharCode.w, CharCode.x, CharCode.y, CharCode.z,
+
+	CharCode.A, CharCode.B, CharCode.C, CharCode.D, CharCode.E, CharCode.F, CharCode.G,
+	CharCode.H, CharCode.I, CharCode.J, CharCode.K, CharCode.L, CharCode.M, CharCode.N,
+	CharCode.O, CharCode.P, CharCode.Q, CharCode.R, CharCode.S, CharCode.T, CharCode.U,
+	CharCode.V, CharCode.W, CharCode.X, CharCode.Y, CharCode.Z,
+
+	CharCode.Semicolon, CharCode.Colon,
+	CharCode.Equals, CharCode.Plus,
+	CharCode.Comma, CharCode.LessThan,
+	CharCode.Dash, CharCode.Underline,
+	CharCode.Period, CharCode.GreaterThan,
+	CharCode.Slash, CharCode.QuestionMark,
+	CharCode.BackTick, CharCode.Tilde,
+	CharCode.OpenSquareBracket, CharCode.OpenCurlyBrace,
+	CharCode.Backslash, CharCode.Pipe,
+	CharCode.CloseSquareBracket, CharCode.CloseCurlyBrace,
+	CharCode.SingleQuote, CharCode.DoubleQuote,
+];
+
+const REMAP_KEYBOARD_EVENT_CODES = [
+	KeyboardEventCode.KeyA,
+	KeyboardEventCode.KeyB,
+	KeyboardEventCode.KeyC,
+	KeyboardEventCode.KeyD,
+	KeyboardEventCode.KeyE,
+	KeyboardEventCode.KeyF,
+	KeyboardEventCode.KeyG,
+	KeyboardEventCode.KeyH,
+	KeyboardEventCode.KeyI,
+	KeyboardEventCode.KeyJ,
+	KeyboardEventCode.KeyK,
+	KeyboardEventCode.KeyL,
+	KeyboardEventCode.KeyM,
+	KeyboardEventCode.KeyN,
+	KeyboardEventCode.KeyO,
+	KeyboardEventCode.KeyP,
+	KeyboardEventCode.KeyQ,
+	KeyboardEventCode.KeyR,
+	KeyboardEventCode.KeyS,
+	KeyboardEventCode.KeyT,
+	KeyboardEventCode.KeyU,
+	KeyboardEventCode.KeyV,
+	KeyboardEventCode.KeyW,
+	KeyboardEventCode.KeyX,
+	KeyboardEventCode.KeyY,
+	KeyboardEventCode.KeyZ,
+	KeyboardEventCode.Digit1,
+	KeyboardEventCode.Digit2,
+	KeyboardEventCode.Digit3,
+	KeyboardEventCode.Digit4,
+	KeyboardEventCode.Digit5,
+	KeyboardEventCode.Digit6,
+	KeyboardEventCode.Digit7,
+	KeyboardEventCode.Digit8,
+	KeyboardEventCode.Digit9,
+	KeyboardEventCode.Digit0,
+	KeyboardEventCode.Minus,
+	KeyboardEventCode.Equal,
+	KeyboardEventCode.BracketLeft,
+	KeyboardEventCode.BracketRight,
+	KeyboardEventCode.Backslash,
+	KeyboardEventCode.IntlHash,
+	KeyboardEventCode.Semicolon,
+	KeyboardEventCode.Quote,
+	KeyboardEventCode.Backquote,
+	KeyboardEventCode.Comma,
+	KeyboardEventCode.Period,
+	KeyboardEventCode.Slash,
+	KeyboardEventCode.IntlBackslash
+];
+
+const enum ModifierState {
+	None = 0,
+	Shift = 1,
+	AltGr = 2,
+	ShiftAltGr = 3
+}
+
+interface KeyCombo {
+	code: KeyboardEventCode;
+	mod: ModifierState;
+}
+
+export class KeyboardMapper {
+
+	private readonly _OS: OperatingSystem;
+	private readonly _remapChars: KeyCombo[];
+
+	constructor(mapping: IKeyboardMapping, OS: OperatingSystem) {
+
+		this._remapChars = [];
+		let maxCharCode = REMAP_CHARS.reduce((prev, curr) => Math.max(prev, curr));
+		for (let i = 0; i <= maxCharCode; i++) {
+			this._remapChars[i] = null;
+		}
+
+		for (let strCode in mapping) {
+			if (mapping.hasOwnProperty(strCode)) {
+				const code = KeyboardEventCodeUtils.toEnum(strCode);
+				if (code === KeyboardEventCode.None) {
+					console.warn(`Unknown code ${strCode} in mapping.`);
+					continue;
+				}
+
+				const results = mapping[strCode];
+
+				this._register(code, ModifierState.None, results.value);
+				this._register(code, ModifierState.Shift, results.withShift);
+				this._register(code, ModifierState.AltGr, results.withAltGr);
+				this._register(code, ModifierState.ShiftAltGr, results.withShiftAltGr);
+			}
+		}
+
+		this._OS = OS;
+
+		for (let i = 0; i < REMAP_CHARS.length; i++) {
+			const charCode = REMAP_CHARS[i];
+			if (!this._remapChars[charCode]) {
+				// console.info(`Could not find any key combination producing '${String.fromCharCode(charCode)}'`);
+			}
+		}
+	}
+
+	private _register(code: KeyboardEventCode, mod: ModifierState, char: string): void {
+		if (char.length === 0) {
+			return;
+		}
+		const charCode = char.charCodeAt(0);
+
+		if (REMAP_CHARS.indexOf(charCode) === -1) {
+			return;
+		}
+		if (REMAP_KEYBOARD_EVENT_CODES.indexOf(code) === -1) {
+			return;
+		}
+		if (this._remapChars[charCode]) {
+			// console.info(`Multiple key combinations can produce '${char}'`);
+			// already remaped
+			return;
+		}
+		this._remapChars[charCode] = {
+			code: code,
+			mod: mod
+		};
+	}
+
+	private _mapSimpleKeybinding(ctrlKey: boolean, altKey: boolean, metaKey: boolean, charCode: number): PrintableKeypress {
+		const keyCombo = this._remapChars[charCode];
+		if (!keyCombo) {
+			console.info('Cannot produce desired kb...');
+			return null;
+		}
+
+		// console.log(`_mapSimpleKeybinding ctrlKey: ${ctrlKey}, altKey: ${altKey}, metaKey: ${metaKey}, char: ${String.fromCharCode(charCode)}`);
+		// console.log(` => ${KeyboardEventCodeUtils.toString(keyCombo.code)}, ${keyCombo.mod}`);
+
+		let shiftKey = false;
+		if (keyCombo.mod === ModifierState.Shift) {
+			shiftKey = true;
+		} else if (keyCombo.mod === ModifierState.AltGr) {
+			console.error('TODO');
+			console.log(`_mapSimpleKeybinding ctrlKey: ${ctrlKey}, altKey: ${altKey}, metaKey: ${metaKey}, char: ${String.fromCharCode(charCode)}`);
+			console.log(` => ${KeyboardEventCodeUtils.toString(keyCombo.code)}, ${keyCombo.mod}`);
+			return null;
+		} else if (keyCombo.mod === ModifierState.ShiftAltGr) {
+			console.error('TODO');
+			return null;
+		}
+
+		return new PrintableKeypress(ctrlKey, shiftKey, altKey, metaKey, KeyboardEventCodeUtils.toString(keyCombo.code));
+	}
+
+	public mapSimpleKeybinding(keybinding: SimpleKeybinding): PrintableKeypress {
+		const ctrlCmd = keybinding.hasCtrlCmd();
+		const winCtrl = keybinding.hasWinCtrl();
+
+		const ctrlKey = (this._OS === OperatingSystem.Macintosh ? winCtrl : ctrlCmd);
+		const metaKey = (this._OS === OperatingSystem.Macintosh ? ctrlCmd : winCtrl);
+		const shiftKey = keybinding.hasShift();
+		const altKey = keybinding.hasAlt();
+		const keyCode = keybinding.getKeyCode();
+
+		if (IMMUTABLE_KEY_CODE_TO_CODE[keyCode] !== -1) {
+			const keyboardEventCode = IMMUTABLE_KEY_CODE_TO_CODE[keyCode];
+			return new PrintableKeypress(ctrlKey, shiftKey, altKey, metaKey, KeyboardEventCodeUtils.toString(keyboardEventCode));
+		}
+
+		let desiredCharCode = 0;
+
+		if (keyCode >= KeyCode.KEY_A && keyCode <= KeyCode.KEY_Z) {
+			if (shiftKey) {
+				desiredCharCode = CharCode.A + (keyCode - KeyCode.KEY_A);
+			} else {
+				desiredCharCode = CharCode.a + (keyCode - KeyCode.KEY_A);
+			}
+		} else {
+			switch (keyCode) {
+				case KeyCode.US_SEMICOLON:
+					desiredCharCode = (!shiftKey ? CharCode.Semicolon : CharCode.Colon);
+					break;
+				case KeyCode.US_EQUAL:
+					desiredCharCode = (!shiftKey ? CharCode.Equals : CharCode.Plus);
+					break;
+				case KeyCode.US_COMMA:
+					desiredCharCode = (!shiftKey ? CharCode.Comma : CharCode.LessThan);
+					break;
+				case KeyCode.US_MINUS:
+					desiredCharCode = (!shiftKey ? CharCode.Dash : CharCode.Underline);
+					break;
+				case KeyCode.US_DOT:
+					desiredCharCode = (!shiftKey ? CharCode.Period : CharCode.GreaterThan);
+					break;
+				case KeyCode.US_SLASH:
+					desiredCharCode = (!shiftKey ? CharCode.Slash : CharCode.QuestionMark);
+					break;
+				case KeyCode.US_BACKTICK:
+					desiredCharCode = (!shiftKey ? CharCode.BackTick : CharCode.Tilde);
+					break;
+				case KeyCode.US_OPEN_SQUARE_BRACKET:
+					desiredCharCode = (!shiftKey ? CharCode.OpenSquareBracket : CharCode.OpenCurlyBrace);
+					break;
+				case KeyCode.US_BACKSLASH:
+					desiredCharCode = (!shiftKey ? CharCode.Backslash : CharCode.Pipe);
+					break;
+				case KeyCode.US_CLOSE_SQUARE_BRACKET:
+					desiredCharCode = (!shiftKey ? CharCode.CloseSquareBracket : CharCode.CloseCurlyBrace);
+					break;
+				case KeyCode.US_QUOTE:
+					desiredCharCode = (!shiftKey ? CharCode.SingleQuote : CharCode.DoubleQuote);
+					break;
+			}
+		}
+
+		if (desiredCharCode === 0) {
+			// OEM_8 = 91,
+			// OEM_102 = 92,
+			console.info('Cannot produce desired kb...');
+			return null;
+		}
+
+		return this._mapSimpleKeybinding(ctrlKey, altKey, metaKey, desiredCharCode);
+	}
+}
+
+(function () {
+	let currentLength = 0;
+	function d(keyCode: KeyCode, code: KeyboardEventCode): void {
+		if (keyCode > currentLength) {
+			for (let i = currentLength; i < keyCode; i++) {
+				IMMUTABLE_KEY_CODE_TO_CODE[i] = -1;
+			}
+		}
+		IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = code;
+		currentLength = keyCode + 1;
+	}
+
+	// Unknown = 0,
+
+	d(KeyCode.Backspace, KeyboardEventCode.Backspace);
+	d(KeyCode.Tab, KeyboardEventCode.Tab);
+	d(KeyCode.Enter, KeyboardEventCode.Enter);
+
+	d(KeyCode.Shift, KeyboardEventCode.ShiftLeft);
+	// TODO => ShiftLeft, ShiftRight
+
+	d(KeyCode.Ctrl, KeyboardEventCode.ControlLeft);
+	// TODO => ControlLeft, ControlRight
+
+	d(KeyCode.Alt, KeyboardEventCode.AltLeft);
+	// TODO => AltLeft, AltRight
+
+	d(KeyCode.PauseBreak, KeyboardEventCode.Pause);
+	d(KeyCode.CapsLock, KeyboardEventCode.CapsLock);
+	d(KeyCode.Escape, KeyboardEventCode.Escape);
+	d(KeyCode.Space, KeyboardEventCode.Space);
+	d(KeyCode.PageUp, KeyboardEventCode.PageUp);
+	d(KeyCode.PageDown, KeyboardEventCode.PageDown);
+	d(KeyCode.End, KeyboardEventCode.End);
+	d(KeyCode.Home, KeyboardEventCode.Home);
+	d(KeyCode.LeftArrow, KeyboardEventCode.ArrowLeft);
+	d(KeyCode.UpArrow, KeyboardEventCode.ArrowUp);
+	d(KeyCode.RightArrow, KeyboardEventCode.ArrowRight);
+	d(KeyCode.DownArrow, KeyboardEventCode.ArrowDown);
+	d(KeyCode.Insert, KeyboardEventCode.Insert);
+	d(KeyCode.Delete, KeyboardEventCode.Delete);
+
+	d(KeyCode.KEY_0, KeyboardEventCode.Digit0);
+	d(KeyCode.KEY_1, KeyboardEventCode.Digit1);
+	d(KeyCode.KEY_2, KeyboardEventCode.Digit2);
+	d(KeyCode.KEY_3, KeyboardEventCode.Digit3);
+	d(KeyCode.KEY_4, KeyboardEventCode.Digit4);
+	d(KeyCode.KEY_5, KeyboardEventCode.Digit5);
+	d(KeyCode.KEY_6, KeyboardEventCode.Digit6);
+	d(KeyCode.KEY_7, KeyboardEventCode.Digit7);
+	d(KeyCode.KEY_8, KeyboardEventCode.Digit8);
+	d(KeyCode.KEY_9, KeyboardEventCode.Digit9);
+
+	d(KeyCode.Meta, KeyboardEventCode.MetaLeft);
+	// TODO => MetaLeft, MetaRight
+	d(KeyCode.ContextMenu, KeyboardEventCode.ContextMenu);
+
+	d(KeyCode.F1, KeyboardEventCode.F1);
+	d(KeyCode.F2, KeyboardEventCode.F2);
+	d(KeyCode.F3, KeyboardEventCode.F3);
+	d(KeyCode.F4, KeyboardEventCode.F4);
+	d(KeyCode.F5, KeyboardEventCode.F5);
+	d(KeyCode.F6, KeyboardEventCode.F6);
+	d(KeyCode.F7, KeyboardEventCode.F7);
+	d(KeyCode.F8, KeyboardEventCode.F8);
+	d(KeyCode.F9, KeyboardEventCode.F9);
+	d(KeyCode.F10, KeyboardEventCode.F10);
+	d(KeyCode.F11, KeyboardEventCode.F11);
+	d(KeyCode.F12, KeyboardEventCode.F12);
+	d(KeyCode.F13, KeyboardEventCode.F13);
+	d(KeyCode.F14, KeyboardEventCode.F14);
+	d(KeyCode.F15, KeyboardEventCode.F15);
+	d(KeyCode.F16, KeyboardEventCode.F16);
+	d(KeyCode.F17, KeyboardEventCode.F17);
+	d(KeyCode.F18, KeyboardEventCode.F18);
+	d(KeyCode.F19, KeyboardEventCode.F19);
+
+	d(KeyCode.NumLock, KeyboardEventCode.NumLock);
+	d(KeyCode.ScrollLock, KeyboardEventCode.ScrollLock);
+
+	d(KeyCode.NUMPAD_0, KeyboardEventCode.Numpad0);
+	d(KeyCode.NUMPAD_1, KeyboardEventCode.Numpad1);
+	d(KeyCode.NUMPAD_2, KeyboardEventCode.Numpad2);
+	d(KeyCode.NUMPAD_3, KeyboardEventCode.Numpad3);
+	d(KeyCode.NUMPAD_4, KeyboardEventCode.Numpad4);
+	d(KeyCode.NUMPAD_5, KeyboardEventCode.Numpad5);
+	d(KeyCode.NUMPAD_6, KeyboardEventCode.Numpad6);
+	d(KeyCode.NUMPAD_7, KeyboardEventCode.Numpad7);
+	d(KeyCode.NUMPAD_8, KeyboardEventCode.Numpad8);
+	d(KeyCode.NUMPAD_9, KeyboardEventCode.Numpad9);
+
+	d(KeyCode.NUMPAD_MULTIPLY, KeyboardEventCode.NumpadMultiply);
+	d(KeyCode.NUMPAD_ADD, KeyboardEventCode.NumpadAdd);
+	d(KeyCode.NUMPAD_SEPARATOR, KeyboardEventCode.NumpadComma);
+	d(KeyCode.NUMPAD_SUBTRACT, KeyboardEventCode.NumpadSubtract);
+	d(KeyCode.NUMPAD_DECIMAL, KeyboardEventCode.NumpadDecimal);
+	d(KeyCode.NUMPAD_DIVIDE, KeyboardEventCode.NumpadDivide);
+})();

src/vs/workbench/services/keybinding/test/keyboardMapper.test.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as assert from 'assert';
+import { mac_de_ch } from 'vs/workbench/services/keybinding/test/mac_de_ch';
+import { KeyMod, KeyCode, SimpleKeybinding } from 'vs/base/common/keyCodes';
+import { KeyboardMapper } from 'vs/workbench/services/keybinding/common/keyboardMapper';
+import { OperatingSystem } from 'vs/base/common/platform';
+import { UserSettingsLabelProvider } from 'vs/platform/keybinding/common/keybindingLabels';
+
+suite('keyboardMapper - MAC de_ch', () => {
+
+	let mapper: KeyboardMapper;
+
+	suiteSetup(() => {
+		mapper = new KeyboardMapper(mac_de_ch, OperatingSystem.Macintosh);
+	});
+
+	function assertKeybindingTranslation(kb: number, expected: string): void {
+		let actualPrintableKeypress = mapper.mapSimpleKeybinding(new SimpleKeybinding(kb));
+		let actual = UserSettingsLabelProvider.toLabel2(actualPrintableKeypress, null, OperatingSystem.Macintosh);
+		assert.deepEqual(actual, expected);
+	}
+
+	test('unchanged', () => {
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KEY_1, 'Cmd+Digit1');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KEY_B, 'Cmd+KeyB');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KEY_B, 'Shift+Cmd+KeyB');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyMod.WinCtrl | KeyCode.KEY_B, 'Ctrl+Shift+Alt+Cmd+KeyB');
+	});
+
+	test('flips Y and Z', () => {
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KEY_Z, 'Cmd+KeyY');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.KEY_Y, 'Cmd+KeyZ');
+	});
+
+	test('other key codes', () => {
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_SEMICOLON, 'Shift+Cmd+Comma');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SEMICOLON, 'Shift+Cmd+Period');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_SEMICOLON, 'Shift+Alt+Cmd+Period');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_EQUAL, 'Shift+Cmd+Digit0');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_EQUAL, 'Shift+Cmd+Digit1');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_EQUAL, 'Shift+Alt+Cmd+Digit1');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_COMMA, 'Cmd+Comma');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_COMMA, 'Cmd+Backquote');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_COMMA, 'Alt+Cmd+Backquote');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_MINUS, 'Cmd+Slash');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_MINUS, 'Shift+Cmd+Slash');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_MINUS, 'Shift+Alt+Cmd+Slash');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_DOT, 'Cmd+Period');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_DOT, 'Shift+Cmd+Backquote');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_DOT, 'Shift+Alt+Cmd+Backquote');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_SLASH, 'Shift+Cmd+Digit7');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_SLASH, 'Shift+Cmd+Minus');
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_SLASH, 'Shift+Alt+Cmd+Minus');
+
+		assertKeybindingTranslation(KeyMod.CtrlCmd | KeyCode.US_BACKTICK, 'Shift+Cmd+Equal');
+
+		// assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.US_BACKTICK, 'Shift+Cmd+Minus');
+		// assertKeybindingTranslation(KeyMod.CtrlCmd | KeyMod.Shift | KeyMod.Alt | KeyCode.US_BACKTICK, 'Shift+Alt+Cmd+Minus');
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  * For the US standard keyboard, the '`~' key
+		//  */
+		// US_BACKTICK = 86,
+
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  * For the US standard keyboard, the '[{' key
+		//  */
+		// US_OPEN_SQUARE_BRACKET = 87,
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  * For the US standard keyboard, the '\|' key
+		//  */
+		// US_BACKSLASH = 88,
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  * For the US standard keyboard, the ']}' key
+		//  */
+		// US_CLOSE_SQUARE_BRACKET = 89,
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  * For the US standard keyboard, the ''"' key
+		//  */
+		// US_QUOTE = 90,
+		// /**
+		//  * Used for miscellaneous characters; it can vary by keyboard.
+		//  */
+		// OEM_8 = 91,
+		// /**
+		//  * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
+		//  */
+		// OEM_102 = 92,
+
+	});
+});