TypeScript electron ipcRenderer.sendSync Examples

Example #1

File: homepage.component.ts Project: aracen74/tsng2

	do_ping() {
		if (this.has_ipc) {
			console.log(ipcRenderer.sendSync('synchronous-message', 'sync ping')); // prints "pong"
			ipcRenderer.send('asynchronous-message', 'async ping');
		} else {
			console.log("There isn't Electron main process.");
		}
	}

Example #2

File: github-electron-renderer-tests.ts Project: longlho/DefinitelyTyped

import {
	ipcRenderer,
	remote,
	webFrame,
	clipboard,
	crashReporter,
	nativeImage,
	screen,
	shell
} from 'electron';

import * as fs from 'fs';

// In renderer process (web page).
// https://github.com/atom/electron/blob/master/docs/api/ipc-renderer.md
console.log(ipcRenderer.sendSync('synchronous-message', 'ping')); // prints "pong"

ipcRenderer.on('asynchronous-reply', (event: Electron.IpcRendererEvent, arg: any) => {
	console.log(arg); // prints "pong"
	event.sender.send('another-message', 'Hello World!');
});

ipcRenderer.send('asynchronous-message', 'ping');

// remote
// https://github.com/atom/electron/blob/master/docs/api/remote.md

var BrowserWindow = remote.BrowserWindow;
var win = new BrowserWindow({ width: 800, height: 600 });
win.loadURL('https://github.com');

Example #3

File: process.ts Project: bangbang93/BMCLJS

import {Module} from 'vuex'
import {IRootState} from '../index'
import {IRunningGame} from '../../../main/service/game'
import {ipcRenderer} from 'electron'


export interface IProcessState {
  processes: IRunningGame[]
}

const store: Module<IProcessState, IRootState> = {
  namespaced: true,
  state: {
    processes: ipcRenderer.sendSync('game:running'),
  },
  mutations: {
    startGame(state, {name, json, id}) {
      state.processes.push({
        name, json, id, launcher: null,
      })
    },
    onGameStop(state, {id}) {
      const index = state.processes.findIndex((value) => {
        if (value.id === id) return true
      })
      if (index === -1) return
      state.processes.splice(index, 1)
    }
  },
}

Example #4

File: main-process-proxy.ts Project: Ahskys/desktop

export function sendWillQuitSync() {
  // eslint-disable-next-line no-sync
  ipcRenderer.sendSync('will-quit')
}

Example #5

File: main-process-proxy.ts Project: Aj-ajaam/desktop

export function sendWillQuitSync() {
  // tslint:disable-next-line:no-sync-functions
  ipcRenderer.sendSync('will-quit')
}

Example #6

File: electron_renderer.ts Project: micaelgallego/electron-node-java

export const bootstrapElectronRenderer = () => {
  electron.ipcRenderer.sendSync(ELECTRON_READY);
  platform([WORKER_RENDER_PLATFORM]).application([WORKER_RENDER_APPLICATION])
}

Example #7

File: export.component.ts Project: richardy2012/cafe-pitch

 ngOnInit() {
   this.slideServie.setText(ipcRenderer.sendSync('RequestPrintText'));
   this.pages = _.range(1, this.slideServie.getMaxPage() + 1);
 }

Example #8

File: index.ts Project: omenansiemen/pitboom-app

import { ipcRenderer } from "electron";

interface IElectron {
	electron: {
		ipc: Electron.IpcRenderer
		app: {
			version: string
			userDataPath: string
		}
	}
}

const w: any = window
const obj: IElectron = {
	electron: {
		ipc: ipcRenderer,
		app: {
			version: ipcRenderer.sendSync('pitboom', 'get-app-version'),
			userDataPath: ipcRenderer.sendSync('pitboom', 'get-app-user-data-path'),
		},
	}
}
w.electron = obj.electron

Example #9

File: preload.ts Project: ryan-nauman/spotify-mini

process.once('loaded', () => {
  let themeConfig = ipcRenderer.sendSync('get-theme-settings');
  let themeSettings: BowtiePlist = themeConfig && themeConfig.settings ? themeConfig.settings : {};
  let player = new Player(themeSettings);
  let bowtie = new Bowtie();
  global.iTunes = player;
  global.Player = player;
  global.Bowtie = bowtie;
  global.onload = () => {
    global.document.body.addEventListener('contextmenu', (e) => {
      e.preventDefault();
      menu.popup(remote.getCurrentWindow());
    });
    global.document.body.addEventListener('mousewheel', (e) => {
      e.preventDefault();
      handleScroll(e);
    });
  };
  ipcRenderer.on('error', (...args) => {
    handleError('Unknown', args);
  });
});