SQL Operations Studio Public Preview 1 (0.23) release source code

src/vs/platform/windows/common/windows.ts

@@ -0,0 +1,233 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import Event from 'vs/base/common/event';
+import { ITelemetryData } from 'vs/platform/telemetry/common/telemetry';
+import { IProcessEnvironment } from 'vs/base/common/platform';
+import { ParsedArgs } from 'vs/platform/environment/common/environment';
+import { IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
+import { IRecentlyOpened } from 'vs/platform/history/common/history';
+
+export const IWindowsService = createDecorator<IWindowsService>('windowsService');
+
+export interface INativeOpenDialogOptions {
+	windowId?: number;
+	forceNewWindow?: boolean;
+
+	dialogOptions?: Electron.OpenDialogOptions;
+
+	telemetryEventName?: string;
+	telemetryExtraData?: ITelemetryData;
+}
+
+export interface IWindowsService {
+
+	_serviceBrand: any;
+
+	onWindowOpen: Event<number>;
+	onWindowFocus: Event<number>;
+	onWindowBlur: Event<number>;
+
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	reloadWindow(windowId: number): TPromise<void>;
+	openDevTools(windowId: number): TPromise<void>;
+	toggleDevTools(windowId: number): TPromise<void>;
+	closeWorkspace(windowId: number): TPromise<void>;
+	openWorkspace(windowId: number): TPromise<void>;
+	createAndOpenWorkspace(windowId: number, folders?: string[], path?: string): TPromise<void>;
+	saveAndOpenWorkspace(windowId: number, path: string): TPromise<void>;
+	toggleFullScreen(windowId: number): TPromise<void>;
+	setRepresentedFilename(windowId: number, fileName: string): TPromise<void>;
+	addRecentlyOpened(files: string[]): TPromise<void>;
+	removeFromRecentlyOpened(paths: string[]): TPromise<void>;
+	clearRecentlyOpened(): TPromise<void>;
+	getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened>;
+	focusWindow(windowId: number): TPromise<void>;
+	closeWindow(windowId: number): TPromise<void>;
+	isFocused(windowId: number): TPromise<boolean>;
+	isMaximized(windowId: number): TPromise<boolean>;
+	maximizeWindow(windowId: number): TPromise<void>;
+	unmaximizeWindow(windowId: number): TPromise<void>;
+	onWindowTitleDoubleClick(windowId: number): TPromise<void>;
+	setDocumentEdited(windowId: number, flag: boolean): TPromise<void>;
+	quit(): TPromise<void>;
+	relaunch(options: { addArgs?: string[], removeArgs?: string[] }): TPromise<void>;
+
+	// Shared process
+	whenSharedProcessReady(): TPromise<void>;
+	toggleSharedProcess(): TPromise<void>;
+
+	// Global methods
+	openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean; }): TPromise<void>;
+	openNewWindow(): TPromise<void>;
+	showWindow(windowId: number): TPromise<void>;
+	getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]>;
+	getWindowCount(): TPromise<number>;
+	log(severity: string, ...messages: string[]): TPromise<void>;
+	showItemInFolder(path: string): TPromise<void>;
+
+	// This needs to be handled from browser process to prevent
+	// foreground ordering issues on Windows
+	openExternal(url: string): TPromise<boolean>;
+
+	// TODO: this is a bit backwards
+	startCrashReporter(config: Electron.CrashReporterStartOptions): TPromise<void>;
+}
+
+export const IWindowService = createDecorator<IWindowService>('windowService');
+
+export interface IWindowService {
+
+	_serviceBrand: any;
+
+	onDidChangeFocus: Event<boolean>;
+
+	getCurrentWindowId(): number;
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void>;
+	reloadWindow(): TPromise<void>;
+	openDevTools(): TPromise<void>;
+	toggleDevTools(): TPromise<void>;
+	closeWorkspace(): TPromise<void>;
+	openWorkspace(): TPromise<void>;
+	createAndOpenWorkspace(folders?: string[], path?: string): TPromise<void>;
+	saveAndOpenWorkspace(path: string): TPromise<void>;
+	toggleFullScreen(): TPromise<void>;
+	setRepresentedFilename(fileName: string): TPromise<void>;
+	getRecentlyOpened(): TPromise<IRecentlyOpened>;
+	focusWindow(): TPromise<void>;
+	closeWindow(): TPromise<void>;
+	isFocused(): TPromise<boolean>;
+	setDocumentEdited(flag: boolean): TPromise<void>;
+	isMaximized(): TPromise<boolean>;
+	maximizeWindow(): TPromise<void>;
+	unmaximizeWindow(): TPromise<void>;
+	onWindowTitleDoubleClick(): TPromise<void>;
+	show(): TPromise<void>;
+	showMessageBox(options: Electron.ShowMessageBoxOptions): number;
+	showSaveDialog(options: Electron.SaveDialogOptions, callback?: (fileName: string) => void): string;
+	showOpenDialog(options: Electron.OpenDialogOptions, callback?: (fileNames: string[]) => void): string[];
+}
+
+export type MenuBarVisibility = 'default' | 'visible' | 'toggle' | 'hidden';
+
+export interface IWindowsConfiguration {
+	window: IWindowSettings;
+}
+
+export interface IWindowSettings {
+	openFilesInNewWindow: 'on' | 'off' | 'default';
+	openFoldersInNewWindow: 'on' | 'off' | 'default';
+	restoreWindows: 'all' | 'folders' | 'one' | 'none';
+	reopenFolders: 'all' | 'one' | 'none'; // TODO@Ben deprecated
+	restoreFullscreen: boolean;
+	zoomLevel: number;
+	titleBarStyle: 'native' | 'custom';
+	autoDetectHighContrast: boolean;
+	menuBarVisibility: MenuBarVisibility;
+	newWindowDimensions: 'default' | 'inherit' | 'maximized' | 'fullscreen';
+	nativeTabs: boolean;
+	enableMenuBarMnemonics: boolean;
+	closeWhenEmpty: boolean;
+}
+
+export enum OpenContext {
+
+	// opening when running from the command line
+	CLI,
+
+	// macOS only: opening from the dock (also when opening files to a running instance from desktop)
+	DOCK,
+
+	// opening from the main application window
+	MENU,
+
+	// opening from a file or folder dialog
+	DIALOG,
+
+	// opening from the OS's UI
+	DESKTOP,
+
+	// opening through the API
+	API
+}
+
+export enum ReadyState {
+
+	/**
+	 * This window has not loaded any HTML yet
+	 */
+	NONE,
+
+	/**
+	 * This window is loading HTML
+	 */
+	LOADING,
+
+	/**
+	 * This window is navigating to another HTML
+	 */
+	NAVIGATING,
+
+	/**
+	 * This window is done loading HTML
+	 */
+	READY
+}
+
+export interface IPath {
+
+	// the file path to open within a Code instance
+	filePath?: string;
+
+	// the line number in the file path to open
+	lineNumber?: number;
+
+	// the column number in the file path to open
+	columnNumber?: number;
+}
+
+export interface IOpenFileRequest {
+	filesToOpen?: IPath[];
+	filesToCreate?: IPath[];
+	filesToDiff?: IPath[];
+}
+
+export interface IAddFoldersRequest {
+	foldersToAdd: IPath[];
+}
+
+export interface IWindowConfiguration extends ParsedArgs, IOpenFileRequest {
+	appRoot: string;
+	execPath: string;
+	isInitialStartup?: boolean;
+
+	userEnv: IProcessEnvironment;
+	nodeCachedDataDir: string;
+
+	backupPath?: string;
+
+	workspace?: IWorkspaceIdentifier;
+	folderPath?: string;
+
+	isISOKeyboard?: boolean;
+	zoomLevel?: number;
+	fullscreen?: boolean;
+	highContrast?: boolean;
+	baseTheme?: string;
+	backgroundColor?: string;
+	accessibilitySupport?: boolean;
+
+	perfStartTime?: number;
+	perfAppReady?: number;
+	perfWindowLoadTime?: number;
+}

src/vs/platform/windows/common/windowsIpc.ts

@@ -0,0 +1,279 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import Event, { buffer } from 'vs/base/common/event';
+import { IChannel, eventToCall, eventFromCall } from 'vs/base/parts/ipc/common/ipc';
+import { IWindowsService, INativeOpenDialogOptions } from './windows';
+import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
+import { IRecentlyOpened } from 'vs/platform/history/common/history';
+
+export interface IWindowsChannel extends IChannel {
+	call(command: 'event:onWindowOpen'): TPromise<number>;
+	call(command: 'event:onWindowFocus'): TPromise<number>;
+	call(command: 'event:onWindowBlur'): TPromise<number>;
+	call(command: 'pickFileFolderAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
+	call(command: 'pickFileAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
+	call(command: 'pickFolderAndOpen', arg: INativeOpenDialogOptions): TPromise<void>;
+	call(command: 'reloadWindow', arg: number): TPromise<void>;
+	call(command: 'toggleDevTools', arg: number): TPromise<void>;
+	call(command: 'closeWorkspace', arg: number): TPromise<void>;
+	call(command: 'openWorkspace', arg: number): TPromise<void>;
+	call(command: 'createAndOpenWorkspace', arg: [number, string[], string]): TPromise<void>;
+	call(command: 'saveAndOpenWorkspace', arg: [number, string]): TPromise<void>;
+	call(command: 'toggleFullScreen', arg: number): TPromise<void>;
+	call(command: 'setRepresentedFilename', arg: [number, string]): TPromise<void>;
+	call(command: 'addRecentlyOpened', arg: string[]): TPromise<void>;
+	call(command: 'removeFromRecentlyOpened', arg: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier)[]): TPromise<void>;
+	call(command: 'clearRecentlyOpened'): TPromise<void>;
+	call(command: 'getRecentlyOpened', arg: number): TPromise<IRecentlyOpened>;
+	call(command: 'focusWindow', arg: number): TPromise<void>;
+	call(command: 'closeWindow', arg: number): TPromise<void>;
+	call(command: 'isFocused', arg: number): TPromise<boolean>;
+	call(command: 'isMaximized', arg: number): TPromise<boolean>;
+	call(command: 'maximizeWindow', arg: number): TPromise<void>;
+	call(command: 'unmaximizeWindow', arg: number): TPromise<void>;
+	call(command: 'onWindowTitleDoubleClick', arg: number): TPromise<void>;
+	call(command: 'setDocumentEdited', arg: [number, boolean]): TPromise<void>;
+	call(command: 'quit'): TPromise<void>;
+	call(command: 'openWindow', arg: [string[], { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }]): TPromise<void>;
+	call(command: 'openNewWindow'): TPromise<void>;
+	call(command: 'showWindow', arg: number): TPromise<void>;
+	call(command: 'getWindows'): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]>;
+	call(command: 'getWindowCount'): TPromise<number>;
+	call(command: 'relaunch', arg: { addArgs?: string[], removeArgs?: string[] }): TPromise<number>;
+	call(command: 'whenSharedProcessReady'): TPromise<void>;
+	call(command: 'toggleSharedProcess'): TPromise<void>;
+	call(command: 'log', arg: [string, string[]]): TPromise<void>;
+	call(command: 'showItemInFolder', arg: string): TPromise<void>;
+	call(command: 'openExternal', arg: string): TPromise<boolean>;
+	call(command: 'startCrashReporter', arg: Electron.CrashReporterStartOptions): TPromise<void>;
+	call(command: string, arg?: any): TPromise<any>;
+}
+
+export class WindowsChannel implements IWindowsChannel {
+
+	private onWindowOpen: Event<number>;
+	private onWindowFocus: Event<number>;
+	private onWindowBlur: Event<number>;
+
+	constructor(private service: IWindowsService) {
+		this.onWindowOpen = buffer(service.onWindowOpen, true);
+		this.onWindowFocus = buffer(service.onWindowFocus, true);
+		this.onWindowBlur = buffer(service.onWindowBlur, true);
+	}
+
+	call(command: string, arg?: any): TPromise<any> {
+		switch (command) {
+			case 'event:onWindowOpen': return eventToCall(this.onWindowOpen);
+			case 'event:onWindowFocus': return eventToCall(this.onWindowFocus);
+			case 'event:onWindowBlur': return eventToCall(this.onWindowBlur);
+			case 'pickFileFolderAndOpen': return this.service.pickFileFolderAndOpen(arg);
+			case 'pickFileAndOpen': return this.service.pickFileAndOpen(arg);
+			case 'pickFolderAndOpen': return this.service.pickFolderAndOpen(arg);
+			case 'reloadWindow': return this.service.reloadWindow(arg);
+			case 'openDevTools': return this.service.openDevTools(arg);
+			case 'toggleDevTools': return this.service.toggleDevTools(arg);
+			case 'closeWorkspace': return this.service.closeWorkspace(arg);
+			case 'openWorkspace': return this.service.openWorkspace(arg);
+			case 'createAndOpenWorkspace': return this.service.createAndOpenWorkspace(arg[0], arg[1], arg[2]);
+			case 'saveAndOpenWorkspace': return this.service.saveAndOpenWorkspace(arg[0], arg[1]);
+			case 'toggleFullScreen': return this.service.toggleFullScreen(arg);
+			case 'setRepresentedFilename': return this.service.setRepresentedFilename(arg[0], arg[1]);
+			case 'addRecentlyOpened': return this.service.addRecentlyOpened(arg);
+			case 'removeFromRecentlyOpened': return this.service.removeFromRecentlyOpened(arg);
+			case 'clearRecentlyOpened': return this.service.clearRecentlyOpened();
+			case 'getRecentlyOpened': return this.service.getRecentlyOpened(arg);
+			case 'focusWindow': return this.service.focusWindow(arg);
+			case 'closeWindow': return this.service.closeWindow(arg);
+			case 'isFocused': return this.service.isFocused(arg);
+			case 'isMaximized': return this.service.isMaximized(arg);
+			case 'maximizeWindow': return this.service.maximizeWindow(arg);
+			case 'unmaximizeWindow': return this.service.unmaximizeWindow(arg);
+			case 'onWindowTitleDoubleClick': return this.service.onWindowTitleDoubleClick(arg);
+			case 'setDocumentEdited': return this.service.setDocumentEdited(arg[0], arg[1]);
+			case 'openWindow': return this.service.openWindow(arg[0], arg[1]);
+			case 'openNewWindow': return this.service.openNewWindow();
+			case 'showWindow': return this.service.showWindow(arg);
+			case 'getWindows': return this.service.getWindows();
+			case 'getWindowCount': return this.service.getWindowCount();
+			case 'relaunch': return this.service.relaunch(arg[0]);
+			case 'whenSharedProcessReady': return this.service.whenSharedProcessReady();
+			case 'toggleSharedProcess': return this.service.toggleSharedProcess();
+			case 'quit': return this.service.quit();
+			case 'log': return this.service.log(arg[0], arg[1]);
+			case 'showItemInFolder': return this.service.showItemInFolder(arg);
+			case 'openExternal': return this.service.openExternal(arg);
+			case 'startCrashReporter': return this.service.startCrashReporter(arg);
+		}
+		return undefined;
+	}
+}
+
+export class WindowsChannelClient implements IWindowsService {
+
+	_serviceBrand: any;
+
+	constructor(private channel: IWindowsChannel) { }
+
+	private _onWindowOpen: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowOpen');
+	get onWindowOpen(): Event<number> { return this._onWindowOpen; }
+
+	private _onWindowFocus: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowFocus');
+	get onWindowFocus(): Event<number> { return this._onWindowFocus; }
+
+	private _onWindowBlur: Event<number> = eventFromCall<number>(this.channel, 'event:onWindowBlur');
+	get onWindowBlur(): Event<number> { return this._onWindowBlur; }
+
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		return this.channel.call('pickFileFolderAndOpen', options);
+	}
+
+	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		return this.channel.call('pickFileAndOpen', options);
+	}
+
+	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		return this.channel.call('pickFolderAndOpen', options);
+	}
+
+	reloadWindow(windowId: number): TPromise<void> {
+		return this.channel.call('reloadWindow', windowId);
+	}
+
+	openDevTools(windowId: number): TPromise<void> {
+		return this.channel.call('openDevTools', windowId);
+	}
+
+	toggleDevTools(windowId: number): TPromise<void> {
+		return this.channel.call('toggleDevTools', windowId);
+	}
+
+	closeWorkspace(windowId: number): TPromise<void> {
+		return this.channel.call('closeWorkspace', windowId);
+	}
+
+	openWorkspace(windowId: number): TPromise<void> {
+		return this.channel.call('openWorkspace', windowId);
+	}
+
+	createAndOpenWorkspace(windowId: number, folders?: string[], path?: string): TPromise<void> {
+		return this.channel.call('createAndOpenWorkspace', [windowId, folders, path]);
+	}
+
+	saveAndOpenWorkspace(windowId: number, path: string): TPromise<void> {
+		return this.channel.call('saveAndOpenWorkspace', [windowId, path]);
+	}
+
+	toggleFullScreen(windowId: number): TPromise<void> {
+		return this.channel.call('toggleFullScreen', windowId);
+	}
+
+	setRepresentedFilename(windowId: number, fileName: string): TPromise<void> {
+		return this.channel.call('setRepresentedFilename', [windowId, fileName]);
+	}
+
+	addRecentlyOpened(files: string[]): TPromise<void> {
+		return this.channel.call('addRecentlyOpened', files);
+	}
+
+	removeFromRecentlyOpened(paths: string[]): TPromise<void> {
+		return this.channel.call('removeFromRecentlyOpened', paths);
+	}
+
+	clearRecentlyOpened(): TPromise<void> {
+		return this.channel.call('clearRecentlyOpened');
+	}
+
+	getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened> {
+		return this.channel.call('getRecentlyOpened', windowId);
+	}
+
+	focusWindow(windowId: number): TPromise<void> {
+		return this.channel.call('focusWindow', windowId);
+	}
+
+	closeWindow(windowId: number): TPromise<void> {
+		return this.channel.call('closeWindow', windowId);
+	}
+
+	isFocused(windowId: number): TPromise<boolean> {
+		return this.channel.call('isFocused', windowId);
+	}
+
+	isMaximized(windowId: number): TPromise<boolean> {
+		return this.channel.call('isMaximized', windowId);
+	}
+
+	maximizeWindow(windowId: number): TPromise<void> {
+		return this.channel.call('maximizeWindow', windowId);
+	}
+
+	unmaximizeWindow(windowId: number): TPromise<void> {
+		return this.channel.call('unmaximizeWindow', windowId);
+	}
+
+	onWindowTitleDoubleClick(windowId: number): TPromise<void> {
+		return this.channel.call('onWindowTitleDoubleClick', windowId);
+	}
+
+	setDocumentEdited(windowId: number, flag: boolean): TPromise<void> {
+		return this.channel.call('setDocumentEdited', [windowId, flag]);
+	}
+
+	quit(): TPromise<void> {
+		return this.channel.call('quit');
+	}
+
+	relaunch(options: { addArgs?: string[], removeArgs?: string[] }): TPromise<void> {
+		return this.channel.call('relaunch', [options]);
+	}
+
+	whenSharedProcessReady(): TPromise<void> {
+		return this.channel.call('whenSharedProcessReady');
+	}
+
+	toggleSharedProcess(): TPromise<void> {
+		return this.channel.call('toggleSharedProcess');
+	}
+
+	openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }): TPromise<void> {
+		return this.channel.call('openWindow', [paths, options]);
+	}
+
+	openNewWindow(): TPromise<void> {
+		return this.channel.call('openNewWindow');
+	}
+
+	showWindow(windowId: number): TPromise<void> {
+		return this.channel.call('showWindow', windowId);
+	}
+
+	getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]> {
+		return this.channel.call('getWindows');
+	}
+
+	getWindowCount(): TPromise<number> {
+		return this.channel.call('getWindowCount');
+	}
+
+	log(severity: string, ...messages: string[]): TPromise<void> {
+		return this.channel.call('log', [severity, messages]);
+	}
+
+	showItemInFolder(path: string): TPromise<void> {
+		return this.channel.call('showItemInFolder', path);
+	}
+
+	openExternal(url: string): TPromise<boolean> {
+		return this.channel.call('openExternal', url);
+	}
+
+	startCrashReporter(config: Electron.CrashReporterStartOptions): TPromise<void> {
+		return this.channel.call('startCrashReporter', config);
+	}
+}

src/vs/platform/windows/electron-browser/windowService.ts

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import Event, { filterEvent, mapEvent, any } from 'vs/base/common/event';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IWindowService, IWindowsService, INativeOpenDialogOptions } from 'vs/platform/windows/common/windows';
+import { remote } from 'electron';
+import { IRecentlyOpened } from 'vs/platform/history/common/history';
+
+export class WindowService implements IWindowService {
+
+	readonly onDidChangeFocus: Event<boolean>;
+
+	_serviceBrand: any;
+
+	constructor(
+		private windowId: number,
+		@IWindowsService private windowsService: IWindowsService
+	) {
+		const onThisWindowFocus = mapEvent(filterEvent(windowsService.onWindowFocus, id => id === windowId), _ => true);
+		const onThisWindowBlur = mapEvent(filterEvent(windowsService.onWindowBlur, id => id === windowId), _ => false);
+		this.onDidChangeFocus = any(onThisWindowFocus, onThisWindowBlur);
+	}
+
+	getCurrentWindowId(): number {
+		return this.windowId;
+	}
+
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		options.windowId = this.windowId;
+
+		return this.windowsService.pickFileFolderAndOpen(options);
+	}
+
+	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		options.windowId = this.windowId;
+
+		return this.windowsService.pickFileAndOpen(options);
+	}
+
+	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		options.windowId = this.windowId;
+
+		return this.windowsService.pickFolderAndOpen(options);
+	}
+
+	reloadWindow(): TPromise<void> {
+		return this.windowsService.reloadWindow(this.windowId);
+	}
+
+	openDevTools(): TPromise<void> {
+		return this.windowsService.openDevTools(this.windowId);
+	}
+
+	toggleDevTools(): TPromise<void> {
+		return this.windowsService.toggleDevTools(this.windowId);
+	}
+
+	closeWorkspace(): TPromise<void> {
+		return this.windowsService.closeWorkspace(this.windowId);
+	}
+
+	openWorkspace(): TPromise<void> {
+		return this.windowsService.openWorkspace(this.windowId);
+	}
+
+	createAndOpenWorkspace(folders?: string[], path?: string): TPromise<void> {
+		return this.windowsService.createAndOpenWorkspace(this.windowId, folders, path);
+	}
+
+	saveAndOpenWorkspace(path: string): TPromise<void> {
+		return this.windowsService.saveAndOpenWorkspace(this.windowId, path);
+	}
+
+	closeWindow(): TPromise<void> {
+		return this.windowsService.closeWindow(this.windowId);
+	}
+
+	toggleFullScreen(): TPromise<void> {
+		return this.windowsService.toggleFullScreen(this.windowId);
+	}
+
+	setRepresentedFilename(fileName: string): TPromise<void> {
+		return this.windowsService.setRepresentedFilename(this.windowId, fileName);
+	}
+
+	getRecentlyOpened(): TPromise<IRecentlyOpened> {
+		return this.windowsService.getRecentlyOpened(this.windowId);
+	}
+
+	focusWindow(): TPromise<void> {
+		return this.windowsService.focusWindow(this.windowId);
+	}
+
+	isFocused(): TPromise<boolean> {
+		return this.windowsService.isFocused(this.windowId);
+	}
+
+	isMaximized(): TPromise<boolean> {
+		return this.windowsService.isMaximized(this.windowId);
+	}
+
+	maximizeWindow(): TPromise<void> {
+		return this.windowsService.maximizeWindow(this.windowId);
+	}
+
+	unmaximizeWindow(): TPromise<void> {
+		return this.windowsService.unmaximizeWindow(this.windowId);
+	}
+
+	onWindowTitleDoubleClick(): TPromise<void> {
+		return this.windowsService.onWindowTitleDoubleClick(this.windowId);
+	}
+
+	setDocumentEdited(flag: boolean): TPromise<void> {
+		return this.windowsService.setDocumentEdited(this.windowId, flag);
+	}
+
+	show(): TPromise<void> {
+		return this.windowsService.showWindow(this.windowId);
+	}
+
+	showMessageBox(options: Electron.ShowMessageBoxOptions): number {
+		return remote.dialog.showMessageBox(remote.getCurrentWindow(), options);
+	}
+
+	showSaveDialog(options: Electron.SaveDialogOptions, callback?: (fileName: string) => void): string {
+		if (callback) {
+			return remote.dialog.showSaveDialog(remote.getCurrentWindow(), options, callback);
+		}
+
+		return remote.dialog.showSaveDialog(remote.getCurrentWindow(), options); // https://github.com/electron/electron/issues/4936
+	}
+
+	showOpenDialog(options: Electron.OpenDialogOptions, callback?: (fileNames: string[]) => void): string[] {
+		if (callback) {
+			return remote.dialog.showOpenDialog(remote.getCurrentWindow(), options, callback);
+		}
+
+		return remote.dialog.showOpenDialog(remote.getCurrentWindow(), options); // https://github.com/electron/electron/issues/4936
+	}
+}

src/vs/platform/windows/electron-main/windows.ts

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { OpenContext, IWindowConfiguration, ReadyState, INativeOpenDialogOptions } from 'vs/platform/windows/common/windows';
+import { ParsedArgs } from 'vs/platform/environment/common/environment';
+import Event from 'vs/base/common/event';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IProcessEnvironment } from 'vs/base/common/platform';
+import { IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
+
+export interface ICodeWindow {
+	id: number;
+	win: Electron.BrowserWindow;
+	config: IWindowConfiguration;
+
+	openedFolderPath: string;
+	openedWorkspace: IWorkspaceIdentifier;
+
+	lastFocusTime: number;
+
+	readyState: ReadyState;
+
+	close(): void;
+
+	send(channel: string, ...args: any[]): void;
+	sendWhenReady(channel: string, ...args: any[]): void;
+
+	toggleFullScreen(): void;
+	hasHiddenTitleBarStyle(): boolean;
+	setRepresentedFilename(name: string): void;
+	getRepresentedFilename(): string;
+	onWindowTitleDoubleClick(): void;
+}
+
+export const IWindowsMainService = createDecorator<IWindowsMainService>('windowsMainService');
+
+export interface IWindowsCountChangedEvent {
+	oldCount: number;
+	newCount: number;
+}
+
+export interface IWindowsMainService {
+	_serviceBrand: any;
+
+	// events
+	onWindowReady: Event<ICodeWindow>;
+	onActiveWindowChanged: Event<ICodeWindow>;
+	onWindowsCountChanged: Event<IWindowsCountChangedEvent>;
+	onWindowClose: Event<number>;
+	onWindowReload: Event<number>;
+
+	// methods
+	ready(initialUserEnv: IProcessEnvironment): void;
+	reload(win: ICodeWindow, cli?: ParsedArgs): void;
+	openWorkspace(win?: ICodeWindow): void;
+	createAndOpenWorkspace(win: ICodeWindow, folders?: string[], path?: string): void;
+	saveAndOpenWorkspace(win: ICodeWindow, path: string): void;
+	closeWorkspace(win: ICodeWindow): void;
+	open(openConfig: IOpenConfiguration): ICodeWindow[];
+	openExtensionDevelopmentHostWindow(openConfig: IOpenConfiguration): void;
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): void;
+	pickFolderAndOpen(options: INativeOpenDialogOptions): void;
+	pickFileAndOpen(options: INativeOpenDialogOptions): void;
+	focusLastActive(cli: ParsedArgs, context: OpenContext): ICodeWindow;
+	getLastActiveWindow(): ICodeWindow;
+	waitForWindowClose(windowId: number): TPromise<void>;
+	openNewWindow(context: OpenContext): void;
+	sendToFocused(channel: string, ...args: any[]): void;
+	sendToAll(channel: string, payload: any, windowIdsToIgnore?: number[]): void;
+	getFocusedWindow(): ICodeWindow;
+	getWindowById(windowId: number): ICodeWindow;
+	getWindows(): ICodeWindow[];
+	getWindowCount(): number;
+	quit(): void;
+}
+
+export interface IOpenConfiguration {
+	context: OpenContext;
+	cli: ParsedArgs;
+	userEnv?: IProcessEnvironment;
+	pathsToOpen?: string[];
+	preferNewWindow?: boolean;
+	forceNewWindow?: boolean;
+	forceReuseWindow?: boolean;
+	forceEmpty?: boolean;
+	diffMode?: boolean;
+	addMode?: boolean;
+	forceOpenWorkspaceAsFile?: boolean;
+	initialStartup?: boolean;
+}
+
+export interface ISharedProcess {
+	whenReady(): TPromise<void>;
+	toggle(): void;
+}

src/vs/platform/windows/electron-main/windowsService.ts

@@ -0,0 +1,383 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { assign } from 'vs/base/common/objects';
+import URI from 'vs/base/common/uri';
+import { IWindowsService, OpenContext, INativeOpenDialogOptions } from 'vs/platform/windows/common/windows';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { shell, crashReporter, app } from 'electron';
+import Event, { chain } from 'vs/base/common/event';
+import { fromEventEmitter } from 'vs/base/node/event';
+import { IURLService } from 'vs/platform/url/common/url';
+import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
+import { IWindowsMainService, ISharedProcess } from 'vs/platform/windows/electron-main/windows';
+import { IHistoryMainService, IRecentlyOpened } from 'vs/platform/history/common/history';
+import { IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
+
+export class WindowsService implements IWindowsService, IDisposable {
+
+	_serviceBrand: any;
+
+	private disposables: IDisposable[] = [];
+
+	readonly onWindowOpen: Event<number> = fromEventEmitter(app, 'browser-window-created', (_, w: Electron.BrowserWindow) => w.id);
+	readonly onWindowFocus: Event<number> = fromEventEmitter(app, 'browser-window-focus', (_, w: Electron.BrowserWindow) => w.id);
+	readonly onWindowBlur: Event<number> = fromEventEmitter(app, 'browser-window-blur', (_, w: Electron.BrowserWindow) => w.id);
+
+	constructor(
+		private sharedProcess: ISharedProcess,
+		@IWindowsMainService private windowsMainService: IWindowsMainService,
+		@IEnvironmentService private environmentService: IEnvironmentService,
+		@IURLService urlService: IURLService,
+		@ILifecycleService private lifecycleService: ILifecycleService,
+		@IHistoryMainService private historyService: IHistoryMainService
+	) {
+		// Catch file URLs
+		chain(urlService.onOpenURL)
+			.filter(uri => uri.authority === 'file' && !!uri.path)
+			.map(uri => URI.file(uri.fsPath))
+			.on(this.openFileForURI, this, this.disposables);
+
+		// Catch extension URLs when there are no windows open
+		chain(urlService.onOpenURL)
+			.filter(uri => /^extension/.test(uri.path))
+			.filter(() => this.windowsMainService.getWindowCount() === 0)
+			.on(this.openExtensionForURI, this, this.disposables);
+	}
+
+	pickFileFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.windowsMainService.pickFileFolderAndOpen(options);
+
+		return TPromise.as(null);
+	}
+
+	pickFileAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.windowsMainService.pickFileAndOpen(options);
+
+		return TPromise.as(null);
+	}
+
+	pickFolderAndOpen(options: INativeOpenDialogOptions): TPromise<void> {
+		this.windowsMainService.pickFolderAndOpen(options);
+
+		return TPromise.as(null);
+	}
+
+	reloadWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			this.windowsMainService.reload(codeWindow);
+		}
+
+		return TPromise.as(null);
+	}
+
+	openDevTools(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.webContents.openDevTools();
+		}
+
+		return TPromise.as(null);
+	}
+
+	toggleDevTools(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			const contents = codeWindow.win.webContents;
+			if (codeWindow.hasHiddenTitleBarStyle() && !codeWindow.win.isFullScreen() && !contents.isDevToolsOpened()) {
+				contents.openDevTools({ mode: 'undocked' }); // due to https://github.com/electron/electron/issues/3647
+			} else {
+				contents.toggleDevTools();
+			}
+		}
+
+		return TPromise.as(null);
+	}
+
+	closeWorkspace(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			this.windowsMainService.closeWorkspace(codeWindow);
+		}
+
+		return TPromise.as(null);
+	}
+
+	openWorkspace(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			this.windowsMainService.openWorkspace(codeWindow);
+		}
+
+		return TPromise.as(null);
+	}
+
+	createAndOpenWorkspace(windowId: number, folders?: string[], path?: string): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			this.windowsMainService.createAndOpenWorkspace(codeWindow, folders, path);
+		}
+
+		return TPromise.as(null);
+	}
+
+	saveAndOpenWorkspace(windowId: number, path: string): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			this.windowsMainService.saveAndOpenWorkspace(codeWindow, path);
+		}
+
+		return TPromise.as(null);
+	}
+
+	toggleFullScreen(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.toggleFullScreen();
+		}
+
+		return TPromise.as(null);
+	}
+
+	setRepresentedFilename(windowId: number, fileName: string): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.setRepresentedFilename(fileName);
+		}
+
+		return TPromise.as(null);
+	}
+
+	addRecentlyOpened(files: string[]): TPromise<void> {
+		this.historyService.addRecentlyOpened(void 0, files);
+
+		return TPromise.as(null);
+	}
+
+	removeFromRecentlyOpened(paths: string[]): TPromise<void> {
+		this.historyService.removeFromRecentlyOpened(paths);
+
+		return TPromise.as(null);
+	}
+
+	clearRecentlyOpened(): TPromise<void> {
+		this.historyService.clearRecentlyOpened();
+
+		return TPromise.as(null);
+	}
+
+	getRecentlyOpened(windowId: number): TPromise<IRecentlyOpened> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			return TPromise.as(this.historyService.getRecentlyOpened(codeWindow.config.workspace || codeWindow.config.folderPath, codeWindow.config.filesToOpen));
+		}
+
+		return TPromise.as(this.historyService.getRecentlyOpened());
+	}
+
+	focusWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.focus();
+		}
+
+		return TPromise.as(null);
+	}
+
+	closeWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.close();
+		}
+
+		return TPromise.as(null);
+	}
+
+	isFocused(windowId: number): TPromise<boolean> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			return TPromise.as(codeWindow.win.isFocused());
+		}
+
+		return TPromise.as(null);
+	}
+
+	isMaximized(windowId: number): TPromise<boolean> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			return TPromise.as(codeWindow.win.isMaximized());
+		}
+
+		return TPromise.as(null);
+	}
+
+	maximizeWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.maximize();
+		}
+
+		return TPromise.as(null);
+	}
+
+	unmaximizeWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.unmaximize();
+		}
+
+		return TPromise.as(null);
+	}
+
+	onWindowTitleDoubleClick(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.onWindowTitleDoubleClick();
+		}
+
+		return TPromise.as(null);
+	}
+
+	setDocumentEdited(windowId: number, flag: boolean): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow && codeWindow.win.isDocumentEdited() !== flag) {
+			codeWindow.win.setDocumentEdited(flag);
+		}
+
+		return TPromise.as(null);
+	}
+
+	openWindow(paths: string[], options?: { forceNewWindow?: boolean, forceReuseWindow?: boolean, forceOpenWorkspaceAsFile?: boolean }): TPromise<void> {
+		if (!paths || !paths.length) {
+			return TPromise.as(null);
+		}
+
+		this.windowsMainService.open({
+			context: OpenContext.API,
+			cli: this.environmentService.args,
+			pathsToOpen: paths,
+			forceNewWindow: options && options.forceNewWindow,
+			forceReuseWindow: options && options.forceReuseWindow,
+			forceOpenWorkspaceAsFile: options && options.forceOpenWorkspaceAsFile
+		});
+
+		return TPromise.as(null);
+	}
+
+	openNewWindow(): TPromise<void> {
+		this.windowsMainService.openNewWindow(OpenContext.API);
+		return TPromise.as(null);
+	}
+
+	showWindow(windowId: number): TPromise<void> {
+		const codeWindow = this.windowsMainService.getWindowById(windowId);
+
+		if (codeWindow) {
+			codeWindow.win.show();
+		}
+
+		return TPromise.as(null);
+	}
+
+	getWindows(): TPromise<{ id: number; workspace?: IWorkspaceIdentifier; folderPath?: string; title: string; filename?: string; }[]> {
+		const windows = this.windowsMainService.getWindows();
+		const result = windows.map(w => ({ id: w.id, workspace: w.openedWorkspace, openedFolderPath: w.openedFolderPath, title: w.win.getTitle(), filename: w.getRepresentedFilename() }));
+
+		return TPromise.as(result);
+	}
+
+	getWindowCount(): TPromise<number> {
+		return TPromise.as(this.windowsMainService.getWindows().length);
+	}
+
+	log(severity: string, ...messages: string[]): TPromise<void> {
+		console[severity].apply(console, ...messages);
+		return TPromise.as(null);
+	}
+
+	showItemInFolder(path: string): TPromise<void> {
+		shell.showItemInFolder(path);
+		return TPromise.as(null);
+	}
+
+	openExternal(url: string): TPromise<boolean> {
+		return TPromise.as(shell.openExternal(url));
+	}
+
+	startCrashReporter(config: Electron.CrashReporterStartOptions): TPromise<void> {
+		crashReporter.start(config);
+		return TPromise.as(null);
+	}
+
+	quit(): TPromise<void> {
+		this.windowsMainService.quit();
+		return TPromise.as(null);
+	}
+
+	relaunch(options: { addArgs?: string[], removeArgs?: string[] }): TPromise<void> {
+		this.lifecycleService.relaunch(options);
+
+		return TPromise.as(null);
+	}
+
+	whenSharedProcessReady(): TPromise<void> {
+		return this.sharedProcess.whenReady();
+	}
+
+	toggleSharedProcess(): TPromise<void> {
+		this.sharedProcess.toggle();
+		return TPromise.as(null);
+	}
+
+	private openFileForURI(uri: URI): TPromise<void> {
+		const cli = assign(Object.create(null), this.environmentService.args, { goto: true });
+		const pathsToOpen = [uri.fsPath];
+
+		this.windowsMainService.open({ context: OpenContext.API, cli, pathsToOpen });
+		return TPromise.as(null);
+	}
+
+	/**
+	 * This should only fire whenever an extension URL is open
+	 * and there are no windows to handle it.
+	 */
+	private async openExtensionForURI(uri: URI): TPromise<void> {
+		const cli = assign(Object.create(null), this.environmentService.args);
+		const window = await this.windowsMainService.open({ context: OpenContext.API, cli })[0];
+
+		if (!window) {
+			return;
+		}
+
+		window.win.show();
+	}
+
+	dispose(): void {
+		this.disposables = dispose(this.disposables);
+	}
+}