window.ts 18.8 KB
Newer Older
E
Erich Gamma 已提交
1 2 3 4 5
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

6
import * as nls from 'vs/nls';
7
import { URI } from 'vs/base/common/uri';
8
import * as errors from 'vs/base/common/errors';
J
Johannes Rieken 已提交
9
import { TPromise } from 'vs/base/common/winjs.base';
S
SteVen Batten 已提交
10
import * as arrays from 'vs/base/common/arrays';
11 12
import * as objects from 'vs/base/common/objects';
import * as DOM from 'vs/base/browser/dom';
13 14
import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
import { IAction, Action } from 'vs/base/common/actions';
S
SteVen Batten 已提交
15
import { IFileService } from 'vs/platform/files/common/files';
B
Benjamin Pasero 已提交
16
import { toResource, IUntitledResourceInput } from 'vs/workbench/common/editor';
17
import { IEditorService, IResourceEditor } from 'vs/workbench/services/editor/common/editorService';
J
Johannes Rieken 已提交
18
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
19
import { IWorkspaceConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
M
Martin Aeschlimann 已提交
20
import { IWindowsService, IWindowService, IWindowSettings, IOpenFileRequest, IWindowsConfiguration, IAddFoldersRequest, IRunActionInWindowRequest, IPathData } from 'vs/platform/windows/common/windows';
21
import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
B
Benjamin Pasero 已提交
22
import { ITitleService } from 'vs/workbench/services/title/common/titleService';
23
import { IWorkbenchThemeService, VS_HC_THEME } from 'vs/workbench/services/themes/common/workbenchThemeService';
24 25
import * as browser from 'vs/base/browser/browser';
import { ICommandService } from 'vs/platform/commands/common/commands';
B
Benjamin Pasero 已提交
26
import { IResourceInput } from 'vs/platform/editor/common/editor';
A
Alex Dima 已提交
27
import { KeyboardMapperFactory } from 'vs/workbench/services/keybinding/electron-browser/keybindingService';
28
import { Themable } from 'vs/workbench/common/theme';
29
import { ipcRenderer as ipc, webFrame } from 'electron';
30
import { IWorkspaceEditingService } from 'vs/workbench/services/workspace/common/workspaceEditing';
31 32
import { IMenuService, MenuId, IMenu, MenuItemAction, ICommandAction } from 'vs/platform/actions/common/actions';
import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
33
import { fillInActionBarActions } from 'vs/platform/actions/browser/menuItemActionItem';
34 35
import { RunOnceScheduler } from 'vs/base/common/async';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
36
import { LifecyclePhase, ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
37
import { IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
38 39 40
import { IIntegrityService } from 'vs/platform/integrity/common/integrity';
import { AccessibilitySupport, isRootUser, isWindows, isMacintosh } from 'vs/base/common/platform';
import product from 'vs/platform/node/product';
41
import { INotificationService } from 'vs/platform/notification/common/notification';
B
Benjamin Pasero 已提交
42
import { EditorServiceImpl } from 'vs/workbench/browser/parts/editor/editor';
S
SteVen Batten 已提交
43 44
import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
E
Erich Gamma 已提交
45

46 47 48 49 50 51 52 53 54 55 56
const TextInputActions: IAction[] = [
	new Action('undo', nls.localize('undo', "Undo"), null, true, () => document.execCommand('undo') && TPromise.as(true)),
	new Action('redo', nls.localize('redo', "Redo"), null, true, () => document.execCommand('redo') && TPromise.as(true)),
	new Separator(),
	new Action('editor.action.clipboardCutAction', nls.localize('cut', "Cut"), null, true, () => document.execCommand('cut') && TPromise.as(true)),
	new Action('editor.action.clipboardCopyAction', nls.localize('copy', "Copy"), null, true, () => document.execCommand('copy') && TPromise.as(true)),
	new Action('editor.action.clipboardPasteAction', nls.localize('paste', "Paste"), null, true, () => document.execCommand('paste') && TPromise.as(true)),
	new Separator(),
	new Action('editor.action.selectAll', nls.localize('selectAll', "Select All"), null, true, () => document.execCommand('selectAll') && TPromise.as(true))
];

57
export class ElectronWindow extends Themable {
58

59 60
	private touchBarMenu: IMenu;
	private touchBarUpdater: RunOnceScheduler;
61 62 63 64 65
	private touchBarDisposables: IDisposable[];
	private lastInstalledTouchedBar: ICommandAction[][];

	private previousConfiguredZoomLevel: number;

66
	private addFoldersScheduler: RunOnceScheduler;
67
	private pendingFoldersToAdd: URI[];
68

E
Erich Gamma 已提交
69
	constructor(
B
Benjamin Pasero 已提交
70
		@IEditorService private editorService: EditorServiceImpl,
71
		@IWindowsService private windowsService: IWindowsService,
B
Benjamin Pasero 已提交
72
		@IWindowService private windowService: IWindowService,
73 74
		@IWorkspaceConfigurationService private configurationService: IWorkspaceConfigurationService,
		@ITitleService private titleService: ITitleService,
75
		@IWorkbenchThemeService protected themeService: IWorkbenchThemeService,
76
		@INotificationService private notificationService: INotificationService,
77
		@ICommandService private commandService: ICommandService,
S
SteVen Batten 已提交
78
		@IExtensionService private extensionService: IExtensionService,
79
		@IContextMenuService private contextMenuService: IContextMenuService,
S
SteVen Batten 已提交
80
		@IKeybindingService private keybindingService: IKeybindingService,
81
		@ITelemetryService private telemetryService: ITelemetryService,
82
		@IWorkspaceEditingService private workspaceEditingService: IWorkspaceEditingService,
83
		@IFileService private fileService: IFileService,
84
		@IMenuService private menuService: IMenuService,
85 86
		@ILifecycleService private lifecycleService: ILifecycleService,
		@IIntegrityService private integrityService: IIntegrityService
E
Erich Gamma 已提交
87
	) {
88 89
		super(themeService);

90 91
		this.touchBarDisposables = [];

92
		this.pendingFoldersToAdd = [];
B
Benjamin Pasero 已提交
93
		this.addFoldersScheduler = this._register(new RunOnceScheduler(() => this.doAddFolders(), 100));
94

E
Erich Gamma 已提交
95
		this.registerListeners();
96
		this.create();
E
Erich Gamma 已提交
97 98 99 100
	}

	private registerListeners(): void {

101
		// React to editor input changes
B
Benjamin Pasero 已提交
102
		this._register(this.editorService.onDidActiveEditorChange(() => this.updateTouchbarMenu()));
E
Erich Gamma 已提交
103

104
		// prevent opening a real URL inside the shell
105 106 107 108
		[DOM.EventType.DRAG_OVER, DOM.EventType.DROP].forEach(event => {
			window.document.body.addEventListener(event, (e: DragEvent) => {
				DOM.EventHelper.stop(e);
			});
E
Erich Gamma 已提交
109 110
		});

111
		// Support runAction event
112
		ipc.on('vscode:runAction', (event: any, request: IRunActionInWindowRequest) => {
113 114 115 116 117
			const args: any[] = [];

			// If we run an action from the touchbar, we fill in the currently active resource
			// as payload because the touch bar items are context aware depending on the editor
			if (request.from === 'touchbar') {
B
Benjamin Pasero 已提交
118
				const activeEditor = this.editorService.activeEditor;
119
				if (activeEditor) {
B
Benjamin Pasero 已提交
120
					const resource = toResource(activeEditor, { supportSideBySide: true });
121 122 123 124 125 126 127 128
					if (resource) {
						args.push(resource);
					}
				}
			} else {
				args.push({ from: request.from }); // TODO@telemetry this is a bit weird to send this to every action?
			}

129
			this.commandService.executeCommand(request.id, ...args).then(_ => {
K
kieferrm 已提交
130
				/* __GDPR__
K
kieferrm 已提交
131 132 133 134 135
					"commandExecuted" : {
						"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
						"from": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
					}
				*/
136
				this.telemetryService.publicLog('commandExecuted', { id: request.id, from: request.from });
J
Johannes Rieken 已提交
137
			}, err => {
138
				this.notificationService.error(err);
J
Johannes Rieken 已提交
139
			});
140 141
		});

S
SteVen Batten 已提交
142 143 144 145 146 147 148 149
		// Support resolve keybindings event
		ipc.on('vscode:resolveKeybindings', (event: any, rawActionIds: string) => {
			let actionIds: string[] = [];
			try {
				actionIds = JSON.parse(rawActionIds);
			} catch (error) {
				// should not happen
			}
150

S
SteVen Batten 已提交
151
			// Resolve keys using the keybinding service and send back to browser process
152
			this.resolveKeybindings(actionIds).then(keybindings => {
S
SteVen Batten 已提交
153 154 155
				if (keybindings.length) {
					ipc.send('vscode:keybindingsResolved', JSON.stringify(keybindings));
				}
156
			});
S
SteVen Batten 已提交
157 158
		});

159
		ipc.on('vscode:reportError', (event: any, error: string) => {
160 161 162 163 164 165 166 167
			if (error) {
				const errorParsed = JSON.parse(error);
				errorParsed.mainProcess = true;
				errors.onUnexpectedError(errorParsed);
			}
		});

		// Support openFiles event for existing and new files
168
		ipc.on('vscode:openFiles', (event: any, request: IOpenFileRequest) => this.onOpenFiles(request));
169

170
		// Support addFolders event if we have a workspace opened
171
		ipc.on('vscode:addFolders', (event: any, request: IAddFoldersRequest) => this.onAddFoldersRequest(request));
172

173
		// Message support
174
		ipc.on('vscode:showInfoMessage', (event: any, message: string) => {
175
			this.notificationService.info(message);
176 177 178
		});

		// Fullscreen Events
179
		ipc.on('vscode:enterFullScreen', () => {
180
			this.lifecycleService.when(LifecyclePhase.Running).then(() => {
181 182 183 184
				browser.setFullscreen(true);
			});
		});

185
		ipc.on('vscode:leaveFullScreen', () => {
186
			this.lifecycleService.when(LifecyclePhase.Running).then(() => {
187 188 189 190 191
				browser.setFullscreen(false);
			});
		});

		// High Contrast Events
192
		ipc.on('vscode:enterHighContrast', () => {
193
			const windowConfig = this.configurationService.getValue<IWindowSettings>('window');
194
			if (windowConfig && windowConfig.autoDetectHighContrast) {
195
				this.lifecycleService.when(LifecyclePhase.Running).then(() => {
M
Martin Aeschlimann 已提交
196
					this.themeService.setColorTheme(VS_HC_THEME, null);
197 198
				});
			}
199 200
		});

201
		ipc.on('vscode:leaveHighContrast', () => {
202
			const windowConfig = this.configurationService.getValue<IWindowSettings>('window');
203
			if (windowConfig && windowConfig.autoDetectHighContrast) {
204
				this.lifecycleService.when(LifecyclePhase.Running).then(() => {
205
					this.themeService.restoreColorTheme();
206 207
				});
			}
208 209
		});

A
Alex Dima 已提交
210
		// keyboard layout changed event
211
		ipc.on('vscode:keyboardLayoutChanged', () => {
212
			KeyboardMapperFactory.INSTANCE._onKeyboardLayoutChanged();
A
Alex Dima 已提交
213 214
		});

215
		// keyboard layout changed event
216
		ipc.on('vscode:accessibilitySupportChanged', (event: any, accessibilitySupportEnabled: boolean) => {
217
			browser.setAccessibilitySupport(accessibilitySupportEnabled ? AccessibilitySupport.Enabled : AccessibilitySupport.Disabled);
218 219
		});

S
Sandeep Somavarapu 已提交
220 221
		// Zoom level changes
		this.updateWindowZoomLevel();
B
Benjamin Pasero 已提交
222
		this._register(this.configurationService.onDidChangeConfiguration(e => {
S
Sandeep Somavarapu 已提交
223 224 225 226
			if (e.affectsConfiguration('window.zoomLevel')) {
				this.updateWindowZoomLevel();
			}
		}));
227

228 229 230
		// Context menu support in input/textarea
		window.document.addEventListener('contextmenu', e => this.onContextMenu(e));
	}
231

232
	private onContextMenu(e: MouseEvent): void {
233 234 235
		if (e.target instanceof HTMLElement) {
			const target = <HTMLElement>e.target;
			if (target.nodeName && (target.nodeName.toLowerCase() === 'input' || target.nodeName.toLowerCase() === 'textarea')) {
B
Benjamin Pasero 已提交
236
				DOM.EventHelper.stop(e, true);
237

238 239
				this.contextMenuService.showContextMenu({
					getAnchor: () => e,
240
					getActions: () => TextInputActions,
B
Benjamin Pasero 已提交
241
					onHide: () => target.focus() // fixes https://github.com/Microsoft/vscode/issues/52948
242
				});
243
			}
244 245 246
		}
	}

S
Sandeep Somavarapu 已提交
247
	private updateWindowZoomLevel(): void {
248
		const windowConfig: IWindowsConfiguration = this.configurationService.getValue<IWindowsConfiguration>();
249 250 251 252

		let newZoomLevel = 0;
		if (windowConfig.window && typeof windowConfig.window.zoomLevel === 'number') {
			newZoomLevel = windowConfig.window.zoomLevel;
253

254 255 256
			// Leave early if the configured zoom level did not change (https://github.com/Microsoft/vscode/issues/1536)
			if (this.previousConfiguredZoomLevel === newZoomLevel) {
				return;
257
			}
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282

			this.previousConfiguredZoomLevel = newZoomLevel;
		}

		if (webFrame.getZoomLevel() !== newZoomLevel) {
			webFrame.setZoomLevel(newZoomLevel);
			browser.setZoomFactor(webFrame.getZoomFactor());
			// See https://github.com/Microsoft/vscode/issues/26151
			// Cannot be trusted because the webFrame might take some time
			// until it really applies the new zoom level
			browser.setZoomLevel(webFrame.getZoomLevel(), /*isTrusted*/false);
		}
	}

	private create(): void {

		// Handle window.open() calls
		const $this = this;
		(<any>window).open = function (url: string, target: string, features: string, replace: boolean): any {
			$this.windowsService.openExternal(url);

			return null;
		};

		// Emit event when vscode has loaded
283
		this.lifecycleService.when(LifecyclePhase.Running).then(() => {
284 285 286
			ipc.send('vscode:workbenchLoaded', this.windowService.getCurrentWindowId());
		});

287 288 289 290 291 292 293 294 295
		// Integrity warning
		this.integrityService.isPure().then(res => this.titleService.updateProperties({ isPure: res.isPure }));

		// Root warning
		this.lifecycleService.when(LifecyclePhase.Running).then(() => {
			let isAdminPromise: Promise<boolean>;
			if (isWindows) {
				isAdminPromise = import('native-is-elevated').then(isElevated => isElevated());
			} else {
A
Alex Dima 已提交
296
				isAdminPromise = Promise.resolve(isRootUser());
297 298 299 300 301 302 303
			}

			return isAdminPromise.then(isAdmin => {

				// Update title
				this.titleService.updateProperties({ isAdmin });

304 305
				// Show warning message (unix only)
				if (isAdmin && !isWindows) {
306
					this.notificationService.warn(nls.localize('runningAsRoot', "It is not recommended to run {0} as root user.", product.nameShort));
307 308 309
				}
			});
		});
310 311 312

		// Touchbar menu (if enabled)
		this.updateTouchbarMenu();
313 314 315
	}

	private updateTouchbarMenu(): void {
316 317 318 319 320
		if (
			!isMacintosh || // macOS only
			!this.configurationService.getValue<boolean>('keyboard.touchbar.enabled') // disabled via setting
		) {
			return;
321 322
		}

323 324
		// Dispose old
		this.touchBarDisposables = dispose(this.touchBarDisposables);
325
		this.touchBarMenu = void 0;
326

327 328 329 330
		// Create new (delayed)
		this.touchBarUpdater = new RunOnceScheduler(() => this.doUpdateTouchbarMenu(), 300);
		this.touchBarDisposables.push(this.touchBarUpdater);
		this.touchBarUpdater.schedule();
331 332
	}

333 334 335 336 337 338 339
	private doUpdateTouchbarMenu(): void {
		if (!this.touchBarMenu) {
			this.touchBarMenu = this.editorService.invokeWithinEditorContext(accessor => this.menuService.createMenu(MenuId.TouchBarContext, accessor.get(IContextKeyService)));
			this.touchBarDisposables.push(this.touchBarMenu);
			this.touchBarDisposables.push(this.touchBarMenu.onDidChange(() => this.touchBarUpdater.schedule()));
		}

340 341 342
		const actions: (MenuItemAction | Separator)[] = [];

		// Fill actions into groups respecting order
343
		fillInActionBarActions(this.touchBarMenu, void 0, actions);
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359

		// Convert into command action multi array
		const items: ICommandAction[][] = [];
		let group: ICommandAction[] = [];
		for (let i = 0; i < actions.length; i++) {
			const action = actions[i];

			// Command
			if (action instanceof MenuItemAction) {
				group.push(action.item);
			}

			// Separator
			else if (action instanceof Separator) {
				if (group.length) {
					items.push(group);
360
				}
361 362

				group = [];
363
			}
364 365 366 367 368 369 370 371 372 373 374
		}

		if (group.length) {
			items.push(group);
		}

		// Only update if the actions have changed
		if (!objects.equals(this.lastInstalledTouchedBar, items)) {
			this.lastInstalledTouchedBar = items;
			this.windowService.updateTouchBar(items);
		}
375 376
	}

S
SteVen Batten 已提交
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	private resolveKeybindings(actionIds: string[]): TPromise<{ id: string; label: string, isNative: boolean; }[]> {
		return TPromise.join([this.lifecycleService.when(LifecyclePhase.Running), this.extensionService.whenInstalledExtensionsRegistered()]).then(() => {
			return arrays.coalesce(actionIds.map(id => {
				const binding = this.keybindingService.lookupKeybinding(id);
				if (!binding) {
					return null;
				}
				// first try to resolve a native accelerator
				const electronAccelerator = binding.getElectronAccelerator();
				if (electronAccelerator) {
					return { id, label: electronAccelerator, isNative: true };
				}
				// we need this fallback to support keybindings that cannot show in electron menus (e.g. chords)
				const acceleratorLabel = binding.getLabel();
				if (acceleratorLabel) {
					return { id, label: acceleratorLabel, isNative: false };
				}
				return null;
			}));
		});
	}

399 400 401
	private onAddFoldersRequest(request: IAddFoldersRequest): void {

		// Buffer all pending requests
402
		this.pendingFoldersToAdd.push(...request.foldersToAdd.map(f => URI.revive(f)));
403 404 405 406 407 408 409 410 411 412

		// Delay the adding of folders a bit to buffer in case more requests are coming
		if (!this.addFoldersScheduler.isScheduled()) {
			this.addFoldersScheduler.schedule();
		}
	}

	private doAddFolders(): void {
		const foldersToAdd: IWorkspaceFolderCreationData[] = [];

413 414
		this.pendingFoldersToAdd.forEach(folder => {
			foldersToAdd.push(({ uri: folder }));
415 416 417
		});

		this.pendingFoldersToAdd = [];
418

419
		this.workspaceEditingService.addFolders(foldersToAdd);
420 421
	}

422
	private onOpenFiles(request: IOpenFileRequest): void {
B
Benjamin Pasero 已提交
423
		const inputs: IResourceEditor[] = [];
424
		const diffMode = request.filesToDiff && (request.filesToDiff.length === 2);
425 426 427 428 429 430 431 432 433 434 435 436 437 438

		if (!diffMode && request.filesToOpen) {
			inputs.push(...this.toInputs(request.filesToOpen, false));
		}

		if (!diffMode && request.filesToCreate) {
			inputs.push(...this.toInputs(request.filesToCreate, true));
		}

		if (diffMode) {
			inputs.push(...this.toInputs(request.filesToDiff, false));
		}

		if (inputs.length) {
439
			this.openResources(inputs, diffMode).then(null, errors.onUnexpectedError);
440
		}
441 442 443 444 445

		if (request.filesToWait && inputs.length) {
			// In wait mode, listen to changes to the editors and wait until the files
			// are closed that the user wants to wait for. When this happens we delete
			// the wait marker file to signal to the outside that editing is done.
M
Martin Aeschlimann 已提交
446
			const resourcesToWaitFor = request.filesToWait.paths.map(p => URI.revive(p.fileUri));
447
			const waitMarkerFile = URI.file(request.filesToWait.waitMarkerFilePath);
B
Benjamin Pasero 已提交
448 449
			const unbind = this.editorService.onDidCloseEditor(() => {
				if (resourcesToWaitFor.every(resource => !this.editorService.isOpen({ resource }))) {
450
					unbind.dispose();
451
					this.fileService.del(waitMarkerFile);
452 453 454
				}
			});
		}
455 456
	}

B
Benjamin Pasero 已提交
457 458
	private openResources(resources: (IResourceInput | IUntitledResourceInput)[], diffMode: boolean): Thenable<any> {
		return this.lifecycleService.when(LifecyclePhase.Running).then((): TPromise<any> => {
N
Nick Snyder 已提交
459

460
			// In diffMode we open 2 resources as diff
461
			if (diffMode && resources.length === 2) {
462
				return this.editorService.openEditor({ leftResource: resources[0].resource, rightResource: resources[1].resource, options: { pinned: true } });
463 464 465 466 467 468 469 470
			}

			// For one file, just put it into the current active editor
			if (resources.length === 1) {
				return this.editorService.openEditor(resources[0]);
			}

			// Otherwise open all
B
Benjamin Pasero 已提交
471
			return this.editorService.openEditors(resources);
472 473 474
		});
	}

M
Martin Aeschlimann 已提交
475
	private toInputs(paths: IPathData[], isNew: boolean): IResourceEditor[] {
476
		return paths.map(p => {
M
Martin Aeschlimann 已提交
477
			const resource = URI.revive(p.fileUri);
478 479 480 481 482 483
			let input: IResourceInput | IUntitledResourceInput;
			if (isNew) {
				input = { filePath: resource.fsPath, options: { pinned: true } } as IUntitledResourceInput;
			} else {
				input = { resource, options: { pinned: true } } as IResourceInput;
			}
484 485 486 487 488 489 490 491 492 493 494 495

			if (!isNew && p.lineNumber) {
				input.options.selection = {
					startLineNumber: p.lineNumber,
					startColumn: p.columnNumber
				};
			}

			return input;
		});
	}

B
Benjamin Pasero 已提交
496
	dispose(): void {
497 498 499 500
		this.touchBarDisposables = dispose(this.touchBarDisposables);

		super.dispose();
	}
J
Johannes Rieken 已提交
501
}