yy-menu
Version:
A traditional menu system for web apps inspired by Electron
184 lines (173 loc) • 21.5 kB
JavaScript
let Menu;
class Accelerators {
/**
* Handles all keyboard input for the menu and user-registered keys registered through Menu.GlobalAccelerator
* @param {object} options
* @param {HTMLElement} [options.div] used for global accelerators (usually attached to document.body)
* @param {Menu} [options.menu] Menu to attach accelerators
*/
constructor(options) {
Menu = require('./menu');
this.menuKeys = {};
this.keys = {};
if (options.div) {
options.div.addEventListener('keydown', e => this.keyDown(this, e));
} else {
options.menu.div.addEventListener('keydown', e => this.keyDown(this, e));
}
}
/**
* clear all user-registered keys
*/
clearKeys() {
this.keys = {};
}
/**
* Register a shortcut key for use by an open menu
* @param {KeyCodes} letter
* @param {MenuItem} menuItem
* @param {boolean} applicationMenu
* @private
*/
registerMenuShortcut(letter, menuItem) {
if (letter) {
const keyCode = (menuItem.menu.applicationMenu ? 'alt+' : '') + letter;
this.menuKeys[Accelerators.prepareKey(keyCode)] = e => {
menuItem.handleClick(e);
e.stopPropagation();
e.preventDefault();
};
}
}
/**
* Register special shortcut keys for menu
* @param {MenuItem} menuItem
* @private
*/
registerMenuSpecial(menu) {
this.menuKeys['escape'] = () => Menu.getApplicationMenu().closeAll();
this.menuKeys['enter'] = e => menu.enter(e);
this.menuKeys['space'] = e => menu.enter(e);
this.menuKeys['arrowright'] = e => menu.move(e, 'right');
this.menuKeys['arrowleft'] = e => menu.move(e, 'left');
this.menuKeys['arrowup'] = e => menu.move(e, 'up');
this.menuKeys['arrowdown'] = e => menu.move(e, 'down');
}
/**
* Removes menu shortcuts
* @private
*/
unregisterMenuShortcuts() {
this.menuKeys = {};
}
/**
* Keycodes definition. In the form of modifier[+modifier...]+key
* <p>For example: ctrl+shift+e</p>
* <p>KeyCodes are case insensitive (i.e., shift+a is the same as Shift+A)</p>
* <pre>
* Modifiers:
* ctrl, alt, shift, meta, (ctrl aliases: command, control, commandorcontrol)
* </pre>
* <pre>
* Keys:
* escape, 0-9, minus, equal, backspace, tab, a-z, backetleft, bracketright, semicolon, quote,
* backquote, backslash, comma, period, slash, numpadmultiply, space, capslock, f1-f24, pause,
* scrolllock, printscreen, home, arrowup, arrowleft, arrowright, arrowdown, pageup, pagedown,
* end, insert, delete, enter, shiftleft, shiftright, ctrlleft, ctrlright, altleft, altright, shiftleft,
* shiftright, numlock, numpad...
* </pre>
* For OS-specific codes and a more detailed explanation see {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code}. Also note that 'Digit' and 'Key' are removed from the code to make it easier to type.
*
* @typedef {string} Accelerators~KeyCodes
*/
/**
* translate a user-provided keycode
* @param {KeyCodes} keyCode
* @return {KeyCodes} formatted and sorted keyCode
* @private
*/
static prepareKey(keyCode) {
let modifiers = [];
let key = '';
keyCode = keyCode.toLowerCase();
if (keyCode.indexOf('+') !== -1) {
const split = keyCode.toLowerCase().split('+');
for (let i = 0; i < split.length - 1; i++) {
let modifier = split[i];
modifier = modifier.replace('commandorcontrol', 'ctrl');
modifier = modifier.replace('command', 'ctrl');
modifier = modifier.replace('control', 'ctrl');
modifiers.push(modifier);
}
modifiers = modifiers.sort((a, b) => {
return a[0] > b[0] ? 1 : a[0] < b[0] ? -1 : 0;
});
for (let part of modifiers) {
key += part + '+';
}
key += split[split.length - 1];
} else {
key = keyCode;
}
return key;
}
/**
* Make the KeyCode pretty for printing on the menu
* @param {KeyCode} keyCode
* @return {string}
* @private
*/
static prettifyKey(keyCode) {
keyCode = Accelerators.prepareKey(keyCode);
let key = '';
if (keyCode.indexOf('+') !== -1) {
const split = keyCode.toLowerCase().split('+');
for (let i = 0; i < split.length - 1; i++) {
let modifier = split[i];
key += modifier[0].toUpperCase() + modifier.substr(1) + '+';
}
key += split[split.length - 1].toUpperCase();
} else {
key = keyCode.toUpperCase();
}
return key;
}
/**
* register a key as a global accelerator
* @param {KeyCodes} keyCode (e.g., Ctrl+shift+E)
* @param {function} callback
*/
register(keyCode, callback) {
this.keys[Accelerators.prepareKey(keyCode)] = callback;
}
keyDown(accelerator, e) {
const modifiers = [];
if (e.altKey) {
modifiers.push('alt');
}
if (e.ctrlKey) {
modifiers.push('ctrl');
}
if (e.metaKey) {
modifiers.push('meta');
}
if (e.shiftKey) {
modifiers.push('shift');
}
let keyCode = '';
for (let modifier of modifiers) {
keyCode = modifier + '+';
}
let translate = e.code.toLowerCase();
translate = translate.replace('digit', '');
translate = translate.replace('key', '');
keyCode += translate;
if (this.menuKeys[keyCode]) {
this.menuKeys[keyCode](e, this);
} else if (this.keys[keyCode]) {
this.keys[keyCode](e, this);
}
}
}
module.exports = Accelerators;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/accelerators.js"],"names":["Menu","Accelerators","constructor","options","require","menuKeys","keys","div","addEventListener","e","keyDown","menu","clearKeys","registerMenuShortcut","letter","menuItem","keyCode","applicationMenu","prepareKey","handleClick","stopPropagation","preventDefault","registerMenuSpecial","getApplicationMenu","closeAll","enter","move","unregisterMenuShortcuts","modifiers","key","toLowerCase","indexOf","split","i","length","modifier","replace","push","sort","a","b","part","prettifyKey","toUpperCase","substr","register","callback","accelerator","altKey","ctrlKey","metaKey","shiftKey","translate","code","module","exports"],"mappings":"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","file":"accelerators.js","sourcesContent":["let Menu\r\n\r\nclass Accelerators\r\n{\r\n    /**\r\n     * Handles all keyboard input for the menu and user-registered keys registered through Menu.GlobalAccelerator\r\n     * @param {object} options\r\n     * @param {HTMLElement} [options.div] used for global accelerators (usually attached to document.body)\r\n     * @param {Menu} [options.menu] Menu to attach accelerators\r\n     */\r\n    constructor(options)\r\n    {\r\n        Menu = require('./menu')\r\n        this.menuKeys = {}\r\n        this.keys = {}\r\n        if (options.div)\r\n        {\r\n            options.div.addEventListener('keydown', (e) => this.keyDown(this, e))\r\n        }\r\n        else\r\n        {\r\n            options.menu.div.addEventListener('keydown', (e) => this.keyDown(this, e))\r\n        }\r\n    }\r\n\r\n    /**\r\n     * clear all user-registered keys\r\n     */\r\n    clearKeys()\r\n    {\r\n        this.keys = {}\r\n    }\r\n\r\n    /**\r\n     * Register a shortcut key for use by an open menu\r\n     * @param {KeyCodes} letter\r\n     * @param {MenuItem} menuItem\r\n     * @param {boolean} applicationMenu\r\n     * @private\r\n     */\r\n    registerMenuShortcut(letter, menuItem)\r\n    {\r\n        if (letter)\r\n        {\r\n            const keyCode = (menuItem.menu.applicationMenu ? 'alt+' : '') + letter\r\n            this.menuKeys[Accelerators.prepareKey(keyCode)] = (e) =>\r\n            {\r\n                menuItem.handleClick(e)\r\n                e.stopPropagation()\r\n                e.preventDefault()\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Register special shortcut keys for menu\r\n     * @param {MenuItem} menuItem\r\n     * @private\r\n     */\r\n    registerMenuSpecial(menu)\r\n    {\r\n        this.menuKeys['escape'] = () => Menu.getApplicationMenu().closeAll()\r\n        this.menuKeys['enter'] = (e) => menu.enter(e)\r\n        this.menuKeys['space'] = (e) => menu.enter(e)\r\n        this.menuKeys['arrowright'] = (e) => menu.move(e, 'right')\r\n        this.menuKeys['arrowleft'] = (e) => menu.move(e, 'left')\r\n        this.menuKeys['arrowup'] = (e) => menu.move(e, 'up')\r\n        this.menuKeys['arrowdown'] = (e) => menu.move(e, 'down')\r\n    }\r\n\r\n    /**\r\n     * Removes menu shortcuts\r\n     * @private\r\n     */\r\n    unregisterMenuShortcuts()\r\n    {\r\n        this.menuKeys = {}\r\n    }\r\n\r\n    /**\r\n     * Keycodes definition. In the form of modifier[+modifier...]+key\r\n     * <p>For example: ctrl+shift+e</p>\r\n     * <p>KeyCodes are case insensitive (i.e., shift+a is the same as Shift+A)</p>\r\n     * <pre>\r\n     * Modifiers:\r\n     *    ctrl, alt, shift, meta, (ctrl aliases: command, control, commandorcontrol)\r\n     * </pre>\r\n     * <pre>\r\n     * Keys:\r\n     *    escape, 0-9, minus, equal, backspace, tab, a-z, backetleft, bracketright, semicolon, quote,\r\n     *    backquote, backslash, comma, period, slash, numpadmultiply, space, capslock, f1-f24, pause,\r\n     *    scrolllock, printscreen, home, arrowup, arrowleft, arrowright, arrowdown, pageup, pagedown,\r\n     *    end, insert, delete, enter, shiftleft, shiftright, ctrlleft, ctrlright, altleft, altright, shiftleft,\r\n     *    shiftright, numlock, numpad...\r\n     * </pre>\r\n     * For OS-specific codes and a more detailed explanation see {@link https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code}. Also note that 'Digit' and 'Key' are removed from the code to make it easier to type.\r\n     *\r\n     * @typedef {string} Accelerators~KeyCodes\r\n     */\r\n\r\n    /**\r\n     * translate a user-provided keycode\r\n     * @param {KeyCodes} keyCode\r\n     * @return {KeyCodes} formatted and sorted keyCode\r\n     * @private\r\n     */\r\n    static prepareKey(keyCode)\r\n    {\r\n        let modifiers = []\r\n        let key = ''\r\n        keyCode = keyCode.toLowerCase()\r\n        if (keyCode.indexOf('+') !== -1)\r\n        {\r\n            const split = keyCode.toLowerCase().split('+')\r\n            for (let i = 0; i < split.length - 1; i++)\r\n            {\r\n                let modifier = split[i]\r\n                modifier = modifier.replace('commandorcontrol', 'ctrl')\r\n                modifier = modifier.replace('command', 'ctrl')\r\n                modifier = modifier.replace('control', 'ctrl')\r\n                modifiers.push(modifier)\r\n            }\r\n            modifiers = modifiers.sort((a, b) => { return a[0] > b[0] ? 1 : a[0] < b[0] ? -1 : 0 })\r\n            for (let part of modifiers)\r\n            {\r\n                key += part + '+'\r\n            }\r\n            key += split[split.length - 1]\r\n        }\r\n        else\r\n        {\r\n            key = keyCode\r\n        }\r\n        return key\r\n    }\r\n\r\n    /**\r\n     * Make the KeyCode pretty for printing on the menu\r\n     * @param {KeyCode} keyCode\r\n     * @return {string}\r\n     * @private\r\n     */\r\n    static prettifyKey(keyCode)\r\n    {\r\n        keyCode = Accelerators.prepareKey(keyCode)\r\n        let key = ''\r\n        if (keyCode.indexOf('+') !== -1)\r\n        {\r\n            const split = keyCode.toLowerCase().split('+')\r\n            for (let i = 0; i < split.length - 1; i++)\r\n            {\r\n                let modifier = split[i]\r\n                key += modifier[0].toUpperCase() + modifier.substr(1) + '+'\r\n            }\r\n            key += split[split.length - 1].toUpperCase()\r\n        }\r\n        else\r\n        {\r\n            key = keyCode.toUpperCase()\r\n        }\r\n        return key\r\n    }\r\n\r\n    /**\r\n     * register a key as a global accelerator\r\n     * @param {KeyCodes} keyCode (e.g., Ctrl+shift+E)\r\n     * @param {function} callback\r\n     */\r\n    register(keyCode, callback)\r\n    {\r\n        this.keys[Accelerators.prepareKey(keyCode)] = callback\r\n    }\r\n\r\n    keyDown(accelerator, e)\r\n    {\r\n        const modifiers = []\r\n        if (e.altKey)\r\n        {\r\n            modifiers.push('alt')\r\n        }\r\n        if (e.ctrlKey)\r\n        {\r\n            modifiers.push('ctrl')\r\n        }\r\n        if (e.metaKey)\r\n        {\r\n            modifiers.push('meta')\r\n        }\r\n        if (e.shiftKey)\r\n        {\r\n            modifiers.push('shift')\r\n        }\r\n        let keyCode = ''\r\n        for (let modifier of modifiers)\r\n        {\r\n            keyCode = modifier + '+'\r\n        }\r\n        let translate = e.code.toLowerCase()\r\n        translate = translate.replace('digit', '')\r\n        translate = translate.replace('key', '')\r\n        keyCode += translate\r\n        if (this.menuKeys[keyCode])\r\n        {\r\n            this.menuKeys[keyCode](e, this)\r\n        }\r\n        else if (this.keys[keyCode])\r\n        {\r\n            this.keys[keyCode](e, this)\r\n        }\r\n    }\r\n}\r\n\r\nmodule.exports = Accelerators"]}