TypeScript electron.remote類代碼示例

export function getGlobal(attributeName: string, defaultValue?: any): any {
    if (global[attributeName]) {
        return global[attributeName];
    } else if (Electron.remote && Electron.remote.getGlobal(attributeName)) {
        return Electron.remote.getGlobal(attributeName)
    } else {
        return defaultValue;
    }
}

 document.addEventListener('contextmenu', function (e :any) {
     switch (e.target.nodeName) {
         case 'TEXTAREA':
         case 'INPUT':
             e.preventDefault();
             textEditingMenu.popup(remote.getCurrentWindow());
             break;
         default:
             if (isAnyTextSelected()) {
                 e.preventDefault();
                 normalMenu.popup(remote.getCurrentWindow());
             }
     }
 }, false);

function _setup() {
	const electron = require('electron');
	const win = electron.remote.getCurrentWindow();

	function getButtonAndBindClick(btn: string, fn: EventListener) {
		const elem = document.getElementById(`btn-${btn}`);
		elem.addEventListener('click', fn);
		return elem;
	}

	const btnMinimize = getButtonAndBindClick('minimize', () => win.minimize());
	const btnMaximize = getButtonAndBindClick('maximize', () => win.maximize());
	const btnRestore  = getButtonAndBindClick('restore' , () => win.restore());
	const btnClose    = getButtonAndBindClick('close'   , () => win.close());

	function updateButtons() {
		const isMax = win.isMaximized();
		btnMaximize.hidden = isMax;
		btnRestore.hidden = !isMax;
	}

	win.on('unmaximize', updateButtons);
	win.on('maximize', updateButtons);
	updateButtons();

	Keyboard.keydownOnce(['esc', 'alt'], (e: typeof KeyEvent) => {
		document.body.classList.toggle('paused');
	});
}

function showContextMenu(e) {
	e.preventDefault();

	const pid = parseInt(e.currentTarget.id);
	if (pid && typeof pid === 'number') {
		const menu = new remote.Menu();
		menu.append(new remote.MenuItem({
			label: localize('killProcess', "Kill Process"),
			click() {
				process.kill(pid, 'SIGTERM');
			}
		})
		);

		menu.append(new remote.MenuItem({
			label: localize('forceKillProcess', "Force Kill Process"),
			click() {
				process.kill(pid, 'SIGKILL');
			}
		})
		);

		menu.popup(remote.getCurrentWindow());
	}
}

    getCookie: async(name: string) => {
        const value = {
            name
        };
        const cookies = remote.getCurrentWindow().webContents.session.cookies;

        if (!name) {
            return new Promise((resolve, reject) => {
                cookies.get({ url: axios.defaults.baseURL }, (error, cookies) => {
                    let string = '';

                    if (error) {
                        return resolve('');
                    }

                    for (let i = cookies.length; --i >= 0;) {
                        const item = cookies[i];
                        string += `${item.name}=${item.value} ;`;
                    }

                    resolve(string);
                });
            });
        }

        return new Promise((resolve, reject) => {
            cookies.get(value, (err, cookies) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(cookies[0].value);
                }
            });
        });
    },

(function init() {
  const { getPersistentAsJson } = Electron.remote.require("./remote");
  const json = JSON.parse(getPersistentAsJson());
  const config = json.config as Config;
  store.mutations.resetConfig(config);

  try {
    const recentList = JSON.parse(localStorage.getItem("recentList") || "[]");
    if (
      recentList instanceof Array &&
      recentList.every(v => typeof v === "string")
    ) {
      store.mutations.resetRecentList(recentList);
    } else {
      console.warn("Failed to load recentList from localStorage");
    }
  } catch {
    console.warn("Failed to load recentList from localStorage");
  }

  Electron.ipcRenderer.on(
    "action",
    (_event: string, name: string, payload: any) => {
      (store.actions as any)[name](payload);
    }
  );
})();

	async move(selector: string): TPromise<void> {
		const { x, y } = await this._getElementXY(selector);
		const webContents = electron.remote.getCurrentWebContents();
		webContents.sendInputEvent({ type: 'mouseMove', x, y } as any);

		await TPromise.timeout(100);
	}

    ready: function() {
        this.button = document.querySelector('.builtin-search-button') as HTMLButtonElement;
        this.button.addEventListener('click', () => {
            this.search(this.input.value);
        });

        this.body = document.querySelector('.builtin-search-body') as HTMLDivElement;
        this.body.classList.add('animated');
        if (this.displayed) {
            this.body.style.display = 'block';
        }

        this.matches = document.querySelector('.builtin-search-matches') as HTMLDivElement;

        remote.getCurrentWebContents().on('found-in-page', (event: Event, result: FoundInPage) => {
            if (this.requestId !== result.requestId) {
                return;
            }
            if (result.activeMatchOrdinal) {
                this.activeIdx = result.activeMatchOrdinal;
            }
            if (result.finalUpdate && result.matches) {
                this.setResult(this.activeIdx, result.matches);
            }
        });

        this.up_button = document.querySelector('.builtin-search-up') as HTMLButtonElement;
        this.up_button.addEventListener('click', () => this.searchNext(this.query, false));
        this.down_button = document.querySelector('.builtin-search-down') as HTMLButtonElement;
        this.down_button.addEventListener('click', () => this.searchNext(this.query, true));
        this.close_button = document.querySelector('.builtin-search-close') as HTMLButtonElement;
        this.close_button.addEventListener('click', () => this.dismiss());
    },

export function showCommitContextMenu(store: AppStore, commit: Commit) {
  const template = getCommitMenuTemplate(store, commit);
  if (template.length === 0) {
    return;
  }
  const menu = Menu.buildFromTemplate(template);
  menu.popup({ window: remote.getCurrentWindow() });
}

 document.getElementById("max-btn").addEventListener("click", function (e) {
   var window: Electron.BrowserWindow = remote.getCurrentWindow();
   
   if(window.isMaximized())
     window.unmaximize();
   else
     window.maximize();        
 });