monaco-editor
Version:
A browser based code editor
136 lines (135 loc) • 6.74 kB
JavaScript
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
import * as nls from '../../../nls.js';
import { IntervalTimer } from '../../../base/common/async.js';
import { Emitter, Event } from '../../../base/common/event.js';
import { Disposable } from '../../../base/common/lifecycle.js';
var AbstractKeybindingService = /** @class */ (function (_super) {
__extends(AbstractKeybindingService, _super);
function AbstractKeybindingService(contextKeyService, commandService, telemetryService, notificationService, statusService) {
var _this = _super.call(this) || this;
_this._contextKeyService = contextKeyService;
_this._commandService = commandService;
_this._telemetryService = telemetryService;
_this._statusService = statusService;
_this._notificationService = notificationService;
_this._currentChord = null;
_this._currentChordChecker = new IntervalTimer();
_this._currentChordStatusMessage = null;
_this._onDidUpdateKeybindings = _this._register(new Emitter());
return _this;
}
AbstractKeybindingService.prototype.dispose = function () {
_super.prototype.dispose.call(this);
};
Object.defineProperty(AbstractKeybindingService.prototype, "onDidUpdateKeybindings", {
get: function () {
return this._onDidUpdateKeybindings ? this._onDidUpdateKeybindings.event : Event.None; // Sinon stubbing walks properties on prototype
},
enumerable: true,
configurable: true
});
AbstractKeybindingService.prototype.lookupKeybinding = function (commandId) {
var result = this._getResolver().lookupPrimaryKeybinding(commandId);
if (!result) {
return null;
}
return result.resolvedKeybinding;
};
AbstractKeybindingService.prototype._enterChordMode = function (firstPart, keypressLabel) {
var _this = this;
this._currentChord = {
keypress: firstPart,
label: keypressLabel
};
if (this._statusService) {
this._currentChordStatusMessage = this._statusService.setStatusMessage(nls.localize('first.chord', "({0}) was pressed. Waiting for second key of chord...", keypressLabel));
}
var chordEnterTime = Date.now();
this._currentChordChecker.cancelAndSet(function () {
if (!_this._documentHasFocus()) {
// Focus has been lost => leave chord mode
_this._leaveChordMode();
return;
}
if (Date.now() - chordEnterTime > 5000) {
// 5 seconds elapsed => leave chord mode
_this._leaveChordMode();
}
}, 500);
};
AbstractKeybindingService.prototype._leaveChordMode = function () {
if (this._currentChordStatusMessage) {
this._currentChordStatusMessage.dispose();
this._currentChordStatusMessage = null;
}
this._currentChordChecker.cancel();
this._currentChord = null;
};
AbstractKeybindingService.prototype._dispatch = function (e, target) {
var _this = this;
var shouldPreventDefault = false;
var keybinding = this.resolveKeyboardEvent(e);
if (keybinding.isChord()) {
console.warn('Unexpected keyboard event mapped to a chord');
return false;
}
var firstPart = keybinding.getDispatchParts()[0];
if (firstPart === null) {
// cannot be dispatched, probably only modifier keys
return shouldPreventDefault;
}
var contextValue = this._contextKeyService.getContext(target);
var currentChord = this._currentChord ? this._currentChord.keypress : null;
var keypressLabel = keybinding.getLabel();
var resolveResult = this._getResolver().resolve(contextValue, currentChord, firstPart);
if (resolveResult && resolveResult.enterChord) {
shouldPreventDefault = true;
this._enterChordMode(firstPart, keypressLabel);
return shouldPreventDefault;
}
if (this._statusService && this._currentChord) {
if (!resolveResult || !resolveResult.commandId) {
this._statusService.setStatusMessage(nls.localize('missing.chord', "The key combination ({0}, {1}) is not a command.", this._currentChord.label, keypressLabel), 10 * 1000 /* 10s */);
shouldPreventDefault = true;
}
}
this._leaveChordMode();
if (resolveResult && resolveResult.commandId) {
if (!resolveResult.bubble) {
shouldPreventDefault = true;
}
if (typeof resolveResult.commandArgs === 'undefined') {
this._commandService.executeCommand(resolveResult.commandId).then(undefined, function (err) { return _this._notificationService.warn(err); });
}
else {
this._commandService.executeCommand(resolveResult.commandId, resolveResult.commandArgs).then(undefined, function (err) { return _this._notificationService.warn(err); });
}
/* __GDPR__
"workbenchActionExecuted" : {
"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
"from": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
}
*/
this._telemetryService.publicLog('workbenchActionExecuted', { id: resolveResult.commandId, from: 'keybinding' });
}
return shouldPreventDefault;
};
return AbstractKeybindingService;
}(Disposable));
export { AbstractKeybindingService };