Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f (#7282)

* Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f

* fix various icon issues

* fix preview features

src/vs/workbench/services/dialogs/browser/dialogService.ts

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as nls from 'vs/nls';
+import { IDialogService, IDialogOptions, IConfirmation, IConfirmationResult, DialogType, IShowResult } from 'vs/platform/dialogs/common/dialogs';
+import { ILayoutService } from 'vs/platform/layout/browser/layoutService';
+import { ILogService } from 'vs/platform/log/common/log';
+import Severity from 'vs/base/common/severity';
+import { Dialog } from 'vs/base/browser/ui/dialog/dialog';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+import { attachDialogStyler } from 'vs/platform/theme/common/styler';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
+import { EventHelper } from 'vs/base/browser/dom';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+
+export class DialogService implements IDialogService {
+
+	_serviceBrand: undefined;
+
+	private allowableCommands = ['copy', 'cut'];
+
+	constructor(
+		@ILogService private readonly logService: ILogService,
+		@ILayoutService private readonly layoutService: ILayoutService,
+		@IThemeService private readonly themeService: IThemeService,
+		@IKeybindingService private readonly keybindingService: IKeybindingService,
+		@IProductService private readonly productService: IProductService,
+		@IClipboardService private readonly clipboardService: IClipboardService
+	) { }
+
+	async confirm(confirmation: IConfirmation): Promise<IConfirmationResult> {
+		this.logService.trace('DialogService#confirm', confirmation.message);
+
+		const buttons: string[] = [];
+		if (confirmation.primaryButton) {
+			buttons.push(confirmation.primaryButton);
+		} else {
+			buttons.push(nls.localize({ key: 'yesButton', comment: ['&& denotes a mnemonic'] }, "&&Yes"));
+		}
+
+		if (confirmation.secondaryButton) {
+			buttons.push(confirmation.secondaryButton);
+		} else if (typeof confirmation.secondaryButton === 'undefined') {
+			buttons.push(nls.localize('cancelButton', "Cancel"));
+		}
+
+		const dialogDisposables = new DisposableStore();
+		const dialog = new Dialog(
+			this.layoutService.container,
+			confirmation.message,
+			buttons,
+			{
+				detail: confirmation.detail,
+				cancelId: 1,
+				type: confirmation.type,
+				keyEventProcessor: (event: StandardKeyboardEvent) => {
+					const resolved = this.keybindingService.softDispatch(event, this.layoutService.container);
+					if (resolved && resolved.commandId) {
+						if (this.allowableCommands.indexOf(resolved.commandId) === -1) {
+							EventHelper.stop(event, true);
+						}
+					}
+				},
+				checkboxChecked: confirmation.checkbox ? confirmation.checkbox.checked : undefined,
+				checkboxLabel: confirmation.checkbox ? confirmation.checkbox.label : undefined
+			});
+
+		dialogDisposables.add(dialog);
+		dialogDisposables.add(attachDialogStyler(dialog, this.themeService));
+
+		const result = await dialog.show();
+		dialogDisposables.dispose();
+
+		return { confirmed: result.button === 0, checkboxChecked: result.checkboxChecked };
+	}
+
+	private getDialogType(severity: Severity): DialogType {
+		return (severity === Severity.Info) ? 'question' : (severity === Severity.Error) ? 'error' : (severity === Severity.Warning) ? 'warning' : 'none';
+	}
+
+	async show(severity: Severity, message: string, buttons: string[], options?: IDialogOptions): Promise<IShowResult> {
+		this.logService.trace('DialogService#show', message);
+
+		const dialogDisposables = new DisposableStore();
+		const dialog = new Dialog(
+			this.layoutService.container,
+			message,
+			buttons,
+			{
+				detail: options ? options.detail : undefined,
+				cancelId: options ? options.cancelId : undefined,
+				type: this.getDialogType(severity),
+				keyEventProcessor: (event: StandardKeyboardEvent) => {
+					const resolved = this.keybindingService.softDispatch(event, this.layoutService.container);
+					if (resolved && resolved.commandId) {
+						if (this.allowableCommands.indexOf(resolved.commandId) === -1) {
+							EventHelper.stop(event, true);
+						}
+					}
+				},
+				checkboxLabel: options && options.checkbox ? options.checkbox.label : undefined,
+				checkboxChecked: options && options.checkbox ? options.checkbox.checked : undefined
+			});
+
+		dialogDisposables.add(dialog);
+		dialogDisposables.add(attachDialogStyler(dialog, this.themeService));
+
+		const result = await dialog.show();
+		dialogDisposables.dispose();
+
+		return {
+			choice: result.button,
+			checkboxChecked: result.checkboxChecked
+		};
+	}
+
+	async about(): Promise<void> {
+		const detail = nls.localize('aboutDetail',
+			"Version: {0}\nCommit: {1}\nDate: {2}\nBrowser: {3}",
+			this.productService.version || 'Unknown',
+			this.productService.commit || 'Unknown',
+			this.productService.date || 'Unknown',
+			navigator.userAgent
+		);
+
+		const { choice } = await this.show(Severity.Info, this.productService.nameLong, [nls.localize('copy', "Copy"), nls.localize('ok', "OK")], { detail });
+
+		if (choice === 0) {
+			this.clipboardService.writeText(detail);
+		}
+	}
+}
+
+registerSingleton(IDialogService, DialogService, true);

src/vs/workbench/services/dialogs/browser/remoteFileDialog.ts

@@ -23,7 +23,6 @@ import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/
 import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
 import { IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { equalsIgnoreCase, format, startsWithIgnoreCase } from 'vs/base/common/strings';
-import { OpenLocalFileCommand, OpenLocalFileFolderCommand, OpenLocalFolderCommand, SaveLocalFileCommand } from 'vs/workbench/browser/actions/workspaceActions';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 import { isValidBasename } from 'vs/base/common/extpath';
@@ -32,6 +31,60 @@ import { Emitter } from 'vs/base/common/event';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { createCancelablePromise, CancelablePromise } from 'vs/base/common/async';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { ICommandHandler } from 'vs/platform/commands/common/commands';
+import { ITextFileService, ISaveOptions } from 'vs/workbench/services/textfile/common/textfiles';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { toResource } from 'vs/workbench/common/editor';
+
+export namespace OpenLocalFileCommand {
+	export const ID = 'workbench.action.files.openLocalFile';
+	export const LABEL = nls.localize('openLocalFile', "Open Local File...");
+	export function handler(): ICommandHandler {
+		return accessor => {
+			const dialogService = accessor.get(IFileDialogService);
+			return dialogService.pickFileAndOpen({ forceNewWindow: false, availableFileSystems: [Schemas.file] });
+		};
+	}
+}
+
+export namespace SaveLocalFileCommand {
+	export const ID = 'workbench.action.files.saveLocalFile';
+	export const LABEL = nls.localize('saveLocalFile', "Save Local File...");
+	export function handler(): ICommandHandler {
+		return accessor => {
+			const textFileService = accessor.get(ITextFileService);
+			const editorService = accessor.get(IEditorService);
+			let resource: URI | undefined = toResource(editorService.activeEditor);
+			const options: ISaveOptions = { force: true, availableFileSystems: [Schemas.file] };
+			if (resource) {
+				return textFileService.saveAs(resource, undefined, options);
+			}
+			return Promise.resolve(undefined);
+		};
+	}
+}
+
+export namespace OpenLocalFolderCommand {
+	export const ID = 'workbench.action.files.openLocalFolder';
+	export const LABEL = nls.localize('openLocalFolder', "Open Local Folder...");
+	export function handler(): ICommandHandler {
+		return accessor => {
+			const dialogService = accessor.get(IFileDialogService);
+			return dialogService.pickFolderAndOpen({ forceNewWindow: false, availableFileSystems: [Schemas.file] });
+		};
+	}
+}
+
+export namespace OpenLocalFileFolderCommand {
+	export const ID = 'workbench.action.files.openLocalFileFolder';
+	export const LABEL = nls.localize('openLocalFileFolder', "Open Local...");
+	export function handler(): ICommandHandler {
+		return accessor => {
+			const dialogService = accessor.get(IFileDialogService);
+			return dialogService.pickFileFolderAndOpen({ forceNewWindow: false, availableFileSystems: [Schemas.file] });
+		};
+	}
+}
 
 interface FileQuickPickItem extends IQuickPickItem {
 	uri: URI;

src/vs/workbench/services/dialogs/electron-browser/dialogService.ts

@@ -4,21 +4,25 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as nls from 'vs/nls';
-import product from 'vs/platform/product/node/product';
+import * as os from 'os';
+import product from 'vs/platform/product/common/product';
 import Severity from 'vs/base/common/severity';
 import { isLinux, isWindows } from 'vs/base/common/platform';
 import { IWindowService } from 'vs/platform/windows/common/windows';
 import { mnemonicButtonLabel } from 'vs/base/common/labels';
 import { IDialogService, IConfirmation, IConfirmationResult, IDialogOptions, IShowResult } from 'vs/platform/dialogs/common/dialogs';
-import { DialogService as HTMLDialogService } from 'vs/platform/dialogs/browser/dialogService';
+import { DialogService as HTMLDialogService } from 'vs/workbench/services/dialogs/browser/dialogService';
 import { ILogService } from 'vs/platform/log/common/log';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
-import { DialogChannel } from 'vs/platform/dialogs/node/dialogIpc';
+import { DialogChannel } from 'vs/platform/dialogs/electron-browser/dialogIpc';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { ILayoutService } from 'vs/platform/layout/browser/layoutService';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { IProductService } from 'vs/platform/product/common/productService';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { IElectronService } from 'vs/platform/electron/node/electron';
 
 interface IMassagedMessageBoxOptions {
 
@@ -36,6 +40,7 @@ interface IMassagedMessageBoxOptions {
 }
 
 export class DialogService implements IDialogService {
+
 	_serviceBrand: undefined;
 
 	private impl: IDialogService;
@@ -47,25 +52,33 @@ export class DialogService implements IDialogService {
 		@IThemeService themeService: IThemeService,
 		@IWindowService windowService: IWindowService,
 		@ISharedProcessService sharedProcessService: ISharedProcessService,
-		@IKeybindingService keybindingService: IKeybindingService
+		@IKeybindingService keybindingService: IKeybindingService,
+		@IProductService productService: IProductService,
+		@IClipboardService clipboardService: IClipboardService,
+		@IElectronService electronService: IElectronService
 	) {
 
 		// Use HTML based dialogs
 		if (configurationService.getValue('workbench.dialogs.customEnabled') === true) {
-			this.impl = new HTMLDialogService(logService, layoutService, themeService, keybindingService);
+			this.impl = new HTMLDialogService(logService, layoutService, themeService, keybindingService, productService, clipboardService);
 		}
 		// Electron dialog service
 		else {
-			this.impl = new NativeDialogService(windowService, logService, sharedProcessService);
+			this.impl = new NativeDialogService(windowService, logService, sharedProcessService, electronService, clipboardService);
 		}
 	}
 
 	confirm(confirmation: IConfirmation): Promise<IConfirmationResult> {
 		return this.impl.confirm(confirmation);
 	}
+
 	show(severity: Severity, message: string, buttons: string[], options?: IDialogOptions | undefined): Promise<IShowResult> {
 		return this.impl.show(severity, message, buttons, options);
 	}
+
+	about(): Promise<void> {
+		return this.impl.about();
+	}
 }
 
 class NativeDialogService implements IDialogService {
@@ -75,7 +88,9 @@ class NativeDialogService implements IDialogService {
 	constructor(
 		@IWindowService private readonly windowService: IWindowService,
 		@ILogService private readonly logService: ILogService,
-		@ISharedProcessService sharedProcessService: ISharedProcessService
+		@ISharedProcessService sharedProcessService: ISharedProcessService,
+		@IElectronService private readonly electronService: IElectronService,
+		@IClipboardService private readonly clipboardService: IClipboardService
 	) {
 		sharedProcessService.registerChannel('dialog', new DialogChannel(this));
 	}
@@ -189,6 +204,51 @@ class NativeDialogService implements IDialogService {
 
 		return { options, buttonIndexMap };
 	}
+
+	async about(): Promise<void> {
+		let version = product.version;
+		if (product.target) {
+			version = `${version} (${product.target} setup)`;
+		}
+
+		const isSnap = process.platform === 'linux' && process.env.SNAP && process.env.SNAP_REVISION;
+		const detail = nls.localize('aboutDetail', // {{SQL CARBON EDIT}} update about dialog
+			"Version: {0}\nCommit: {1}\nDate: {2}\nVS Code: {8}\nElectron: {3}\nChrome: {4}\nNode.js: {5}\nV8: {6}\nOS: {7}",
+			version,
+			product.commit || 'Unknown',
+			product.date || 'Unknown',
+			process.versions['electron'],
+			process.versions['chrome'],
+			process.versions['node'],
+			process.versions['v8'],
+			`${os.type()} ${os.arch()} ${os.release()}${isSnap ? ' snap' : ''}`,
+			product.vscodeVersion
+		);
+
+		const ok = nls.localize('okButton', "OK");
+		const copy = mnemonicButtonLabel(nls.localize({ key: 'copy', comment: ['&& denotes a mnemonic'] }, "&&Copy"));
+		let buttons: string[];
+		if (isLinux) {
+			buttons = [copy, ok];
+		} else {
+			buttons = [ok, copy];
+		}
+
+		const result = await this.electronService.showMessageBox({
+			title: product.nameLong,
+			type: 'info',
+			message: product.nameLong,
+			detail: `\n${detail}`,
+			buttons,
+			noLink: true,
+			defaultId: buttons.indexOf(ok),
+			cancelId: buttons.indexOf(ok)
+		});
+
+		if (buttons[result.response] === copy) {
+			this.clipboardService.writeText(detail);
+		}
+	}
 }
 
 registerSingleton(IDialogService, DialogService, true);