Você não pode selecionar mais de 25 tópicos
Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
124 linhas
3.9 KiB
124 linhas
3.9 KiB
'use strict';
|
|
import { commands, Disposable } from 'vscode';
|
|
import { CommandContext, extensionId, setCommandContext } from './constants';
|
|
import { Logger } from './logger';
|
|
|
|
export declare interface KeyCommand {
|
|
onDidPressKey?(key: Keys): Promise<{} | undefined>;
|
|
}
|
|
|
|
const keyNoopCommand = Object.create(null) as KeyCommand;
|
|
export { keyNoopCommand as KeyNoopCommand };
|
|
|
|
export declare type Keys = 'left' | 'right' | ',' | '.' | 'escape';
|
|
export const keys: Keys[] = ['left', 'right', ',', '.', 'escape'];
|
|
|
|
export declare interface KeyMapping {
|
|
[id: string]: KeyCommand | (() => Promise<KeyCommand>) | undefined;
|
|
}
|
|
|
|
const mappings: KeyMapping[] = [];
|
|
|
|
export class KeyboardScope implements Disposable {
|
|
constructor(
|
|
private readonly mapping: KeyMapping
|
|
) {
|
|
for (const key in mapping) {
|
|
mapping[key] = mapping[key] || keyNoopCommand;
|
|
}
|
|
}
|
|
|
|
async dispose() {
|
|
const index = mappings.indexOf(this.mapping);
|
|
Logger.log('KeyboardScope.dispose', mappings.length, index);
|
|
if (index === mappings.length - 1) {
|
|
mappings.pop();
|
|
await this.updateKeyCommandsContext(mappings[mappings.length - 1]);
|
|
}
|
|
else {
|
|
mappings.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
async begin() {
|
|
mappings.push(this.mapping);
|
|
await this.updateKeyCommandsContext(this.mapping);
|
|
return this;
|
|
}
|
|
|
|
async clearKeyCommand(key: Keys) {
|
|
const mapping = mappings[mappings.length - 1];
|
|
if (mapping !== this.mapping || !mapping[key]) return;
|
|
|
|
Logger.log('KeyboardScope.clearKeyCommand', mappings.length, key);
|
|
mapping[key] = undefined;
|
|
await setCommandContext(`${CommandContext.Key}:${key}`, false);
|
|
}
|
|
|
|
async setKeyCommand(key: Keys, command: KeyCommand | (() => Promise<KeyCommand>)) {
|
|
const mapping = mappings[mappings.length - 1];
|
|
if (mapping !== this.mapping) return;
|
|
|
|
Logger.log('KeyboardScope.setKeyCommand', mappings.length, key, Boolean(mapping[key]));
|
|
|
|
if (!mapping[key]) {
|
|
mapping[key] = command;
|
|
await setCommandContext(`${CommandContext.Key}:${key}`, true);
|
|
}
|
|
else {
|
|
mapping[key] = command;
|
|
}
|
|
}
|
|
|
|
private async updateKeyCommandsContext(mapping: KeyMapping) {
|
|
const promises = [];
|
|
for (const key of keys) {
|
|
promises.push(setCommandContext(`${CommandContext.Key}:${key}`, Boolean(mapping && mapping[key])));
|
|
}
|
|
await Promise.all(promises);
|
|
}
|
|
}
|
|
|
|
export class Keyboard implements Disposable {
|
|
private _disposable: Disposable;
|
|
|
|
constructor() {
|
|
const subscriptions = keys.map(key =>
|
|
commands.registerCommand(`${extensionId}.key.${key}`, () => this.execute(key), this)
|
|
);
|
|
this._disposable = Disposable.from(...subscriptions);
|
|
}
|
|
|
|
dispose() {
|
|
this._disposable && this._disposable.dispose();
|
|
}
|
|
|
|
async beginScope(mapping?: KeyMapping): Promise<KeyboardScope> {
|
|
Logger.log('Keyboard.beginScope', mappings.length);
|
|
return await new KeyboardScope(
|
|
mapping ? Object.assign(Object.create(null), mapping) : Object.create(null)
|
|
).begin();
|
|
}
|
|
|
|
async execute(key: Keys): Promise<{} | undefined> {
|
|
if (!mappings.length) return undefined;
|
|
|
|
try {
|
|
const mapping = mappings[mappings.length - 1];
|
|
|
|
let command = mapping[key] as KeyCommand | (() => Promise<KeyCommand>);
|
|
if (typeof command === 'function') {
|
|
command = await command();
|
|
}
|
|
if (!command || typeof command.onDidPressKey !== 'function') return undefined;
|
|
|
|
Logger.log('Keyboard.execute', key);
|
|
|
|
return await command.onDidPressKey(key);
|
|
}
|
|
catch (ex) {
|
|
Logger.error(ex, 'Keyboard.execute');
|
|
return undefined;
|
|
}
|
|
}
|
|
}
|