@codingame/monaco-vscode-keybindings-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/keybinding/common/windowsKeyboardMapper.js

@@ -1,352 +0,0 @@
-import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE, ScanCodeUtils, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE } from 'vscode/vscode/vs/base/common/keyCodes';
-import { ScanCodeChord, KeyCodeChord } from 'vscode/vscode/vs/base/common/keybindings';
-import { UILabelProvider } from 'vscode/vscode/vs/base/common/keybindingLabels';
-import { BaseResolvedKeybinding } from 'vscode/vscode/vs/platform/keybinding/common/baseResolvedKeybinding';
-import { toEmptyArrayIfContainsNull } from 'vscode/vscode/vs/platform/keybinding/common/resolvedKeybindingItem';
-
-class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
-    constructor(mapper, chords) {
-        super(1 , chords);
-        this._mapper = mapper;
-    }
-    _getLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
-        }
-        return this._mapper.getUILabelForKeyCode(chord.keyCode);
-    }
-    _getUSLabelForKeybinding(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
-        }
-        return ( KeyCodeUtils.toString(chord.keyCode));
-    }
-    getUSLabel() {
-        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUSLabelForKeybinding(keybinding));
-    }
-    _getAriaLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
-        }
-        return this._mapper.getAriaLabelForKeyCode(chord.keyCode);
-    }
-    _getElectronAccelerator(chord) {
-        return this._mapper.getElectronAcceleratorForKeyBinding(chord);
-    }
-    _getUserSettingsLabel(chord) {
-        if (chord.isDuplicateModifierCase()) {
-            return '';
-        }
-        const result = this._mapper.getUserSettingsLabelForKeyCode(chord.keyCode);
-        return (result ? result.toLowerCase() : result);
-    }
-    _isWYSIWYG(chord) {
-        return this.__isWYSIWYG(chord.keyCode);
-    }
-    __isWYSIWYG(keyCode) {
-        if (keyCode === 15
-            || keyCode === 16
-            || keyCode === 17
-            || keyCode === 18 ) {
-            return true;
-        }
-        const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
-        const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
-        return (ariaLabel === userSettingsLabel);
-    }
-    _getChordDispatch(chord) {
-        if (chord.isModifierKey()) {
-            return null;
-        }
-        let result = '';
-        if (chord.ctrlKey) {
-            result += 'ctrl+';
-        }
-        if (chord.shiftKey) {
-            result += 'shift+';
-        }
-        if (chord.altKey) {
-            result += 'alt+';
-        }
-        if (chord.metaKey) {
-            result += 'meta+';
-        }
-        result += ( KeyCodeUtils.toString(chord.keyCode));
-        return result;
-    }
-    _getSingleModifierChordDispatch(chord) {
-        if (chord.keyCode === 5  && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
-            return 'ctrl';
-        }
-        if (chord.keyCode === 4  && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
-            return 'shift';
-        }
-        if (chord.keyCode === 6  && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
-            return 'alt';
-        }
-        if (chord.keyCode === 57  && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
-            return 'meta';
-        }
-        return null;
-    }
-    static getProducedCharCode(chord, mapping) {
-        if (!mapping) {
-            return null;
-        }
-        if (chord.ctrlKey && chord.shiftKey && chord.altKey) {
-            return mapping.withShiftAltGr;
-        }
-        if (chord.ctrlKey && chord.altKey) {
-            return mapping.withAltGr;
-        }
-        if (chord.shiftKey) {
-            return mapping.withShift;
-        }
-        return mapping.value;
-    }
-    static getProducedChar(chord, mapping) {
-        const char = this.getProducedCharCode(chord, mapping);
-        if (char === null || char.length === 0) {
-            return ' --- ';
-        }
-        return '  ' + char + '  ';
-    }
-}
-class WindowsKeyboardMapper {
-    constructor(_isUSStandard, rawMappings, _mapAltGrToCtrlAlt) {
-        this._isUSStandard = _isUSStandard;
-        this._mapAltGrToCtrlAlt = _mapAltGrToCtrlAlt;
-        this._keyCodeToLabel = [];
-        this._scanCodeToKeyCode = [];
-        this._keyCodeToLabel = [];
-        this._keyCodeExists = [];
-        this._keyCodeToLabel[0 ] = ( KeyCodeUtils.toString(0 ));
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
-            const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-            if (immutableKeyCode !== -1 ) {
-                this._scanCodeToKeyCode[scanCode] = immutableKeyCode;
-                this._keyCodeToLabel[immutableKeyCode] = ( KeyCodeUtils.toString(immutableKeyCode));
-                this._keyCodeExists[immutableKeyCode] = true;
-            }
-        }
-        const producesLetter = [];
-        let producesLetters = false;
-        this._codeInfo = [];
-        for (const strCode in rawMappings) {
-            if (rawMappings.hasOwnProperty(strCode)) {
-                const scanCode = ScanCodeUtils.toEnum(strCode);
-                if (scanCode === 0 ) {
-                    continue;
-                }
-                const rawMapping = rawMappings[strCode];
-                const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
-                if (immutableKeyCode !== -1 ) {
-                    const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
-                    if (keyCode === 0  || immutableKeyCode === keyCode) {
-                        continue;
-                    }
-                    if (scanCode !== 134 ) {
-                        continue;
-                    }
-                }
-                const value = rawMapping.value;
-                const withShift = rawMapping.withShift;
-                const withAltGr = rawMapping.withAltGr;
-                const withShiftAltGr = rawMapping.withShiftAltGr;
-                const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
-                const mapping = {
-                    scanCode: scanCode,
-                    keyCode: keyCode,
-                    value: value,
-                    withShift: withShift,
-                    withAltGr: withAltGr,
-                    withShiftAltGr: withShiftAltGr,
-                };
-                this._codeInfo[scanCode] = mapping;
-                this._scanCodeToKeyCode[scanCode] = keyCode;
-                if (keyCode === 0 ) {
-                    continue;
-                }
-                this._keyCodeExists[keyCode] = true;
-                if (value.length === 0) {
-                    this._keyCodeToLabel[keyCode] = null;
-                }
-                else if (value.length > 1) {
-                    this._keyCodeToLabel[keyCode] = value;
-                }
-                else {
-                    const charCode = value.charCodeAt(0);
-                    if (charCode >= 97  && charCode <= 122 ) {
-                        const upperCaseValue = 65  + ((charCode - 97) );
-                        producesLetter[upperCaseValue] = true;
-                        producesLetters = true;
-                        this._keyCodeToLabel[keyCode] = String.fromCharCode(65  + ((charCode - 97) ));
-                    }
-                    else if (charCode >= 65  && charCode <= 90 ) {
-                        producesLetter[charCode] = true;
-                        producesLetters = true;
-                        this._keyCodeToLabel[keyCode] = value;
-                    }
-                    else {
-                        this._keyCodeToLabel[keyCode] = value;
-                    }
-                }
-            }
-        }
-        const _registerLetterIfMissing = (charCode, keyCode) => {
-            if (!producesLetter[charCode]) {
-                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
-            }
-        };
-        _registerLetterIfMissing(65 , 31 );
-        _registerLetterIfMissing(66 , 32 );
-        _registerLetterIfMissing(67 , 33 );
-        _registerLetterIfMissing(68 , 34 );
-        _registerLetterIfMissing(69 , 35 );
-        _registerLetterIfMissing(70 , 36 );
-        _registerLetterIfMissing(71 , 37 );
-        _registerLetterIfMissing(72 , 38 );
-        _registerLetterIfMissing(73 , 39 );
-        _registerLetterIfMissing(74 , 40 );
-        _registerLetterIfMissing(75 , 41 );
-        _registerLetterIfMissing(76 , 42 );
-        _registerLetterIfMissing(77 , 43 );
-        _registerLetterIfMissing(78 , 44 );
-        _registerLetterIfMissing(79 , 45 );
-        _registerLetterIfMissing(80 , 46 );
-        _registerLetterIfMissing(81 , 47 );
-        _registerLetterIfMissing(82 , 48 );
-        _registerLetterIfMissing(83 , 49 );
-        _registerLetterIfMissing(84 , 50 );
-        _registerLetterIfMissing(85 , 51 );
-        _registerLetterIfMissing(86 , 52 );
-        _registerLetterIfMissing(87 , 53 );
-        _registerLetterIfMissing(88 , 54 );
-        _registerLetterIfMissing(89 , 55 );
-        _registerLetterIfMissing(90 , 56 );
-        if (!producesLetters) {
-            const _registerLabel = (keyCode, charCode) => {
-                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
-            };
-            _registerLabel(85 , 59 );
-            _registerLabel(86 , 61 );
-            _registerLabel(87 , 44 );
-            _registerLabel(88 , 45 );
-            _registerLabel(89 , 46 );
-            _registerLabel(90 , 47 );
-            _registerLabel(91 , 96 );
-            _registerLabel(92 , 91 );
-            _registerLabel(93 , 92 );
-            _registerLabel(94 , 93 );
-            _registerLabel(95 , 39 );
-        }
-    }
-    dumpDebugInfo() {
-        const result = [];
-        const immutableSamples = [
-            88 ,
-            104
-        ];
-        let cnt = 0;
-        result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
-            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
-                if (immutableSamples.indexOf(scanCode) === -1) {
-                    continue;
-                }
-            }
-            if (cnt % 6 === 0) {
-                result.push(`|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |`);
-                result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-            }
-            cnt++;
-            const mapping = this._codeInfo[scanCode];
-            const strCode = ( ScanCodeUtils.toString(scanCode));
-            const mods = [0b000, 0b010, 0b101, 0b111];
-            for (const mod of mods) {
-                const ctrlKey = (mod & 0b001) ? true : false;
-                const shiftKey = (mod & 0b010) ? true : false;
-                const altKey = (mod & 0b100) ? true : false;
-                const scanCodeChord = ( new ScanCodeChord(ctrlKey, shiftKey, altKey, false, scanCode));
-                const keyCodeChord = this._resolveChord(scanCodeChord);
-                const strKeyCode = (keyCodeChord ? ( KeyCodeUtils.toString(keyCodeChord.keyCode)) : null);
-                const resolvedKb = (keyCodeChord ? ( new WindowsNativeResolvedKeybinding(this, [keyCodeChord])) : null);
-                const outScanCode = `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strCode}`;
-                const ariaLabel = (resolvedKb ? resolvedKb.getAriaLabel() : null);
-                const outUILabel = (ariaLabel ? ariaLabel.replace(/Control\+/, 'Ctrl+') : null);
-                const outUserSettings = (resolvedKb ? resolvedKb.getUserSettingsLabel() : null);
-                const outKey = WindowsNativeResolvedKeybinding.getProducedChar(scanCodeChord, mapping);
-                const outKb = (strKeyCode ? `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strKeyCode}` : null);
-                const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
-                const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
-                result.push(`| ${this._leftPad(outScanCode, 30)} | ${outKey} | ${this._leftPad(outKb, 25)} | ${this._leftPad(outUILabel, 25)} |  ${this._leftPad(outUserSettings, 25)} | ${outWYSIWYG} |`);
-            }
-            result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
-        }
-        return result.join('\n');
-    }
-    _leftPad(str, cnt) {
-        if (str === null) {
-            str = 'null';
-        }
-        while (str.length < cnt) {
-            str = ' ' + str;
-        }
-        return str;
-    }
-    getUILabelForKeyCode(keyCode) {
-        return this._getLabelForKeyCode(keyCode);
-    }
-    getAriaLabelForKeyCode(keyCode) {
-        return this._getLabelForKeyCode(keyCode);
-    }
-    getUserSettingsLabelForKeyCode(keyCode) {
-        if (this._isUSStandard) {
-            return KeyCodeUtils.toUserSettingsUS(keyCode);
-        }
-        return KeyCodeUtils.toUserSettingsGeneral(keyCode);
-    }
-    getElectronAcceleratorForKeyBinding(chord) {
-        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
-    }
-    _getLabelForKeyCode(keyCode) {
-        return this._keyCodeToLabel[keyCode] || ( KeyCodeUtils.toString(0 ));
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
-        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
-        const chord = ( new KeyCodeChord(
-            ctrlKey,
-            keyboardEvent.shiftKey,
-            altKey,
-            keyboardEvent.metaKey,
-            keyboardEvent.keyCode
-        ));
-        return ( new WindowsNativeResolvedKeybinding(this, [chord]));
-    }
-    _resolveChord(chord) {
-        if (!chord) {
-            return null;
-        }
-        if (chord instanceof KeyCodeChord) {
-            if (!this._keyCodeExists[chord.keyCode]) {
-                return null;
-            }
-            return chord;
-        }
-        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
-        if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
-            return null;
-        }
-        return ( new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode));
-    }
-    resolveKeybinding(keybinding) {
-        const chords = toEmptyArrayIfContainsNull(( keybinding.chords.map(chord => this._resolveChord(chord))));
-        if (chords.length > 0) {
-            return [( new WindowsNativeResolvedKeybinding(this, chords))];
-        }
-        return [];
-    }
-}
-
-export { WindowsKeyboardMapper, WindowsNativeResolvedKeybinding };