main - more shuffling around

src/vs/code/electron-browser/sharedProcessMain.ts

@@ -33,7 +33,7 @@ import { ChoiceChannelClient } from 'vs/platform/message/common/messageIpc';
 import { IWindowsService } from 'vs/platform/windows/common/windows';
 import { WindowsChannelClient } from 'vs/platform/windows/common/windowsIpc';
 import { ipcRenderer } from 'electron';
-import { IDisposable, dispose } from "vs/base/common/lifecycle";
+import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 
 interface ISharedProcessInitData {
 	sharedIPCHandle: string;

src/vs/code/electron-main/app.ts

@@ -10,7 +10,7 @@ import * as platform from 'vs/base/common/platform';
 import { WindowsManager } from 'vs/code/electron-main/windows';
 import { IWindowsService, OpenContext } from 'vs/platform/windows/common/windows';
 import { WindowsChannel } from 'vs/platform/windows/common/windowsIpc';
-import { WindowsService, IWindowsMainService } from 'vs/platform/windows/electron-main/windowsService';
+import { WindowsService } from 'vs/platform/windows/electron-main/windowsService';
 import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
 import { CodeMenu } from 'vs/code/electron-main/menus';
 import { getShellEnvironment } from 'vs/code/node/shellEnv';
@@ -44,6 +44,7 @@ import pkg from 'vs/platform/node/package';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { ConfigurationService } from 'vs/platform/configuration/node/configurationService';
 import { TPromise } from "vs/base/common/winjs.base";
+import { IWindowsMainService } from "vs/platform/windows/electron-main/windows";
 
 export class CodeApplication {
 	private toDispose: IDisposable[];

src/vs/code/electron-main/keyboard.ts

@@ -12,9 +12,9 @@ import { IStorageService } from 'vs/platform/storage/node/storage';
 import Event, { Emitter, once } from 'vs/base/common/event';
 import { ConfigWatcher } from 'vs/base/node/config';
 import { IUserFriendlyKeybinding } from 'vs/platform/keybinding/common/keybinding';
-import { IEnvironmentService } from "vs/platform/environment/common/environment";
-import { IWindowsMainService } from "vs/platform/windows/electron-main/windowsService";
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ipcMain as ipc } from 'electron';
+import { IWindowsMainService } from "vs/platform/windows/electron-main/windows";
 
 export class KeyboardLayoutMonitor {
 

src/vs/code/electron-main/launch.ts

@@ -13,8 +13,8 @@ import { IProcessEnvironment } from 'vs/base/common/platform';
 import { ParsedArgs } from 'vs/platform/environment/common/environment';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { once } from 'vs/base/common/event';
-import { OpenContext } from "vs/platform/windows/common/windows";
-import { IWindowsMainService, ICodeWindow } from "vs/platform/windows/electron-main/windowsService";
+import { OpenContext } from 'vs/platform/windows/common/windows';
+import { IWindowsMainService, ICodeWindow } from "vs/platform/windows/electron-main/windows";
 
 export const ID = 'launchService';
 export const ILaunchService = createDecorator<ILaunchService>(ID);

src/vs/code/electron-main/menus.ts

@@ -10,7 +10,7 @@ import { isMacintosh, isLinux, isWindows, language } from 'vs/base/common/platfo
 import * as arrays from 'vs/base/common/arrays';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ipcMain as ipc, app, shell, dialog, Menu, MenuItem, BrowserWindow } from 'electron';
-import { OpenContext } from "vs/platform/windows/common/windows";
+import { OpenContext } from 'vs/platform/windows/common/windows';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IFilesConfiguration, AutoSaveConfiguration } from 'vs/platform/files/common/files';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -18,9 +18,9 @@ import { IUpdateService, State as UpdateState } from 'vs/platform/update/common/
 import product from 'vs/platform/node/product';
 import { RunOnceScheduler } from 'vs/base/common/async';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { tildify } from "vs/base/common/labels";
-import { IWindowsMainService } from "vs/platform/windows/electron-main/windowsService";
+import { tildify } from 'vs/base/common/labels';
 import { KeybindingsResolver } from "vs/code/electron-main/keyboard";
+import { IWindowsMainService } from "vs/platform/windows/electron-main/windows";
 
 interface IExtensionViewlet {
 	id: string;

src/vs/code/electron-main/sharedProcess.ts

@@ -11,8 +11,9 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { IProcessEnvironment } from 'vs/base/common/platform';
 import { BrowserWindow, ipcMain } from 'electron';
 import { PromiseSource } from 'vs/base/common/async';
+import { ISharedProcess } from "vs/platform/windows/electron-main/windows";
 
-export class SharedProcess {
+export class SharedProcess implements ISharedProcess {
 
 	private spawnPromiseSource: PromiseSource<void>;
 

src/vs/code/electron-main/window.ts

@@ -19,11 +19,11 @@ import { IWorkbenchEditorConfiguration } from 'vs/workbench/common/editor';
 import { parseArgs } from 'vs/platform/environment/node/argv';
 import product from 'vs/platform/node/product';
 import { getCommonHTTPHeaders } from 'vs/platform/environment/node/http';
-import { IWindowSettings, MenuBarVisibility, ReadyState } from 'vs/platform/windows/common/windows';
+import { IWindowSettings, MenuBarVisibility, IWindowConfiguration, ReadyState } from 'vs/platform/windows/common/windows';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { KeyboardLayoutMonitor } from 'vs/code/electron-main/keyboard';
-import { isLinux, isMacintosh, isWindows } from "vs/base/common/platform";
-import { ICodeWindow, IWindowConfiguration } from "vs/platform/windows/electron-main/windowsService";
+import { isLinux, isMacintosh, isWindows } from 'vs/base/common/platform';
+import { ICodeWindow } from "vs/platform/windows/electron-main/windows";
 
 export interface IWindowState {
 	width?: number;

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

@@ -23,14 +23,14 @@ import { ILifecycleService, UnloadReason } from 'vs/platform/lifecycle/electron-
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILogService } from 'vs/platform/log/common/log';
 import { getPathLabel } from 'vs/base/common/labels';
-import { IWindowSettings, OpenContext } from 'vs/platform/windows/common/windows';
+import { IWindowSettings, OpenContext, IPath, IWindowConfiguration } from 'vs/platform/windows/common/windows';
 import { getLastActiveWindow, findBestWindowOrFolder } from 'vs/code/node/windowsUtils';
 import CommonEvent, { Emitter } from 'vs/base/common/event';
 import product from 'vs/platform/node/product';
 import { ITelemetryService, ITelemetryData } from 'vs/platform/telemetry/common/telemetry';
 import { isParent, isEqual, isEqualOrParent } from 'vs/platform/files/common/files';
 import { KeyboardLayoutMonitor } from 'vs/code/electron-main/keyboard';
-import { IPath, IWindowsMainService, IOpenConfiguration, IRecentPathsList, IWindowConfiguration } from "vs/platform/windows/electron-main/windowsService";
+import { IWindowsMainService, IOpenConfiguration, IRecentPathsList } from "vs/platform/windows/electron-main/windows";
 
 enum WindowError {
 	UNRESPONSIVE,

src/vs/code/node/windowsUtils.ts

@@ -9,7 +9,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as platform from 'vs/base/common/platform';
 import * as paths from 'vs/base/common/paths';
-import { OpenContext } from "vs/platform/windows/common/windows";
+import { OpenContext } from 'vs/platform/windows/common/windows';
 import { isEqualOrParent } from 'vs/platform/files/common/files';
 
 /**

src/vs/code/test/node/windowsUtils.test.ts

@@ -7,7 +7,7 @@
 import assert = require('assert');
 import path = require('path');
 import { findBestWindowOrFolder, ISimpleWindow, IBestWindowOrFolderOptions } from 'vs/code/node/windowsUtils';
-import { OpenContext } from "vs/platform/windows/common/windows";
+import { OpenContext } from 'vs/platform/windows/common/windows';
 
 const fixturesFolder = require.toUrl('./fixtures');
 

src/vs/platform/lifecycle/electron-main/lifecycleMain.ts

@@ -12,8 +12,8 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { IStorageService } from 'vs/platform/storage/node/storage';
 import Event, { Emitter } from 'vs/base/common/event';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { ICodeWindow } from "vs/platform/windows/electron-main/windows";
 import { ReadyState } from "vs/platform/windows/common/windows";
-import { ICodeWindow } from "vs/platform/windows/electron-main/windowsService";
 
 export const ILifecycleService = createDecorator<ILifecycleService>('lifecycleService');
 

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

@@ -9,6 +9,8 @@ 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";
 
 export const IWindowsService = createDecorator<IWindowsService>('windowsService');
 
@@ -109,6 +111,27 @@ export interface IWindowSettings {
 	enableMenuBarMnemonics: 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 {
 
 	/**
@@ -132,23 +155,50 @@ export enum ReadyState {
 	READY
 }
 
-export enum OpenContext {
+export interface IPath {
 
-	// opening when running from the command line
-	CLI,
+	// the workspace spath for a Code instance which can be null
+	workspacePath?: string;
 
-	// macOS only: opening from the dock (also when opening files to a running instance from desktop)
-	DOCK,
+	// the file path to open within a Code instance
+	filePath?: string;
 
-	// opening from the main application window
-	MENU,
+	// the line number in the file path to open
+	lineNumber?: number;
 
-	// opening from a file or folder dialog
-	DIALOG,
+	// the column number in the file path to open
+	columnNumber?: number;
 
-	// opening from the OS's UI
-	DESKTOP,
+	// indicator to create the file path in the Code instance
+	createFilePath?: boolean;
+}
 
-	// opening through the API
-	API
+export interface IWindowConfiguration extends ParsedArgs {
+	appRoot: string;
+	execPath: string;
+
+	userEnv: IProcessEnvironment;
+
+	isISOKeyboard?: boolean;
+
+	zoomLevel?: number;
+	fullscreen?: boolean;
+	highContrast?: boolean;
+	baseTheme?: string;
+	backgroundColor?: string;
+	accessibilitySupport?: boolean;
+
+	isInitialStartup?: boolean;
+
+	perfStartTime?: number;
+	perfAppReady?: number;
+	perfWindowLoadTime?: number;
+
+	workspacePath?: string;
+
+	filesToOpen?: IPath[];
+	filesToCreate?: IPath[];
+	filesToDiff?: IPath[];
+
+	nodeCachedDataDir: string;
 }
\ No newline at end of file

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

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { OpenContext, IWindowConfiguration, ReadyState, IPath } from 'vs/platform/windows/common/windows';
+import { ParsedArgs } from 'vs/platform/environment/common/environment';
+import Event from 'vs/base/common/event';
+import { ITelemetryData } from 'vs/platform/telemetry/common/telemetry';
+import { createDecorator } from "vs/platform/instantiation/common/instantiation";
+import { IProcessEnvironment } from "vs/base/common/platform";
+
+export interface ICodeWindow {
+	id: number;
+	win: Electron.BrowserWindow;
+	config: IWindowConfiguration;
+	openedWorkspacePath: string;
+
+	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 IWindowsMainService {
+	_serviceBrand: any;
+
+	// events
+	onWindowReady: Event<ICodeWindow>;
+	onWindowClose: Event<number>;
+	onWindowReload: Event<number>;
+	onPathsOpen: Event<IPath[]>;
+	onRecentPathsChange: Event<void>;
+
+	// methods
+	ready(initialUserEnv: IProcessEnvironment): void;
+	reload(win: ICodeWindow, cli?: ParsedArgs): void;
+	open(openConfig: IOpenConfiguration): ICodeWindow[];
+	openExtensionDevelopmentHostWindow(openConfig: IOpenConfiguration): void;
+	openFileFolderPicker(forceNewWindow?: boolean, data?: ITelemetryData): void;
+	openFilePicker(forceNewWindow?: boolean, path?: string, window?: ICodeWindow, data?: ITelemetryData): void;
+	openFolderPicker(forceNewWindow?: boolean, window?: ICodeWindow, data?: ITelemetryData): void;
+	focusLastActive(cli: ParsedArgs, context: OpenContext): ICodeWindow;
+	getLastActiveWindow(): ICodeWindow;
+	findWindow(workspacePath: string, filePath?: string, extensionDevelopmentPath?: string): ICodeWindow;
+	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;
+	addToRecentPathsList(paths: { path: string; isFile?: boolean; }[]): void;
+	getRecentPathsList(workspacePath?: string, filesToOpen?: IPath[]): IRecentPathsList;
+	removeFromRecentPathsList(path: string): void;
+	removeFromRecentPathsList(paths: string[]): void;
+	clearRecentPathsList(): void;
+	updateWindowsJumpList(): void;
+	quit(): void;
+}
+
+export interface IOpenConfiguration {
+	context: OpenContext;
+	cli: ParsedArgs;
+	userEnv?: IProcessEnvironment;
+	pathsToOpen?: string[];
+	preferNewWindow?: boolean;
+	forceNewWindow?: boolean;
+	forceReuseWindow?: boolean;
+	forceEmpty?: boolean;
+	windowToUse?: ICodeWindow;
+	diffMode?: boolean;
+	initialStartup?: boolean;
+}
+
+export interface IRecentPathsList {
+	folders: string[];
+	files: string[];
+}
+
+export interface ISharedProcess {
+	whenReady(): TPromise<void>;
+	toggle(): void;
+}
\ No newline at end of file

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

@@ -9,147 +9,15 @@ 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, ReadyState } from 'vs/platform/windows/common/windows';
-import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
+import { IWindowsService, OpenContext } 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 { ITelemetryData } from 'vs/platform/telemetry/common/telemetry';
 import { ILifecycleService } from "vs/platform/lifecycle/electron-main/lifecycleMain";
-import { createDecorator } from "vs/platform/instantiation/common/instantiation";
-import { IProcessEnvironment } from "vs/base/common/platform";
-
-export interface ICodeWindow {
-	id: number;
-	win: Electron.BrowserWindow;
-	config: IWindowConfiguration;
-	openedWorkspacePath: string;
-
-	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 interface IWindowConfiguration extends ParsedArgs {
-	appRoot: string;
-	execPath: string;
-
-	userEnv: IProcessEnvironment;
-
-	isISOKeyboard?: boolean;
-
-	zoomLevel?: number;
-	fullscreen?: boolean;
-	highContrast?: boolean;
-	baseTheme?: string;
-	backgroundColor?: string;
-	accessibilitySupport?: boolean;
-
-	isInitialStartup?: boolean;
-
-	perfStartTime?: number;
-	perfAppReady?: number;
-	perfWindowLoadTime?: number;
-
-	workspacePath?: string;
-
-	filesToOpen?: IPath[];
-	filesToCreate?: IPath[];
-	filesToDiff?: IPath[];
-
-	nodeCachedDataDir: string;
-}
-
-export interface ISharedProcess {
-	whenReady(): TPromise<void>;
-	toggle(): void;
-}
-
-export const IWindowsMainService = createDecorator<IWindowsMainService>('windowsMainService');
-
-export interface IWindowsMainService {
-	_serviceBrand: any;
-
-	// events
-	onWindowReady: Event<ICodeWindow>;
-	onWindowClose: Event<number>;
-	onWindowReload: Event<number>;
-	onPathsOpen: Event<IPath[]>;
-	onRecentPathsChange: Event<void>;
-
-	// methods
-	ready(initialUserEnv: IProcessEnvironment): void;
-	reload(win: ICodeWindow, cli?: ParsedArgs): void;
-	open(openConfig: IOpenConfiguration): ICodeWindow[];
-	openExtensionDevelopmentHostWindow(openConfig: IOpenConfiguration): void;
-	openFileFolderPicker(forceNewWindow?: boolean, data?: ITelemetryData): void;
-	openFilePicker(forceNewWindow?: boolean, path?: string, window?: ICodeWindow, data?: ITelemetryData): void;
-	openFolderPicker(forceNewWindow?: boolean, window?: ICodeWindow, data?: ITelemetryData): void;
-	focusLastActive(cli: ParsedArgs, context: OpenContext): ICodeWindow;
-	getLastActiveWindow(): ICodeWindow;
-	findWindow(workspacePath: string, filePath?: string, extensionDevelopmentPath?: string): ICodeWindow;
-	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;
-	addToRecentPathsList(paths: { path: string; isFile?: boolean; }[]): void;
-	getRecentPathsList(workspacePath?: string, filesToOpen?: IPath[]): IRecentPathsList;
-	removeFromRecentPathsList(path: string): void;
-	removeFromRecentPathsList(paths: string[]): void;
-	clearRecentPathsList(): void;
-	updateWindowsJumpList(): void;
-	quit(): void;
-}
-
-export interface IPath {
-
-	// the workspace spath for a Code instance which can be null
-	workspacePath?: string;
-
-	// 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;
-
-	// indicator to create the file path in the Code instance
-	createFilePath?: boolean;
-}
-
-export interface IOpenConfiguration {
-	context: OpenContext;
-	cli: ParsedArgs;
-	userEnv?: IProcessEnvironment;
-	pathsToOpen?: string[];
-	preferNewWindow?: boolean;
-	forceNewWindow?: boolean;
-	forceReuseWindow?: boolean;
-	forceEmpty?: boolean;
-	windowToUse?: ICodeWindow;
-	diffMode?: boolean;
-	initialStartup?: boolean;
-}
-
-export interface IRecentPathsList {
-	folders: string[];
-	files: string[];
-}
+import { IWindowsMainService, ISharedProcess } from "vs/platform/windows/electron-main/windows";
 
 export class WindowsService implements IWindowsService, IDisposable {