TypeScript electron.globalShortcut类代码示例

const registerShortcuts = (): void => {
  // Global mute shortcut
  globalShortcut.register('CmdOrCtrl+Alt+M', () =>
    WindowManager.sendActionToPrimaryWindow(EVENT_TYPE.UI.SYSTEM_MENU, EVENT_TYPE.CONVERSATION.TOGGLE_MUTE)
  );

  // Global account switching shortcut
  const switchAccountShortcut = ['CmdOrCtrl', 'Super'];
  const accountLimit = config.MAXIMUM_ACCOUNTS;
  for (const shortcut of switchAccountShortcut) {
    for (let accountId = 0; accountId < accountLimit; accountId++) {
      globalShortcut.register(`${shortcut}+${accountId + 1}`, () =>
        WindowManager.sendActionToPrimaryWindow(EVENT_TYPE.ACTION.SWITCH_ACCOUNT, accountId)
      );
    }
  }
};

const __refreshMenu = _.debounce(function () {
    Menu.setApplicationMenu(Menu.buildFromTemplate(_.cloneDeep(menuTemplate)));
    globalShortcut.unregisterAll();
    const mainWindow = shell.getMainWindow();
    if (mainWindow.isFocused()) {
        menuTemplate.forEach((menuItem) => registerShortcuts(menuItem));
    }
}, 100);

  let onReady = () => {
    if (!env.integrationTests) {
      const shouldQuit = app.makeSingleInstance((argv, cwd) => {
        // we only get inside this callback when another instance
        // is launched - so this executes in the context of the main instance
        store.dispatch(
          actions.processUrlArguments({
            args: argv,
          })
        );
        store.dispatch(actions.focusWind({ wind: "root" }));
      });
      if (shouldQuit) {
        app.exit(0);
        return;
      }
    }

    store.dispatch(
      actions.processUrlArguments({
        args: process.argv,
      })
    );

    globalShortcut.register("Control+Alt+Backspace", function() {
      store.dispatch(actions.forceCloseLastGame({}));
    });

    // Emitted when the application is activated. Various actions can trigger
    // this event, such as launching the application for the first time,
    // attempting to re-launch the application when it's already running, or
    // clicking on the application's dock or taskbar icon.
    app.on("activate", () => {
      store.dispatch(actions.focusWind({ wind: "root" }));
    });

    app.on("before-quit", e => {
      e.preventDefault();
      store.dispatch(actions.quit({}));
    });

    store.dispatch(actions.preboot({}));

    setInterval(() => {
      try {
        store.dispatch(actions.tick({}));
      } catch (e) {
        mainLogger.error(`While dispatching tick: ${e.stack}`);
      }
    }, 1 * 1000 /* every second */);
  };

const handleModifyHotkey = (event, args: IModifyHotkeyArgs) => {
  const { type, payload } = args;
  let shortcuts;
  if (type === 'switch') {
    if (!payload) {
      globalShortcut.unregisterAll();
      return;
    }
    settings.set(ENABLE_HOTKEY, payload);
    shortcuts = settings.get(GLOBAL_SHORTCUT, DEFAULT_GLOBAL_SHORTCUT);
  } else {
    shortcuts = payload;
    settings.set(GLOBAL_SHORTCUT, shortcuts);
  }
  registerHotkeys(shortcuts);
  event.sender.send(MODIFY_HOTKEY, { type, status: 'success' });
};

  let onReady = () => {
    if (!env.integrationTests) {
      const shouldQuit = app.makeSingleInstance((argv, cwd) => {
        // we only get inside this callback when another instance
        // is launched - so this executes in the context of the main instance
        store.dispatch(
          actions.processUrlArguments({
            args: argv,
          })
        );
        store.dispatch(actions.focusWindow({ window: "root" }));
      });

      if (shouldQuit) {
        app.exit(0);
        return;
      }
    }

    store.dispatch(
      actions.processUrlArguments({
        args: process.argv,
      })
    );

    globalShortcut.register("Control+Alt+Backspace", function() {
      store.dispatch(actions.forceCloseLastGame({}));
    });

    if (rt) {
      rt.end();
    }

    store.dispatch(actions.preboot({}));

    setInterval(() => {
      try {
        store.dispatch(actions.tick({}));
      } catch (e) {
        logger.error(`While dispatching tick: ${e.stack}`);
      }
    }, 1 * 1000 /* every second */);
  };

function createWindow()
{
    mainWindow =
        new BrowserWindow(
        {
            width: 650,
            height: 500,
            autoHideMenuBar: true,
            title: 'electroshell'

            // Enable these to have transparent window background
            //transparent: true,
            //frame: false,
        });

    var ret = globalShortcut.register('super+`', function()
    {
        if (mainWindow.isMinimized())
        {
            mainWindow.restore();
        }
        mainWindow.focus();
    });

    // Load the index.html of the app
    //mainWindow.loadURL('file://' + __dirname + '/index.html');
    mainWindow.loadURL('http://localhost:8080/index.html');

    mainWindow.on('closed', function() {
        // Dereference the window object
        mainWindow = null;
    });

    // Start PowerShell Editor Services
    editorServicesClient = new EditorServicesClient();
    editorServicesClient.start(mainWindow.webContents);
}

    socket.on('globalShortcut-isRegistered', (accelerator) => {
        const isRegistered = globalShortcut.isRegistered(accelerator);

        socket.emit('globalShortcut-isRegisteredCompleted', isRegistered);
    });

 socket.on('globalShortcut-unregisterAll', () => {
     try {
         globalShortcut.unregisterAll();            
     } catch (error) { }
 });