1
0
mirror of https://github.com/mifi/lossless-cut.git synced 2024-11-22 18:32:34 +01:00
lossless-cut/public/electron.js

259 lines
8.2 KiB
JavaScript
Raw Normal View History

2022-11-23 03:50:26 +01:00
process.traceDeprecation = true;
process.traceProcessWarnings = true;
2016-10-30 11:57:12 +01:00
const electron = require('electron'); // eslint-disable-line
const isDev = require('electron-is-dev');
2020-04-17 17:44:57 +02:00
const unhandled = require('electron-unhandled');
const i18n = require('i18next');
const debounce = require('lodash/debounce');
const yargsParser = require('yargs-parser');
const JSON5 = require('json5');
2022-11-22 16:23:41 +01:00
const remote = require('@electron/remote/main');
2022-09-04 16:44:48 +02:00
const logger = require('./logger');
2016-10-30 11:57:12 +01:00
const menu = require('./menu');
2020-04-17 17:44:11 +02:00
const configStore = require('./configStore');
2016-10-30 11:57:12 +01:00
2018-02-17 15:15:30 +01:00
const { checkNewVersion } = require('./update-checker');
require('./i18n');
const { app, ipcMain } = electron;
2018-09-30 22:08:36 +02:00
const { BrowserWindow } = electron;
2016-10-30 11:57:12 +01:00
2022-11-22 16:23:41 +01:00
remote.initialize();
2022-11-22 16:53:57 +01:00
app.commandLine.appendSwitch('enable-features', 'PlatformHEVCDecoderSupport');
2020-04-17 17:44:57 +02:00
unhandled({
showDialog: true,
});
2020-02-11 15:16:03 +01:00
app.name = 'LosslessCut';
let filesToOpen = [];
2016-10-30 11:57:12 +01:00
// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let mainWindow;
2020-02-20 05:03:25 +01:00
let askBeforeClose = false;
2020-03-31 13:59:05 +02:00
let rendererReady = false;
let newVersion;
2020-03-31 13:59:05 +02:00
2022-02-23 12:43:19 +01:00
const openFiles = (paths) => mainWindow.webContents.send('openFiles', paths);
2020-02-20 05:03:25 +01:00
// https://github.com/electron/electron/issues/526#issuecomment-563010533
function getSizeOptions() {
const bounds = configStore.get('windowBounds');
const options = {};
if (bounds) {
const area = electron.screen.getDisplayMatching(bounds).workArea;
// If the saved position still valid (the window is entirely inside the display area), use it.
if (
bounds.x >= area.x
&& bounds.y >= area.y
&& bounds.x + bounds.width <= area.x + area.width
&& bounds.y + bounds.height <= area.y + area.height
) {
options.x = bounds.x;
options.y = bounds.y;
}
// If the saved size is still valid, use it.
if (bounds.width <= area.width || bounds.height <= area.height) {
options.width = bounds.width;
options.height = bounds.height;
}
}
return options;
}
2016-10-30 11:57:12 +01:00
function createWindow() {
mainWindow = new BrowserWindow({
...getSizeOptions(),
2016-10-30 11:57:12 +01:00
darkTheme: true,
webPreferences: {
2021-04-01 16:29:15 +02:00
enableRemoteModule: true,
contextIsolation: false,
nodeIntegration: true,
2020-03-04 11:41:40 +01:00
// https://github.com/electron/electron/issues/5107
webSecurity: !isDev,
},
2016-10-30 11:57:12 +01:00
});
2020-03-04 11:41:40 +01:00
2022-11-22 16:23:41 +01:00
remote.enable(mainWindow.webContents);
2020-12-13 14:36:12 +01:00
if (isDev) mainWindow.loadURL('http://localhost:3001');
// Need to useloadFile for special characters https://github.com/mifi/lossless-cut/issues/40
else mainWindow.loadFile('build/index.html');
2016-10-30 11:57:12 +01:00
2020-02-24 11:18:44 +01:00
// Open the DevTools.
// mainWindow.webContents.openDevTools()
2020-03-04 11:41:40 +01:00
// Emitted when the window is closed.
2016-10-30 11:57:12 +01:00
mainWindow.on('closed', () => {
// Dereference the window object, usually you would store windows
// in an array if your app supports multi windows, this is the time
// when you should delete the corresponding element.
mainWindow = null;
});
2020-02-18 10:06:57 +01:00
// https://stackoverflow.com/questions/39574636/prompt-to-save-quit-before-closing-window/47434365
mainWindow.on('close', (e) => {
2020-02-20 05:03:25 +01:00
if (!askBeforeClose) return;
2020-02-18 10:06:57 +01:00
const choice = electron.dialog.showMessageBoxSync(mainWindow, {
type: 'question',
buttons: ['Yes', 'No'],
title: i18n.t('Confirm quit'),
message: i18n.t('Are you sure you want to quit?'),
2020-02-18 10:06:57 +01:00
});
if (choice === 1) {
e.preventDefault();
}
});
const debouncedSaveWindowState = debounce(() => {
if (!mainWindow) return;
const { x, y, width, height } = mainWindow.getNormalBounds();
configStore.set('windowBounds', { x, y, width, height });
}, 500);
mainWindow.on('resize', debouncedSaveWindowState);
mainWindow.on('move', debouncedSaveWindowState);
2016-10-30 11:57:12 +01:00
}
function updateMenu() {
menu(app, mainWindow, newVersion);
}
function openFilesEventually(paths) {
if (rendererReady) openFiles(paths);
else filesToOpen = paths;
}
// https://github.com/electron/electron/issues/3657
// https://github.com/mifi/lossless-cut/issues/357
// https://github.com/mifi/lossless-cut/issues/639
// https://github.com/mifi/lossless-cut/issues/591
function parseCliArgs(rawArgv = process.argv) {
const ignoreFirstArgs = isDev ? 2 : 1;
// production: First arg is the LosslessCut executable
// dev: First 2 args are electron and the electron.js
const argsWithoutAppName = rawArgv.length > ignoreFirstArgs ? rawArgv.slice(ignoreFirstArgs) : [];
return yargsParser(argsWithoutAppName);
}
const argv = parseCliArgs();
2021-04-08 17:52:15 +02:00
if (!argv.allowMultipleInstances && !app.requestSingleInstanceLock()) {
app.quit();
} else {
// On macOS, the system enforces single instance automatically when users try to open a second instance of your app in Finder, and the open-file and open-url events will be emitted for that.
// However when users start your app in command line, the system's single instance mechanism will be bypassed, and you have to use this method to ensure single instance.
// This can be tested with one terminal: npx electron .
// and another terminal: npx electron . path/to/file.mp4
app.on('second-instance', (event, commandLine) => {
// Someone tried to run a second instance, we should focus our window.
if (mainWindow) {
if (mainWindow.isMinimized()) mainWindow.restore();
mainWindow.focus();
}
2020-04-17 17:44:11 +02:00
const argv2 = parseCliArgs(commandLine);
if (argv2._) openFilesEventually(argv2._);
});
// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', async () => {
// https://github.com/electron/electron/issues/23757
// https://github.com/electron/electron/pull/28489
// TODO I think this can be removed when we are on electron 12 or 14
if (isDev) {
electron.protocol.registerFileProtocol('file', (request, callback) => {
const pathname = decodeURIComponent(request.url.replace('file:///', ''));
callback(pathname);
});
}
await configStore.init();
2021-04-01 16:29:15 +02:00
logger.info('CLI arguments', argv);
// Only if no files to open already (open-file might have already added some files)
if (filesToOpen.length === 0) filesToOpen = argv._;
const { settingsJson } = argv;
2021-04-01 16:29:15 +02:00
if (settingsJson != null) {
logger.info('initializing settings', settingsJson);
Object.entries(JSON5.parse(settingsJson)).forEach(([key, value]) => {
configStore.set(key, value);
});
}
2018-02-17 15:15:30 +01:00
if (isDev) {
const { default: installExtension, REACT_DEVELOPER_TOOLS } = require('electron-devtools-installer'); // eslint-disable-line global-require,import/no-extraneous-dependencies
2016-10-30 11:57:12 +01:00
installExtension(REACT_DEVELOPER_TOOLS)
.then(name => logger.info('Added Extension', name))
.catch(err => logger.error('Failed to add extension', err));
}
2016-10-30 11:57:12 +01:00
createWindow();
updateMenu();
if (!process.windowsStore && !process.mas) {
newVersion = await checkNewVersion();
// newVersion = '1.2.3';
if (newVersion) updateMenu();
}
});
2020-03-31 13:59:05 +02:00
// Quit when all windows are closed.
app.on('window-all-closed', () => {
app.quit();
});
2020-02-20 05:03:25 +01:00
app.on('activate', () => {
// On OS X it's common to re-create a window in the app when the
// dock icon is clicked and there are no other windows open.
if (mainWindow === null) {
createWindow();
}
});
2020-04-17 17:44:11 +02:00
ipcMain.on('renderer-ready', () => {
rendererReady = true;
if (filesToOpen.length > 0) openFiles(filesToOpen);
});
// Mac OS open with LosslessCut
// Emitted when the user wants to open a file with the application. The open-file event is usually emitted when the application is already open and the OS wants to reuse the application to open the file.
app.on('open-file', (event, path) => {
openFilesEventually([path]);
event.preventDefault(); // recommended in docs https://www.electronjs.org/docs/latest/api/app#event-open-file-macos
});
ipcMain.on('setAskBeforeClose', (e, val) => {
askBeforeClose = val;
});
ipcMain.on('setLanguage', (e, language) => {
i18n.changeLanguage(language).then(() => updateMenu()).catch((err) => logger.error('Failed to set language', err));
});
}
function focusWindow() {
try {
app.focus({ steal: true });
} catch (err) {
2022-09-04 16:44:48 +02:00
logger.error('Failed to focus window', err);
}
}
2022-11-23 03:52:32 +01:00
module.exports = { focusWindow, isDev };