505 lines
16 KiB
JavaScript
505 lines
16 KiB
JavaScript
// desktop.js
|
|
// Electron script to run Hyperspace as an app
|
|
// © 2018 Hyperspace developers. Licensed under NPL v1.
|
|
|
|
const {
|
|
app,
|
|
Menu,
|
|
protocol,
|
|
BrowserWindow,
|
|
shell,
|
|
systemPreferences
|
|
} = require("electron");
|
|
const windowStateKeeper = require("electron-window-state");
|
|
const { autoUpdater } = require("electron-updater");
|
|
const path = require("path");
|
|
|
|
// Check for any updates to the app
|
|
autoUpdater.checkForUpdatesAndNotify();
|
|
|
|
// Create a container for the window
|
|
let mainWindow;
|
|
|
|
// Register the "hyperspace://" protocol so that it supports
|
|
// HTTPS and acts like a standard protocol instead of a fake
|
|
// file:// protocol, which is necessary for Mastodon to redirect
|
|
// to when authorizing Hyperspace.
|
|
protocol.registerSchemesAsPrivileged([
|
|
{ scheme: "hyperspace", privileges: { standard: true, secure: true } }
|
|
]);
|
|
|
|
/**
|
|
* Determine whether the desktop app is on macOS
|
|
* - Returns: Boolean of whether platform is Darwin
|
|
*/
|
|
function isDarwin() {
|
|
return process.platform === "darwin";
|
|
}
|
|
|
|
/**
|
|
* Register the protocol for Hyperspace
|
|
*/
|
|
function registerProtocol() {
|
|
protocol.registerFileProtocol(
|
|
"hyperspace",
|
|
(request, callback) => {
|
|
// Check to make sure we're doing a GET request
|
|
if (request.method !== "GET") {
|
|
callback({ error: -322 });
|
|
return null;
|
|
}
|
|
|
|
// Check to make sure we're actually working with a hyperspace
|
|
// protocol and that the host is 'hyperspace'
|
|
const parsedUrl = new URL(request.url);
|
|
if (parsedUrl.protocol !== "hyperspace:") {
|
|
callback({ error: -302 });
|
|
return;
|
|
}
|
|
|
|
if (parsedUrl.host !== "hyperspace") {
|
|
callback({ error: -105 });
|
|
return;
|
|
}
|
|
|
|
// Convert the parsed URL to a list of strings.
|
|
const target = parsedUrl.pathname.split("/");
|
|
|
|
// Check that the target isn't trying to go somewhere
|
|
// else. If it is, throw a "FILE_NOT_FOUND" error
|
|
if (target[0] !== "") {
|
|
callback({ error: -6 });
|
|
return;
|
|
}
|
|
|
|
// Check if the last target item in the list is empty.
|
|
// If so, replace it with "index.html" so that it can
|
|
// load a page.
|
|
if (target[target.length - 1] === "") {
|
|
target[target.length - 1] = "index.html";
|
|
}
|
|
|
|
// Check the middle target and redirect to the appropriate
|
|
// build files of the desktop app when running.
|
|
let baseDirectory;
|
|
if (target[1] === "app" || target[1] === "oauth") {
|
|
baseDirectory = __dirname + "/../build/";
|
|
} else {
|
|
// If it doesn't match above, throw a "FILE_NOT_FOUND" error.
|
|
callback({ error: -6 });
|
|
return;
|
|
}
|
|
|
|
// Create a normalized version of the string.
|
|
baseDirectory = path.normalize(baseDirectory);
|
|
|
|
// Check to make sure the target isn't trying to go out of bounds.
|
|
// If it is, throw a "FILE_NOT_FOUND" error.
|
|
const relTarget = path.normalize(path.join(...target.slice(2)));
|
|
if (relTarget.startsWith("..")) {
|
|
callback({ error: -6 });
|
|
return;
|
|
}
|
|
|
|
// Create the absolute target path and return it.
|
|
const absTarget = path.join(baseDirectory, relTarget);
|
|
callback({ path: absTarget });
|
|
},
|
|
error => {
|
|
if (error) console.error("Failed to register protocol");
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create the window and all of its properties
|
|
*/
|
|
function createWindow() {
|
|
// Create a window state manager that keeps track of the width
|
|
// and height of the main window.
|
|
let mainWindowState = windowStateKeeper({
|
|
defaultHeight: 624,
|
|
defaultWidth: 1024
|
|
});
|
|
|
|
// Create a browser window with some settings
|
|
mainWindow = new BrowserWindow({
|
|
// Use the values from the window state keeper
|
|
// to draw the window exactly as it was left.
|
|
// If not possible, derive it from the default
|
|
// values defined earlier.
|
|
x: mainWindowState.x,
|
|
y: mainWindowState.y,
|
|
width: mainWindowState.width,
|
|
height: mainWindowState.height,
|
|
|
|
// Set a minimum width to prevent element collisions.
|
|
minWidth: 300,
|
|
|
|
// Set important web preferences.
|
|
webPreferences: { nodeIntegration: true },
|
|
|
|
// Set some preferences that are specific to macOS.
|
|
titleBarStyle: "hiddenInset",
|
|
vibrancy: "sidebar",
|
|
transparent: isDarwin(),
|
|
backgroundColor: isDarwin() ? "#80000000" : "#FFF",
|
|
|
|
// Hide the window until the contents load
|
|
show: false
|
|
});
|
|
|
|
// Set up event listeners to track changes in the window state.
|
|
mainWindowState.manage(mainWindow);
|
|
|
|
// Load the main app and open the index page.
|
|
mainWindow.loadURL("hyperspace://hyperspace/app/");
|
|
|
|
// Watch for a change in macOS's dark mode and reload the window to apply changes, as well as accent color
|
|
if (isDarwin()) {
|
|
systemPreferences.subscribeNotification(
|
|
"AppleInterfaceThemeChangedNotification",
|
|
() => {
|
|
if (mainWindow != null) {
|
|
mainWindow.webContents.reload();
|
|
}
|
|
}
|
|
);
|
|
|
|
systemPreferences.subscribeNotification(
|
|
"AppleColorPreferencesChangedNotification",
|
|
() => {
|
|
if (mainWindow != null) {
|
|
mainWindow.webContents.reload();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
// Only show the window when ready
|
|
mainWindow.once("ready-to-show", () => {
|
|
mainWindow.show();
|
|
});
|
|
|
|
// Delete the window when closed
|
|
mainWindow.on("closed", () => {
|
|
mainWindow = null;
|
|
});
|
|
|
|
// Hijack any links with a blank target and open them in the default
|
|
// browser instead of a new Electron window
|
|
mainWindow.webContents.on("new-window", (event, url) => {
|
|
event.preventDefault();
|
|
shell.openExternal(url);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Go to a URL in the main window. If it doesn't exist,
|
|
* create the window and then navigate to it.
|
|
* @param url The URL to visit in the main window
|
|
*/
|
|
function safelyGoTo(url) {
|
|
if (mainWindow == null) {
|
|
registerProtocol();
|
|
createWindow();
|
|
}
|
|
mainWindow.loadURL(url);
|
|
}
|
|
|
|
/**
|
|
* Create the menu bar and attach it to a window
|
|
*/
|
|
function createMenubar() {
|
|
// Create an instance of the Menu class
|
|
let menu = Menu;
|
|
|
|
// Create a menu bar template
|
|
const menuBar = [
|
|
{
|
|
label: "File",
|
|
submenu: [
|
|
{
|
|
label: "New Window",
|
|
accelerator: "CmdOrCtrl+N",
|
|
click() {
|
|
if (mainWindow == null) {
|
|
registerProtocol();
|
|
createWindow();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
label: "New Post",
|
|
accelerator: "Shift+CmdOrCtrl+N",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#compose");
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: "Edit",
|
|
submenu: [
|
|
{ role: "undo" },
|
|
{ role: "redo" },
|
|
{ type: "separator" },
|
|
{ role: "cut" },
|
|
{ role: "copy" },
|
|
{ role: "paste" },
|
|
{ role: "pasteandmatchstyle" },
|
|
{ role: "delete" },
|
|
{ role: "selectall" }
|
|
]
|
|
},
|
|
{
|
|
label: "View",
|
|
submenu: [
|
|
{
|
|
label: "Back",
|
|
accelerator: "CmdOrCtrl+[",
|
|
click() {
|
|
if (
|
|
mainWindow != null &&
|
|
mainWindow.webContents.canGoBack()
|
|
) {
|
|
mainWindow.webContents.goBack();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
label: "Forward",
|
|
accelerator: "CmdOrCtrl+]",
|
|
click() {
|
|
if (
|
|
mainWindow != null &&
|
|
mainWindow.webContents.canGoForward()
|
|
) {
|
|
mainWindow.webContents.goForward();
|
|
}
|
|
}
|
|
},
|
|
{ role: "reload" },
|
|
{ role: "forcereload" },
|
|
{ type: "separator" },
|
|
{
|
|
label: "Open Dev Tools",
|
|
click() {
|
|
try {
|
|
mainWindow.webContents.openDevTools();
|
|
} catch (err) {
|
|
console.error("Couldn't open dev tools: " + err);
|
|
}
|
|
},
|
|
accelerator: "Shift+CmdOrCtrl+I"
|
|
},
|
|
{ type: "separator" },
|
|
{ role: "togglefullscreen" }
|
|
]
|
|
},
|
|
{
|
|
label: "Timelines",
|
|
submenu: [
|
|
{
|
|
label: "Home",
|
|
accelerator: "CmdOrCtrl+0",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/home");
|
|
}
|
|
},
|
|
{
|
|
label: "Local",
|
|
accelerator: "CmdOrCtrl+1",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/local");
|
|
}
|
|
},
|
|
{
|
|
label: "Public",
|
|
accelerator: "CmdOrCtrl+2",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/public");
|
|
}
|
|
},
|
|
{
|
|
label: "Messages",
|
|
accelerator: "CmdOrCtrl+3",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/messages");
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{
|
|
label: "Activity",
|
|
accelerator: "Alt+CmdOrCtrl+A",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/activity");
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
label: "Account",
|
|
submenu: [
|
|
{
|
|
label: "Notifications",
|
|
accelerator: "Alt+CmdOrCtrl+N",
|
|
click() {
|
|
safelyGoTo(
|
|
"hyperspace://hyperspace/app/#/notifications"
|
|
);
|
|
}
|
|
},
|
|
{
|
|
label: "Recommendations",
|
|
accelerator: "Alt+CmdOrCtrl+R",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/recommended");
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{
|
|
label: "Edit Profile",
|
|
accelerator: "Shift+CmdOrCtrl+P",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/you");
|
|
}
|
|
},
|
|
{
|
|
label: "Follow Requests",
|
|
accelerator: "Alt+CmdOrCtrl+E",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/requests");
|
|
}
|
|
},
|
|
{
|
|
label: "Blocked Servers",
|
|
accelerator: "Shift+CmdOrCtrl+B",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/blocked");
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{
|
|
label: "Switch Accounts...",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/welcome");
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
role: "window",
|
|
submenu: [
|
|
{ role: "minimize" },
|
|
{ role: "close" },
|
|
{ type: "separator" }
|
|
]
|
|
},
|
|
{
|
|
role: "help",
|
|
submenu: [
|
|
{
|
|
label: "Hyperspace Desktop Docs",
|
|
click() {
|
|
require("electron").shell.openExternal(
|
|
"https://hyperspace.marquiskurt.net/docs/"
|
|
);
|
|
}
|
|
},
|
|
{
|
|
label: "Report a Bug",
|
|
click() {
|
|
require("electron").shell.openExternal(
|
|
"https://github.com/hyperspacedev/hyperspace/issues"
|
|
);
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{
|
|
label: "Acknowledgements",
|
|
click() {
|
|
require("electron").shell.openExternal(
|
|
"https://github.com/hyperspacedev/hyperspace/blob/master/patreon.md"
|
|
);
|
|
}
|
|
}
|
|
]
|
|
}
|
|
];
|
|
|
|
if (process.platform === "darwin") {
|
|
menuBar.unshift({
|
|
label: app.getName(),
|
|
submenu: [
|
|
{
|
|
label: `About ${app.getName()}`,
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/about");
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{
|
|
label: "Preferences...",
|
|
accelerator: "Cmd+,",
|
|
click() {
|
|
safelyGoTo("hyperspace://hyperspace/app/#/settings");
|
|
}
|
|
},
|
|
{ type: "separator" },
|
|
{ role: "services" },
|
|
{ type: "separator" },
|
|
{ role: "hide" },
|
|
{ role: "hideothers" },
|
|
{ role: "unhide" },
|
|
{ type: "separator" },
|
|
{ role: "quit" }
|
|
]
|
|
});
|
|
|
|
// Edit menu
|
|
menuBar[2].submenu.push(
|
|
{ type: "separator" },
|
|
{
|
|
label: "Speech",
|
|
submenu: [{ role: "startspeaking" }, { role: "stopspeaking" }]
|
|
}
|
|
);
|
|
|
|
// Window menu
|
|
menuBar[6].submenu = [
|
|
{ role: "close" },
|
|
{ role: "minimize" },
|
|
{ role: "zoom" },
|
|
{ type: "separator" },
|
|
{ role: "front" }
|
|
];
|
|
}
|
|
|
|
// Create the template for the menu and attach it to the application
|
|
const thisMenu = menu.buildFromTemplate(menuBar);
|
|
menu.setApplicationMenu(thisMenu);
|
|
}
|
|
|
|
// When the app is ready, create the window and menu bar
|
|
app.on("ready", () => {
|
|
registerProtocol();
|
|
createWindow();
|
|
createMenubar();
|
|
});
|
|
|
|
// Standard quit behavior changes for macOS
|
|
app.on("window-all-closed", () => {
|
|
if (!isDarwin()) {
|
|
app.quit();
|
|
}
|
|
});
|
|
|
|
// When the app is activated, create the window and menu bar
|
|
app.on("activate", () => {
|
|
if (mainWindow === null) {
|
|
createWindow();
|
|
createMenubar();
|
|
}
|
|
});
|