ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-05 01:25:38 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f (#7282)

Browse Source 
* Merge from vscode 1eb87b0e9ce9886afeaecec22b31abd0d9b7939f

* fix various icon issues

* fix preview features
This commit is contained in:
Anthony Dresser
2019-09-19 21:50:52 -07:00
committed by GitHub
parent 9d3d64eef3
commit db498db0a8
459 changed files with 10195 additions and 7528 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/vs/platform/windows/common/windows.ts
View File

@@ -155,9 +155,6 @@ export interface IWindowsService {
openNewWindow(options?: INewWindowOptions): Promise<void>;
openExtensionDevelopmentHostWindow(args: ParsedArgs, env: IProcessEnvironment): Promise<void>;
getWindows(): Promise<{ id: number; workspace?: IWorkspaceIdentifier; folderUri?: ISingleFolderWorkspaceIdentifier; title: string; filename?: string; }[]>;
getWindowCount(): Promise<number>;
log(severity: string, args: string[]): Promise<void>;
showItemInFolder(path: URI): Promise<void>;
getActiveWindowId(): Promise<number | undefined>;
// This needs to be handled from browser process to prevent
@@ -167,7 +164,6 @@ export interface IWindowsService {
// TODO: this is a bit backwards
startCrashReporter(config: CrashReporterStartOptions): Promise<void>;
openAboutDialog(): Promise<void>;
resolveProxy(windowId: number, url: string): Promise<string | undefined>;
}

4
src/vs/platform/windows/common/windowsIpc.ts
View File

@@ -104,17 +104,13 @@ export class WindowsChannel implements IServerChannel {
case 'openNewWindow': return this.service.openNewWindow(arg);
case 'openExtensionDevelopmentHostWindow': return this.service.openExtensionDevelopmentHostWindow(arg[0], arg[1]);
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(URI.revive(arg));
case 'getActiveWindowId': return this.service.getActiveWindowId();
case 'openExternal': return this.service.openExternal(arg);
case 'startCrashReporter': return this.service.startCrashReporter(arg);
case 'openAboutDialog': return this.service.openAboutDialog();
case 'resolveProxy': return this.service.resolveProxy(arg[0], arg[1]);
}

16
src/vs/platform/windows/electron-browser/windowsService.ts
View File

@@ -222,18 +222,6 @@ export class WindowsService implements IWindowsService {
return result;
}
getWindowCount(): Promise<number> {
return this.channel.call('getWindowCount');
}
log(severity: string, args: string[]): Promise<void> {
return this.channel.call('log', [severity, args]);
}
showItemInFolder(path: URI): Promise<void> {
return this.channel.call('showItemInFolder', path);
}
getActiveWindowId(): Promise<number | undefined> {
return this.channel.call('getActiveWindowId');
}
@@ -250,10 +238,6 @@ export class WindowsService implements IWindowsService {
return this.channel.call('updateTouchBar', [windowId, items]);
}
openAboutDialog(): Promise<void> {
return this.channel.call('openAboutDialog');
}
resolveProxy(windowId: number, url: string): Promise<string | undefined> {
return Promise.resolve(this.channel.call('resolveProxy', [windowId, url]));
}

103
src/vs/platform/windows/electron-main/windowsService.ts
View File

@@ -3,25 +3,22 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from 'vs/nls';
import * as os from 'os';
import { Disposable, DisposableStore } from 'vs/base/common/lifecycle';
import { assign } from 'vs/base/common/objects';
import { URI } from 'vs/base/common/uri';
import product from 'vs/platform/product/node/product';
import { IWindowsService, OpenContext, INativeOpenDialogOptions, IEnterWorkspaceResult, IMessageBoxResult, IDevToolsOptions, INewWindowOptions, IOpenSettings, IURIToOpen } from 'vs/platform/windows/common/windows';
import { IEnvironmentService, ParsedArgs } from 'vs/platform/environment/common/environment';
import { shell, crashReporter, app, Menu, clipboard } from 'electron';
import { shell, crashReporter, app, Menu } from 'electron';
import { Event } from 'vs/base/common/event';
import { IURLService, IURLHandler } from 'vs/platform/url/common/url';
import { ILifecycleService } from 'vs/platform/lifecycle/electron-main/lifecycleMain';
import { ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
import { IWindowsMainService, ISharedProcess, ICodeWindow } from 'vs/platform/windows/electron-main/windows';
import { IHistoryMainService, IRecentlyOpened, IRecent } from 'vs/platform/history/common/history';
import { IRecentlyOpened, IRecent } from 'vs/platform/history/common/history';
import { IHistoryMainService } from 'vs/platform/history/electron-main/historyMainService';
import { IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { ISerializableCommandAction } from 'vs/platform/actions/common/actions';
import { Schemas } from 'vs/base/common/network';
import { mnemonicButtonLabel } from 'vs/base/common/labels';
import { isMacintosh, isLinux, IProcessEnvironment } from 'vs/base/common/platform';
import { isMacintosh, IProcessEnvironment } from 'vs/base/common/platform';
import { ILogService } from 'vs/platform/log/common/log';
export class WindowsService extends Disposable implements IWindowsService, IURLHandler {
@@ -41,15 +38,15 @@ export class WindowsService extends Disposable implements IWindowsService, IURLH
Event.filter(Event.fromNodeEventEmitter(app, 'browser-window-focus', (_, w: Electron.BrowserWindow) => w.id), id => !!this.windowsMainService.getWindowById(id))
);
readonly onRecentlyOpenedChange: Event<void> = this.historyService.onRecentlyOpenedChange;
readonly onRecentlyOpenedChange: Event<void> = this.historyMainService.onRecentlyOpenedChange;
constructor(
private sharedProcess: ISharedProcess,
@IWindowsMainService private readonly windowsMainService: IWindowsMainService,
@IEnvironmentService private readonly environmentService: IEnvironmentService,
@IURLService urlService: IURLService,
@ILifecycleService private readonly lifecycleService: ILifecycleService,
@IHistoryMainService private readonly historyService: IHistoryMainService,
@ILifecycleMainService private readonly lifecycleMainService: ILifecycleMainService,
@IHistoryMainService private readonly historyMainService: IHistoryMainService,
@ILogService private readonly logService: ILogService
) {
super();
@@ -160,25 +157,25 @@ export class WindowsService extends Disposable implements IWindowsService, IURLH
async addRecentlyOpened(recents: IRecent[]): Promise<void> {
this.logService.trace('windowsService#addRecentlyOpened');
this.historyService.addRecentlyOpened(recents);
this.historyMainService.addRecentlyOpened(recents);
}
async removeFromRecentlyOpened(paths: URI[]): Promise<void> {
this.logService.trace('windowsService#removeFromRecentlyOpened');
this.historyService.removeFromRecentlyOpened(paths);
this.historyMainService.removeFromRecentlyOpened(paths);
}
async clearRecentlyOpened(): Promise<void> {
this.logService.trace('windowsService#clearRecentlyOpened');
this.historyService.clearRecentlyOpened();
this.historyMainService.clearRecentlyOpened();
}
async getRecentlyOpened(windowId: number): Promise<IRecentlyOpened> {
this.logService.trace('windowsService#getRecentlyOpened', windowId);
return this.withWindow(windowId, codeWindow => this.historyService.getRecentlyOpened(codeWindow.config.workspace, codeWindow.config.folderUri, codeWindow.config.filesToOpenOrCreate), () => this.historyService.getRecentlyOpened())!;
return this.withWindow(windowId, codeWindow => this.historyMainService.getRecentlyOpened(codeWindow.config.workspace, codeWindow.config.folderUri, codeWindow.config.filesToOpenOrCreate), () => this.historyMainService.getRecentlyOpened())!;
}
async newWindowTab(): Promise<void> {
@@ -339,32 +336,6 @@ export class WindowsService extends Disposable implements IWindowsService, IURLH
return this.windowsMainService.getWindows().length;
}
async log(severity: string, args: string[]): Promise<void> {
let consoleFn = console.log;
switch (severity) {
case 'error':
consoleFn = console.error;
break;
case 'warn':
consoleFn = console.warn;
break;
case 'info':
consoleFn = console.info;
break;
}
consoleFn.call(console, ...args);
}
async showItemInFolder(resource: URI): Promise<void> {
this.logService.trace('windowsService#showItemInFolder');
if (resource.scheme === Schemas.file) {
shell.showItemInFolder(resource.fsPath);
}
}
async getActiveWindowId(): Promise<number | undefined> {
return this._activeWindowId;
}
@@ -391,7 +362,7 @@ export class WindowsService extends Disposable implements IWindowsService, IURLH
async relaunch(options: { addArgs?: string[], removeArgs?: string[] }): Promise<void> {
this.logService.trace('windowsService#relaunch');
this.lifecycleService.relaunch(options);
this.lifecycleMainService.relaunch(options);
}
async whenSharedProcessReady(): Promise<void> {
@@ -407,54 +378,6 @@ export class WindowsService extends Disposable implements IWindowsService, IURLH
}
async openAboutDialog(): Promise<void> {
this.logService.trace('windowsService#openAboutDialog');
let version = app.getVersion();
if (product.target) {
version = `${version} (${product.target} setup)`;
}
const isSnap = process.platform === 'linux' && process.env.SNAP && process.env.SNAP_REVISION;
// {{SQL CARBON EDIT}}
const detail = nls.localize('aboutDetail',
"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.windowsMainService.showMessageBox({
title: product.nameLong,
type: 'info',
message: product.nameLong,
detail: `\n${detail}`,
buttons,
noLink: true,
defaultId: buttons.indexOf(ok),
cancelId: buttons.indexOf(ok)
}, this.windowsMainService.getFocusedWindow() || this.windowsMainService.getLastActiveWindow());
if (buttons[result.button] === copy) {
clipboard.writeText(detail);
}
}
async handleURL(uri: URI): Promise<boolean> {
// Catch file URLs