新增：页面全局快捷键注册方法

modstart · modstart · commit 64ef1789e96d · 2025-07-14T13:22:31.000+08:00
diff --git a/electron/lib/util.ts b/electron/lib/util.ts
@@ -6,6 +6,7 @@ import Showdown from "showdown"
 import iconvLite from "iconv-lite";
 import chardet from "chardet";
 import {Iconv} from "iconv"
+import {isMac, isWin} from "./env";
 
 export const sleep = (time = 1000) => {
     return new Promise((resolve) => {
@@ -103,7 +104,11 @@ export const StrUtil = {
             Date.now(),
             (Math.floor(Math.random() * 1000000) + '').padStart(6, '0')
         ].join('')
-    }
+    },
+    ucFirst(str: string) {
+        if (!str) return '';
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    },
 }
 
 export const TimeUtil = {
@@ -469,3 +474,105 @@ export const MarkdownUtil = {
     },
 }
 
+type HotkeyModifierType = 'Control' | 'Option' | 'Command' | 'Ctrl' | 'Alt' | 'Win' | 'Meta' | 'Shift';
+type HotkeyType = { key: string, modifiers: HotkeyModifierType[] }
+
+export const HotKeyUtil = {
+    orderModifiers(modifiers: HotkeyModifierType[]) {
+        const order = ['Control', 'Ctrl', 'Command', 'Meta', 'Win', 'Option', 'Alt', 'Shift'];
+        return modifiers.sort((a, b) => {
+            return order.indexOf(a) - order.indexOf(b);
+        });
+    },
+    unifyObject(hotkey: HotkeyType) {
+        return {
+            key: hotkey.key.toUpperCase(),
+            modifiers: this.orderModifiers(hotkey.modifiers.map(modifier => StrUtil.ucFirst(modifier)))
+        };
+    },
+    unifyString(hotkey: string): HotkeyType {
+        const parts = hotkey.split('+');
+        const key = (parts.pop() || '');
+        const modifiers: any[] = [];
+        parts.forEach(part => {
+            modifiers.push(StrUtil.ucFirst(part.trim()));
+        });
+        return this.unifyObject({key, modifiers});
+    },
+    unify(hotkeys: string | string[] | HotkeyType | HotkeyType[]): HotkeyType[] {
+        if (typeof hotkeys === 'string') {
+            return [this.unifyString(hotkeys)];
+        } else if (Array.isArray(hotkeys)) {
+            return hotkeys.map(hotkey => {
+                if (typeof hotkey === 'string') {
+                    return this.unifyString(hotkey);
+                } else {
+                    return this.unifyObject(hotkey);
+                }
+            });
+        } else {
+            return [this.unifyObject(hotkeys)];
+        }
+    },
+    getFromEvent(event: any): HotkeyType | null {
+        const valid = [
+            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+            '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
+            'Space',
+        ]
+        const key = (event.key || '').toUpperCase();
+        if (!event || !event.key || !valid.includes(key)) {
+            return null
+        }
+        const modifiers: HotkeyModifierType[] = [];
+        if (isWin) {
+            if (event.ctrlKey || event.control) {
+                modifiers.push('Ctrl');
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push('Alt');
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push('Win');
+            }
+        } else if (isMac) {
+            if (event.ctrlKey || event.control) {
+                modifiers.push('Control');
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push('Option');
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push('Command');
+            }
+        } else {
+            if (event.ctrlKey || event.control) {
+                modifiers.push('Ctrl');
+            }
+            if (event.altKey || event.alt) {
+                modifiers.push('Alt');
+            }
+            if (event.metaKey || event.meta) {
+                modifiers.push('Meta');
+            }
+        }
+        if (event.shiftKey || event.shift) {
+            modifiers.push('Shift');
+        }
+        return this.unifyObject({key, modifiers});
+    },
+    match(hotkeysForMatch: HotkeyType[], hotkey: HotkeyType): boolean {
+        if (!hotkeysForMatch || !hotkey) {
+            return false
+        }
+        const hotKeyStr = hotkey.modifiers.join('+') + '+' + hotkey.key;
+        for (const key of hotkeysForMatch) {
+            const keyStr = key.modifiers.join('+') + '+' + key.key;
+            if (keyStr === hotKeyStr) {
+                return true
+            }
+        }
+        return false
+    }
+}
diff --git a/electron/mapi/manager/lib/hooks.ts b/electron/mapi/manager/lib/hooks.ts
@@ -8,6 +8,7 @@ type PluginHookType = never
     | 'PluginEvent'
     | 'SubInputChange'
     | 'ScreenCapture'
+    | 'Hotkey'
 
 type HookType = never
     | 'Show'
diff --git a/electron/mapi/manager/plugin/event.ts b/electron/mapi/manager/plugin/event.ts
@@ -72,6 +72,24 @@ export const ManagerPluginEvent = {
         }
         ManagerPluginEvent.pluginEvents[event] = ManagerPluginEvent.pluginEvents[event].filter(c => c !== context)
     },
+    registerHotkey: async (context: PluginContext, data: any) => {
+        if (!context._event) {
+            context._event = {}
+        }
+        if (!context._event['Hotkey']) {
+            context._event['Hotkey'] = []
+        }
+        const {id, hotkeys} = data
+        context._event['Hotkey'].push({
+            id, hotkeys
+        })
+    },
+    unregisterHotkeyAll: async (context: PluginContext, data: any) => {
+        if (!context._event || !context._event['HotKey']) {
+            return
+        }
+        context._event['Hotkey'] = []
+    },
     isMacOs: async (context: PluginContext, data: any) => {
         return isMac
     },
diff --git a/electron/mapi/manager/type.ts b/electron/mapi/manager/type.ts
@@ -5,6 +5,9 @@ import {ActiveWindow, PluginRecord} from "../../../src/types/Manager";
 export type PluginContext = (BrowserView | {}) & {
     _plugin: PluginRecord,
     _window?: BrowserWindow,
+    _event?: {
+        [key: string]: any[],
+    }
 }
 
 export type SearchQuery = {
diff --git a/electron/mapi/manager/window/index.ts b/electron/mapi/manager/window/index.ts
@@ -13,6 +13,8 @@ import {Events} from "../../event/main";
 import {ManagerSystem} from "../system";
 import {AppsMain} from "../../app/main";
 import {ManagerPluginEvent} from "../plugin/event";
+import {PluginContext} from "../type";
+import {HotKeyUtil} from "../../../lib/util";
 
 const browserViews = new Map<WebContents, BrowserView>()
 const detachWindows = new Map<WebContents, BrowserWindow>()
@@ -262,12 +264,31 @@ export const ManagerWindow = {
                 // exit when Escape key is pressed
                 if (mainWindowView === view) {
                     if (input.key === 'Escape') {
-                        if (mainWindowView) {
-                            ManagerWindow.close()
-                            AppRuntime.mainWindow.webContents.focus()
+                        if (!(input.meta || input.control || input.shift || input.alt)) {
+                            if (mainWindowView) {
+                                ManagerWindow.close()
+                                AppRuntime.mainWindow.webContents.focus()
+                            }
+                        }
+                    }
+                } else {
+                    if (input.key === 'Escape') {
+                        if (!(input.meta || input.control || input.shift || input.alt)) {
+                            view._window.isFullScreen() && view._window.setFullScreen(false);
                         }
                     }
                 }
+            } else if (input.type === 'keyDown') {
+                if ((view as PluginContext)._event && (view as PluginContext)._event['Hotkey']) {
+                    const hotkey = HotKeyUtil.getFromEvent(input)
+                    if (hotkey) {
+                        (view as PluginContext)._event['Hotkey'].forEach(({id, hotkeys}) => {
+                            if (HotKeyUtil.match(hotkeys, hotkey)) {
+                                executePluginHooks(view as BrowserView, 'Hotkey', {id, hotkey});
+                            }
+                        })
+                    }
+                }
             }
         })
         const windowOption = {
@@ -476,13 +497,18 @@ export const ManagerWindow = {
             // console.log('detach.render-process-gone')
             win.close();
         });
-        view.webContents.on('before-input-event', (event, input) => {
-            if (input.type !== 'keyDown') return;
-            if (!(input.meta || input.control || input.shift || input.alt)) {
-                if (input.key === 'Escape') {
-                    win.isFullScreen() && win.setFullScreen(false);
+        win.webContents.on('before-input-event', (event, input) => {
+            if (input.type === 'keyDown') {
+                if ((view as PluginContext)._event && (view as PluginContext)._event['Hotkey']) {
+                    const hotkey = HotKeyUtil.getFromEvent(input)
+                    if (hotkey) {
+                        (view as PluginContext)._event['Hotkey'].forEach(({id, hotkeys}) => {
+                            if (HotKeyUtil.match(hotkeys, hotkey)) {
+                                executePluginHooks(view as BrowserView, 'Hotkey', {id, hotkey});
+                            }
+                        })
+                    }
                 }
-                return;
             }
         });
         if (isMac) {
diff --git a/electron/preload/focusany.ts b/electron/preload/focusany.ts
@@ -2,8 +2,9 @@ import os from "os";
 import electronRemote from "@electron/remote";
 import path from "path";
 import fs from "fs";
-import {EncodeUtil, FileUtil, StrUtil, TimeUtil} from "../lib/util";
+import {EncodeUtil, FileUtil, HotKeyUtil, StrUtil, TimeUtil} from "../lib/util";
 import {ipcRenderer, shell} from 'electron'
+import {isMac} from "../lib/env";
 
 const ipcSendSync = (type: string, data?: any) => {
     executeHook('Log', `${type}`, data)
@@ -123,6 +124,48 @@ export const FocusAny = {
         delete FocusAny.hooks.onPluginEventCallbacks[event]
         ipcSend('unregisterPluginEvent', {event})
     },
+    registerHotkey(
+        key: string
+            | string[]
+            | HotkeyQuickType
+            | HotkeyType
+            | HotkeyType[]
+        ,
+        callback: () => void,
+    ) {
+        if ('save' === key) {
+            if (isMac) {
+                key = 'Command+S'
+            } else {
+                key = 'Ctrl+S'
+            }
+        }
+        const hotkeys = HotKeyUtil.unify(key)
+        if (!('hotKeyListeners' in FocusAny.hooks)) {
+            FocusAny.hooks.hotKeyListeners = []
+            FocusAny.hooks.onHotkey = (payload: {
+                id: string, hotkey: HotkeyType
+            }) => {
+                const {id, hotkey} = payload
+                FocusAny.hooks.hotKeyListeners.forEach((listener: {
+                    id: string,
+                    hotkeys: HotkeyType[],
+                    callback: () => void
+                }) => {
+                    if (listener.id === id) {
+                        listener.callback();
+                    }
+                });
+            }
+        }
+        const id = StrUtil.randomString(16)
+        FocusAny.hooks.hotKeyListeners.push({id, hotkeys, callback})
+        ipcSend('registerHotkey', {id, hotkeys})
+    },
+    unregisterHotkeyAll() {
+        FocusAny.hooks.hotKeyListeners = []
+        ipcSend('unregisterHotkeyAll', {})
+    },
     onLog(cb: Function) {
         FocusAny.hooks.onLog = cb
     },
diff --git a/sdk/focusany.d.ts b/sdk/focusany.d.ts
@@ -23,7 +23,13 @@ declare type PlatformType = 'win' | 'osx' | 'linux'
 
 declare type EditionType = 'open' | 'pro'
 
-declare type PluginEvent = 'ClipboardChange' | 'UserChange'
+declare type PluginEvent = 'ClipboardChange' | 'UserChange' | '_HotKey'
+
+declare type HotkeyModifierType = 'Control' | 'Option' | 'Command' | 'Ctrl' | 'Alt' | 'Win' | 'Meta' | 'Shift'
+
+declare type HotkeyType = { key: string, modifiers: HotkeyModifierType[] }
+
+declare type HotkeyQuickType = 'save'
 
 declare type ActionMatch = (
     ActionMatchText
@@ -158,6 +164,26 @@ interface FocusAnyApi {
      */
     offPluginEventAll(event: PluginEvent): void;
 
+    /**
+     * register hot
+     * @param key
+     * @param callback
+     */
+    registerHotkey(
+        key: string
+            | string[]
+            | HotkeyQuickType
+            | HotkeyType
+            | HotkeyType[]
+        ,
+        callback: () => void,
+    ): void;
+
+    /**
+     * unregister all hotkey
+     */
+    unregisterHotkeyAll(): void;
+
     /**
      * 插件主窗口是否显示
      */
diff --git a/src/pages/PageDetachWindow.vue b/src/pages/PageDetachWindow.vue
@@ -105,9 +105,6 @@ window.__page.onLeaveFullScreen(() => {
     isFullscreen.value = false
     console.log('onLeaveFullScreen')
 })
-window.addEventListener('keydown', (e) => {
-    console.log('PageDetachWindow.keydown', e)
-})
 </script>
 
 <template>

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,9 @@ import {ActiveWindow, PluginRecord} from "../../../src/types/Manager";`
`5`	`5`	`export type PluginContext = (BrowserView \| {}) & {`
`6`	`6`	`_plugin: PluginRecord,`
`7`	`7`	`_window?: BrowserWindow,`
	`8`	`+ _event?: {`
	`9`	`+ [key: string]: any[],`
	`10`	`+ }`
`8`	`11`	`}`
`9`	`12`
`10`	`13`	`export type SearchQuery = {`