gars_v2/app/background.js

Geo Assistant Research System

(function () {'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var path = _interopDefault(require('path'));
var url = _interopDefault(require('url'));
var electron = require('electron');
var jetpack = _interopDefault(require('fs-jetpack'));

var devMenuTemplate = {
    label: 'Development',
    submenu: [{
        label: 'Reload',
        accelerator: 'CmdOrCtrl+R',
        click: function () {
            electron.BrowserWindow.getFocusedWindow().webContents.reloadIgnoringCache();
        }
    },{
        label: 'Toggle DevTools',
        accelerator: 'Alt+CmdOrCtrl+I',
        click: function () {
            electron.BrowserWindow.getFocusedWindow().toggleDevTools();
        }
    },{
        label: 'Quit',
        accelerator: 'CmdOrCtrl+Q',
        click: function () {
            electron.app.quit();
        }
    }]
};

var fileMenuTemplate = {
    label: 'File',
    submenu: [{
        label: "Browse..",
        accelerator: "CmdOrCtrl+O",
        click: function() {
            var filepath = electron.dialog.showOpenDialog({
                properties: ['openDirectory']
            });
            if (!filepath) return;
            var focusedWindow = electron.BrowserWindow.getFocusedWindow();
            focusedWindow.webContents.send('navigate', filepath[0]);
        }
    }, {
        type: "separator"
    }, {
        label: 'Quit',
        accelerator: 'CmdOrCtrl+Q',
        click: function() {
            electron.app.quit();
        }
    }]
};

var editMenuTemplate = {
    label: 'Edit',
    submenu: [
        { label: "Undo", accelerator: "CmdOrCtrl+Z", selector: "undo:" },
        { label: "Redo", accelerator: "Shift+CmdOrCtrl+Z", selector: "redo:" },
        { type: "separator" },
        { label: "Cut", accelerator: "CmdOrCtrl+X", selector: "cut:" },
        { label: "Copy", accelerator: "CmdOrCtrl+C", selector: "copy:" },
        { label: "Paste", accelerator: "CmdOrCtrl+V", selector: "paste:" },
        { label: "Select All", accelerator: "CmdOrCtrl+A", selector: "selectAll:" }
    ]
};

// Simple wrapper exposing environment variables to rest of the code.

// The variables have been written to `env.json` by the build process.
var env = jetpack.cwd(__dirname).read('env.json', 'json');

// This helper remembers the size and position of your windows (and restores
// them in that place after app relaunch).
// Can be used for more than one window, just construct many
// instances of it and give each different name.

var createWindow = function(name, options) {

    var userDataDir = jetpack.cwd(electron.app.getPath('userData'));
    var stateStoreFile = 'window-state-' + name + '.json';
    var defaultSize = {
        width: options.width,
        height: options.height
    };
    var state = {};
    var win;

    var restore = function() {
        var restoredState = {};
        try {
            restoredState = userDataDir.read(stateStoreFile, 'json');
        } catch (err) {
            // For some reason json can't be read (might be corrupted).
            // No worries, we have defaults.
        }
        return Object.assign({}, defaultSize, restoredState);
    };

    var getCurrentPosition = function() {
        var position = win.getPosition();
        var size = win.getSize();
        return {
            x: position[0],
            y: position[1],
            width: size[0],
            height: size[1]
        };
    };

    var windowWithinBounds = function(windowState, bounds) {
        return windowState.x >= bounds.x &&
            windowState.y >= bounds.y &&
            windowState.x + windowState.width <= bounds.x + bounds.width &&
            windowState.y + windowState.height <= bounds.y + bounds.height;
    };

    var resetToDefaults = function(windowState) {
        var bounds = electron.screen.getPrimaryDisplay().bounds;
        return Object.assign({}, defaultSize, {
            x: (bounds.width - defaultSize.width) / 2,
            y: (bounds.height - defaultSize.height) / 2
        });
    };

    var ensureVisibleOnSomeDisplay = function(windowState) {
        var visible = electron.screen.getAllDisplays().some(function(display) {
            return windowWithinBounds(windowState, display.bounds);
        });
        if (!visible) {
            // Window is partially or fully not visible now.
            // Reset it to safe defaults.
            return resetToDefaults(windowState);
        }
        return windowState;
    };

    var saveState = function() {
        if (!win.isMinimized() && !win.isMaximized()) {
            Object.assign(state, getCurrentPosition());
        }
        userDataDir.write(stateStoreFile, state, { atomic: true });
    };

    state = ensureVisibleOnSomeDisplay(restore());

    win = new electron.BrowserWindow(Object.assign({ show: false }, options, state));

    win.loadURL(url.format({
        pathname: options.pathname,
        protocol: 'file:',
        slashes: true
    }));

    if (env.name === 'development') {
        win.openDevTools();
    }

    win.once('ready-to-show', () => {
        win.show();
    });

    win.on('close', saveState);

    return win;
};

var userDataDir = jetpack.cwd(electron.app.getPath('userData'));
var stateStoreFile = 'state.json';
var state = {
    path: electron.app.getPath('home')
};

function restore() {
    try {
        var content = userDataDir.read(stateStoreFile, 'json');
        Object.assign(state, content);
    } catch (err) {}
    console.log('state restored:', state);
    return state;
}

function get(key) {
    return arguments.length ? state[key] : state;
}

function set(key, val) {
    state[key] = val;
}

function save() {
    userDataDir.write(stateStoreFile, state, { atomic: true });
    console.log('state saved', state);
}

var state$1 = {
    restore,
    get,
    save,
    set
};

// This is main process of Electron, started as first thing when your
// app starts. This script is running through entire life of your application.
// It doesn't have any windows which you can see on screen, but we can open
// window from here.

// Special module holding environment variables which you declared
// in config/env_xxx.json file.
var setApplicationMenu = function() {
    var menus = [fileMenuTemplate, editMenuTemplate];
    //if (env.name !== 'production') {
    menus.push(devMenuTemplate);
    //}
    electron.Menu.setApplicationMenu(electron.Menu.buildFromTemplate(menus));
};

// Save userData in separate folders for each environment.
// Thanks to this you can use production and development versions of the app
// on same machine like those are two separate apps.
if (env.name !== 'production') {
    var userDataPath = electron.app.getPath('userData');
    electron.app.setPath('userData', userDataPath + ' (' + env.name + ')');
}

electron.app.on('ready', function() {
    setApplicationMenu();

    state$1.restore();
    global.state = state$1;

    var mainWindow = createWindow('main', {
        width: 1000,
        height: 600,
        pathname: path.join(__dirname, 'main.html')
    });

    electron.ipcMain.on('preview', (event, filepath) => {
        console.log('preview request received', filepath);

        var mapWindow = createWindow('map', {
            fullscreen: true,
            pathname: path.join(__dirname, 'map.html')
        });

        mapWindow.webContents.on('did-finish-load', function() {
            mapWindow.webContents.send('open', filepath);
        });
    });
});

electron.app.on('window-all-closed', function() {
    state$1.save();
    electron.app.quit();
});

}());
//# sourceMappingURL=background.js.map