summaryrefslogtreecommitdiff
path: root/ext/js/input/hotkey-handler.js
diff options
context:
space:
mode:
Diffstat (limited to 'ext/js/input/hotkey-handler.js')
-rw-r--r--ext/js/input/hotkey-handler.js267
1 files changed, 267 insertions, 0 deletions
diff --git a/ext/js/input/hotkey-handler.js b/ext/js/input/hotkey-handler.js
new file mode 100644
index 00000000..423410b7
--- /dev/null
+++ b/ext/js/input/hotkey-handler.js
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2021 Yomichan Authors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/* global
+ * DocumentUtil
+ * api
+ */
+
+/**
+ * Class which handles hotkey events and actions.
+ */
+class HotkeyHandler extends EventDispatcher {
+ /**
+ * Creates a new instance of the class.
+ */
+ constructor() {
+ super();
+ this._actions = new Map();
+ this._hotkeys = new Map();
+ this._hotkeyRegistrations = new Map();
+ this._eventListeners = new EventListenerCollection();
+ this._isPrepared = false;
+ this._hasEventListeners = false;
+ this._forwardFrameId = null;
+ }
+
+ /**
+ * Gets the frame ID used for forwarding hotkeys.
+ */
+ get forwardFrameId() {
+ return this._forwardFrameId;
+ }
+
+ /**
+ * Sets the frame ID used for forwarding hotkeys.
+ */
+ set forwardFrameId(value) {
+ this._forwardFrameId = value;
+ this._updateHotkeyRegistrations();
+ }
+
+ /**
+ * Begins listening to key press events in order to detect hotkeys.
+ */
+ prepare() {
+ this._isPrepared = true;
+ this._updateEventHandlers();
+ api.crossFrame.registerHandlers([
+ ['hotkeyHandler.forwardHotkey', {async: false, handler: this._onMessageForwardHotkey.bind(this)}]
+ ]);
+ }
+
+ /**
+ * Registers a set of actions that this hotkey handler supports.
+ * @param actions An array of `[name, handler]` entries, where `name` is a string and `handler` is a function.
+ */
+ registerActions(actions) {
+ for (const [name, handler] of actions) {
+ this._actions.set(name, handler);
+ }
+ }
+
+ /**
+ * Registers a set of hotkeys for a given scope.
+ * @param scope The scope that the hotkey definitions must be for in order to be activated.
+ * @param hotkeys An array of hotkey definitions of the format `{action, key, modifiers, scopes, enabled}`.
+ * * `action` - a string indicating which action to perform.
+ * * `key` - a keyboard key code indicating which key needs to be pressed.
+ * * `modifiers` - an array of keyboard modifiers which also need to be pressed. Supports: `'alt', 'ctrl', 'shift', 'meta'`.
+ * * `scopes` - an array of scopes for which the hotkey is valid. If this array does not contain `this.scope`, the hotkey will not be registered.
+ * * `enabled` - a boolean indicating whether the hotkey is currently enabled.
+ */
+ registerHotkeys(scope, hotkeys) {
+ let registrations = this._hotkeyRegistrations.get(scope);
+ if (typeof registrations === 'undefined') {
+ registrations = [];
+ this._hotkeyRegistrations.set(scope, registrations);
+ }
+ registrations.push(...hotkeys);
+ this._updateHotkeyRegistrations();
+ }
+
+ /**
+ * Removes all registered hotkeys for a given scope.
+ */
+ clearHotkeys(scope) {
+ const registrations = this._hotkeyRegistrations.get(scope);
+ if (typeof registrations !== 'undefined') {
+ registrations.length = 0;
+ }
+ this._updateHotkeyRegistrations();
+ }
+
+ /**
+ * Assigns a set of hotkeys for a given scope. This is an optimized shorthand for calling
+ * `clearHotkeys`, then calling `registerHotkeys`.
+ * @see registerHotkeys for argument information.
+ */
+ setHotkeys(scope, hotkeys) {
+ let registrations = this._hotkeyRegistrations.get(scope);
+ if (typeof registrations === 'undefined') {
+ registrations = [];
+ this._hotkeyRegistrations.set(scope, registrations);
+ } else {
+ registrations.length = 0;
+ }
+ registrations.push(...hotkeys);
+ this._updateHotkeyRegistrations();
+ }
+
+ /**
+ * Adds a single event listener to a specific event.
+ * @param eventName The string representing the event's name.
+ * @param callback The event listener callback to add.
+ */
+ on(eventName, callback) {
+ const result = super.on(eventName, callback);
+ this._updateHasEventListeners();
+ this._updateEventHandlers();
+ return result;
+ }
+
+ /**
+ * Removes a single event listener from a specific event.
+ * @param eventName The string representing the event's name.
+ * @param callback The event listener callback to add.
+ * @returns `true` if the callback was removed, `false` otherwise.
+ */
+ off(eventName, callback) {
+ const result = super.off(eventName, callback);
+ this._updateHasEventListeners();
+ this._updateEventHandlers();
+ return result;
+ }
+
+ /**
+ * Attempts to simulate an action for a given combination of key and modifiers.
+ * @param key A keyboard key code indicating which key needs to be pressed.
+ * @param modifiers An array of keyboard modifiers which also need to be pressed. Supports: `'alt', 'ctrl', 'shift', 'meta'`.
+ * @returns `true` if an action was performed, `false` otherwise.
+ */
+ simulate(key, modifiers) {
+ const hotkeyInfo = this._hotkeys.get(key);
+ return (
+ typeof hotkeyInfo !== 'undefined' &&
+ this._invokeHandlers(key, modifiers, hotkeyInfo, false)
+ );
+ }
+
+ // Message handlers
+
+ _onMessageForwardHotkey({key, modifiers}) {
+ return this.simulate(key, modifiers);
+ }
+
+ // Private
+
+ _onKeyDown(e) {
+ const key = e.code;
+ const hotkeyInfo = this._hotkeys.get(key);
+ if (typeof hotkeyInfo !== 'undefined') {
+ const eventModifiers = DocumentUtil.getActiveModifiers(e);
+ const canForward = (this._forwardFrameId !== null);
+ if (this._invokeHandlers(key, eventModifiers, hotkeyInfo, canForward)) {
+ e.preventDefault();
+ return;
+ }
+ }
+ this.trigger('keydownNonHotkey', e);
+ }
+
+ _invokeHandlers(key, modifiers, hotkeyInfo, canForward) {
+ for (const {modifiers: handlerModifiers, action} of hotkeyInfo.handlers) {
+ if (!this._areSame(handlerModifiers, modifiers)) { continue; }
+
+ const actionHandler = this._actions.get(action);
+ if (typeof actionHandler !== 'undefined') {
+ const result = actionHandler();
+ if (result !== false) {
+ return true;
+ }
+ }
+ }
+
+ if (canForward && hotkeyInfo.forward) {
+ this._forwardHotkey(key, modifiers);
+ return true;
+ }
+
+ return false;
+ }
+
+ _areSame(set, array) {
+ if (set.size !== array.length) { return false; }
+ for (const value of array) {
+ if (!set.has(value)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ _updateHotkeyRegistrations() {
+ if (this._hotkeys.size === 0 && this._hotkeyRegistrations.size === 0) { return; }
+
+ const canForward = (this._forwardFrameId !== null);
+ this._hotkeys.clear();
+ for (const [scope, registrations] of this._hotkeyRegistrations.entries()) {
+ for (const {action, key, modifiers, scopes, enabled} of registrations) {
+ if (!(enabled && key !== null && action !== '')) { continue; }
+
+ const correctScope = scopes.includes(scope);
+ if (!correctScope && !canForward) { continue; }
+
+ let hotkeyInfo = this._hotkeys.get(key);
+ if (typeof hotkeyInfo === 'undefined') {
+ hotkeyInfo = {handlers: [], forward: false};
+ this._hotkeys.set(key, hotkeyInfo);
+ }
+
+ if (correctScope) {
+ hotkeyInfo.handlers.push({modifiers: new Set(modifiers), action});
+ } else {
+ hotkeyInfo.forward = true;
+ }
+ }
+ }
+ this._updateEventHandlers();
+ }
+
+ _updateHasEventListeners() {
+ this._hasEventListeners = this.hasListeners('keydownNonHotkey');
+ }
+
+ _updateEventHandlers() {
+ if (this._isPrepared && (this._hotkeys.size > 0 || this._hasEventListeners)) {
+ if (this._eventListeners.size !== 0) { return; }
+ this._eventListeners.addEventListener(document, 'keydown', this._onKeyDown.bind(this), false);
+ } else {
+ this._eventListeners.removeAllEventListeners();
+ }
+ }
+
+ async _forwardHotkey(key, modifiers) {
+ const frameId = this._forwardFrameId;
+ if (frameId === null) { throw new Error('No forwarding target'); }
+ try {
+ await api.crossFrame.invoke(frameId, 'hotkeyHandler.forwardHotkey', {key, modifiers});
+ } catch (e) {
+ // NOP
+ }
+ }
+}