development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-09-18 01:58:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

window - reduce to one property for opened workspace

Browse source
This commit is contained in:
Benjamin Pasero 2021-01-21 09:47:38 +01:00
parent acaed31726
commit c8ce53e492
12 changed files with 35 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/vs/code/electron-main/window.ts
View file

@ -362,9 +362,7 @@ export class CodeWindow extends Disposable implements ICodeWindow {
get backupPath(): string | undefined { return this.currentConfig?.backupPath; }
get openedWorkspace(): IWorkspaceIdentifier | undefined { return this.currentConfig?.workspace; }
get openedFolderUri(): ISingleFolderWorkspaceIdentifier | undefined { return this.currentConfig?.folderUri; }
get openedWorkspace(): IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | undefined { return this.currentConfig?.workspace ?? this.currentConfig?.folderUri; }
get remoteAuthority(): string | undefined { return this.currentConfig?.remoteAuthority; }

10
src/vs/platform/launch/electron-main/launchMainService.ts
View file

@ -20,6 +20,7 @@ import { IDiagnosticInfoOptions, IDiagnosticInfo, IRemoteDiagnosticInfo, IRemote
import { IMainProcessInfo, IWindowInfo } from 'vs/platform/launch/node/launch';
import { isLaunchedFromCli } from 'vs/platform/environment/node/argvHelper';
import { CancellationToken } from 'vs/base/common/cancellation';
import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
export const ID = 'launchMainService';
export const ILaunchMainService = createDecorator<ILaunchMainService>(ID);
@ -272,11 +273,12 @@ export class LaunchMainService implements ILaunchMainService {
private getFolderURIs(window: ICodeWindow): URI[] {
const folderURIs: URI[] = [];
if (window.openedFolderUri) {
folderURIs.push(window.openedFolderUri.uri);
} else if (window.openedWorkspace) {
const workspace = window.openedWorkspace;
if (isSingleFolderWorkspaceIdentifier(workspace)) {
folderURIs.push(workspace.uri);
} else if (isWorkspaceIdentifier(workspace)) {
// workspace folders can only be shown for local workspaces
const workspaceConfigPath = window.openedWorkspace.configPath;
const workspaceConfigPath = workspace.configPath;
const resolvedWorkspace = this.workspacesMainService.resolveLocalWorkspaceSync(workspaceConfigPath);
if (resolvedWorkspace) {
const rootFolders = resolvedWorkspace.folders;

1
src/vs/platform/native/electron-main/nativeHostMainService.ts
View file

@ -105,7 +105,6 @@ export class NativeHostMainService extends Disposable implements INativeHostMain
return windows.map(window => ({
id: window.id,
workspace: window.openedWorkspace,
folderUri: window.openedFolderUri,
title: window.win.getTitle(),
filename: window.getRepresentedFilename(),
dirty: window.isDocumentEdited()

3
src/vs/platform/windows/common/windows.ts
View file

@ -41,8 +41,7 @@ export interface IAddFoldersRequest {
export interface IOpenedWindow {
readonly id: number;
readonly workspace?: IWorkspaceIdentifier;
readonly folderUri?: ISingleFolderWorkspaceIdentifier;
readonly workspace?: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier;
readonly title: string;
readonly filename?: string;
readonly dirty: boolean;

3
src/vs/platform/windows/electron-main/windows.ts
View file

@ -65,8 +65,7 @@ export interface ICodeWindow extends IDisposable {
readonly win: BrowserWindow;
readonly config: INativeWindowConfiguration | undefined;
readonly openedFolderUri?: ISingleFolderWorkspaceIdentifier;
readonly openedWorkspace?: IWorkspaceIdentifier;
readonly openedWorkspace?: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier;
readonly backupPath?: string;

12
src/vs/platform/windows/electron-main/windowsFinder.ts
View file

@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { URI } from 'vs/base/common/uri';
import { IWorkspaceIdentifier, IResolvedWorkspace } from 'vs/platform/workspaces/common/workspaces';
import { IWorkspaceIdentifier, IResolvedWorkspace, isWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { extUriBiasedIgnorePathCase } from 'vs/base/common/resources';
import { ICodeWindow } from 'vs/platform/windows/electron-main/windows';
@ -13,7 +13,7 @@ export function findWindowOnFile(windows: ICodeWindow[], fileUri: URI, localWork
// First check for windows with workspaces that have a parent folder of the provided path opened
for (const window of windows) {
const workspace = window.openedWorkspace;
if (workspace) {
if (isWorkspaceIdentifier(workspace)) {
const resolvedWorkspace = localWorkspaceResolver(workspace);
// resolved workspace: folders are known and can be compared with
@ -33,9 +33,9 @@ export function findWindowOnFile(windows: ICodeWindow[], fileUri: URI, localWork
}
// Then go with single folder windows that are parent of the provided file path
const singleFolderWindowsOnFilePath = windows.filter(window => window.openedFolderUri && extUriBiasedIgnorePathCase.isEqualOrParent(fileUri, window.openedFolderUri.uri));
const singleFolderWindowsOnFilePath = windows.filter(window => isSingleFolderWorkspaceIdentifier(window.openedWorkspace) && extUriBiasedIgnorePathCase.isEqualOrParent(fileUri, window.openedWorkspace.uri));
if (singleFolderWindowsOnFilePath.length) {
return singleFolderWindowsOnFilePath.sort((windowA, windowB) => -(windowA.openedFolderUri!.uri.path.length - windowB.openedFolderUri!.uri.path.length))[0];
return singleFolderWindowsOnFilePath.sort((windowA, windowB) => -((windowA.openedWorkspace as ISingleFolderWorkspaceIdentifier).uri.path.length - (windowB.openedWorkspace as ISingleFolderWorkspaceIdentifier).uri.path.length))[0];
}
return undefined;
@ -46,12 +46,12 @@ export function findWindowOnWorkspaceOrFolder(windows: ICodeWindow[], folderOrWo
for (const window of windows) {
// check for workspace config path
if (window.openedWorkspace && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.configPath, folderOrWorkspaceConfigUri)) {
if (isWorkspaceIdentifier(window.openedWorkspace) && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.configPath, folderOrWorkspaceConfigUri)) {
return window;
}
// check for folder path
if (window.openedFolderUri && extUriBiasedIgnorePathCase.isEqual(window.openedFolderUri.uri, folderOrWorkspaceConfigUri)) {
if (isSingleFolderWorkspaceIdentifier(window.openedWorkspace) && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.uri, folderOrWorkspaceConfigUri)) {
return window;
}
}

10
src/vs/platform/windows/electron-main/windowsMainService.ts
View file

@ -24,7 +24,7 @@ import product from 'vs/platform/product/common/product';
import { IWindowsMainService, IOpenConfiguration, IWindowsCountChangedEvent, ICodeWindow, IOpenEmptyConfiguration, OpenContext } from 'vs/platform/windows/electron-main/windows';
import { IWorkspacesHistoryMainService } from 'vs/platform/workspaces/electron-main/workspacesHistoryMainService';
import { IProcessEnvironment, isMacintosh } from 'vs/base/common/platform';
import { IWorkspaceIdentifier, hasWorkspaceFileExtension, IRecent } from 'vs/platform/workspaces/common/workspaces';
import { IWorkspaceIdentifier, hasWorkspaceFileExtension, IRecent, isWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { Schemas } from 'vs/base/common/network';
import { URI } from 'vs/base/common/uri';
@ -417,13 +417,13 @@ export class WindowsMainService extends Disposable implements IWindowsMainServic
if (windowToUseForFiles) {
// Window is workspace
if (windowToUseForFiles.openedWorkspace) {
if (isWorkspaceIdentifier(windowToUseForFiles.openedWorkspace)) {
workspacesToOpen.push({ workspace: windowToUseForFiles.openedWorkspace, remoteAuthority: windowToUseForFiles.remoteAuthority });
}
// Window is single folder
else if (windowToUseForFiles.openedFolderUri) {
foldersToOpen.push({ folderUri: windowToUseForFiles.openedFolderUri.uri, remoteAuthority: windowToUseForFiles.remoteAuthority });
else if (isSingleFolderWorkspaceIdentifier(windowToUseForFiles.openedWorkspace)) {
foldersToOpen.push({ folderUri: windowToUseForFiles.openedWorkspace.uri, remoteAuthority: windowToUseForFiles.remoteAuthority });
}
// Window is empty
@ -497,7 +497,7 @@ export class WindowsMainService extends Disposable implements IWindowsMainServic
// Open remaining ones
allFoldersToOpen.forEach(folderToOpen => {
if (windowsOnFolderPath.some(window => extUriBiasedIgnorePathCase.isEqual(window.openedFolderUri?.uri, folderToOpen.folderUri))) {
if (windowsOnFolderPath.some(window => isSingleFolderWorkspaceIdentifier(window.openedWorkspace) && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.uri, folderToOpen.folderUri))) {
return; // ignore folders that are already open
}

12
src/vs/platform/windows/electron-main/windowsStateHandler.ts
View file

@ -15,7 +15,7 @@ import { ILogService } from 'vs/platform/log/common/log';
import { IStateService } from 'vs/platform/state/node/state';
import { INativeWindowConfiguration, IWindowSettings } from 'vs/platform/windows/common/windows';
import { ICodeWindow, IWindowsMainService, IWindowState as IWindowUIState, WindowMode } from 'vs/platform/windows/electron-main/windows';
import { IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, IWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
export interface IWindowState {
workspace?: IWorkspaceIdentifier;
@ -198,10 +198,10 @@ export class WindowsStateHandler extends Disposable {
}
// Any non extension host window with same workspace or folder
else if (!window.isExtensionDevelopmentHost && (!!window.openedWorkspace || !!window.openedFolderUri)) {
else if (!window.isExtensionDevelopmentHost && window.openedWorkspace) {
this._state.openedWindows.forEach(openedWindow => {
const sameWorkspace = window.openedWorkspace && openedWindow.workspace && openedWindow.workspace.id === window.openedWorkspace.id;
const sameFolder = window.openedFolderUri && openedWindow.folderUri && extUriBiasedIgnorePathCase.isEqual(openedWindow.folderUri, window.openedFolderUri.uri);
const sameWorkspace = isWorkspaceIdentifier(window.openedWorkspace) && isWorkspaceIdentifier(openedWindow.workspace) && openedWindow.workspace.id === window.openedWorkspace.id;
const sameFolder = isSingleFolderWorkspaceIdentifier(window.openedWorkspace) && openedWindow.folderUri && extUriBiasedIgnorePathCase.isEqual(openedWindow.folderUri, window.openedWorkspace.uri);
if (sameWorkspace || sameFolder) {
openedWindow.uiState = state.uiState;
@ -220,8 +220,8 @@ export class WindowsStateHandler extends Disposable {
private toWindowState(window: ICodeWindow): IWindowState {
return {
workspace: window.openedWorkspace,
folderUri: window.openedFolderUri?.uri,
workspace: isWorkspaceIdentifier(window.openedWorkspace) ? window.openedWorkspace : undefined,
folderUri: isSingleFolderWorkspaceIdentifier(window.openedWorkspace) ? window.openedWorkspace.uri : undefined,
backupPath: window.backupPath,
remoteAuthority: window.remoteAuthority,
uiState: window.serializeWindowState()

3
src/vs/platform/windows/test/electron-main/window.test.ts
View file

@ -39,8 +39,7 @@ function createTestCodeWindow(options: { lastFocusTime: number, openedFolderUri?
id: number = -1;
win: Electron.BrowserWindow = undefined!;
config: INativeWindowConfiguration | undefined;
openedFolderUri = options.openedFolderUri ? { id: '', uri: options.openedFolderUri } : undefined;
openedWorkspace = options.openedWorkspace;
openedWorkspace = options.openedFolderUri ? { id: '', uri: options.openedFolderUri } : options.openedWorkspace;
backupPath?: string | undefined;
remoteAuthority?: string | undefined;
isExtensionDevelopmentHost = false;

6
src/vs/platform/workspaces/electron-main/workspacesMainService.ts
View file

@ -3,7 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IWorkspaceIdentifier, hasWorkspaceFileExtension, UNTITLED_WORKSPACE_NAME, IResolvedWorkspace, IStoredWorkspaceFolder, isStoredWorkspaceFolder, IWorkspaceFolderCreationData, IUntitledWorkspaceInfo, getStoredWorkspaceFolder, IEnterWorkspaceResult, isUntitledWorkspace } from 'vs/platform/workspaces/common/workspaces';
import { IWorkspaceIdentifier, hasWorkspaceFileExtension, UNTITLED_WORKSPACE_NAME, IResolvedWorkspace, IStoredWorkspaceFolder, isStoredWorkspaceFolder, IWorkspaceFolderCreationData, IUntitledWorkspaceInfo, getStoredWorkspaceFolder, IEnterWorkspaceResult, isUntitledWorkspace, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
import { join, dirname } from 'vs/base/common/path';
import { mkdirp, writeFile, rimrafSync, readdirSync, writeFileSync } from 'vs/base/node/pfs';
@ -271,7 +271,7 @@ export class WorkspacesMainService extends Disposable implements IWorkspacesMain
return true;
}
if (window.openedWorkspace && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.configPath, workspacePath)) {
if (isWorkspaceIdentifier(window.openedWorkspace) && extUriBiasedIgnorePathCase.isEqual(window.openedWorkspace.configPath, workspacePath)) {
return false; // window is already opened on a workspace with that path
}
@ -308,7 +308,7 @@ export class WorkspacesMainService extends Disposable implements IWorkspacesMain
}
// if the window was opened on an untitled workspace, delete it.
if (window.openedWorkspace && this.isUntitledWorkspace(window.openedWorkspace)) {
if (isWorkspaceIdentifier(window.openedWorkspace) && this.isUntitledWorkspace(window.openedWorkspace)) {
this.deleteUntitledWorkspaceSync(window.openedWorkspace);
}

5
src/vs/workbench/electron-sandbox/actions/windowActions.ts
View file

@ -20,6 +20,7 @@ import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
import { Codicon } from 'vs/base/common/codicons';
import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
export class CloseCurrentWindowAction extends Action {
@ -154,8 +155,8 @@ export abstract class BaseSwitchWindow extends Action {
const windows = await this.nativeHostService.getWindows();
const placeHolder = nls.localize('switchWindowPlaceHolder', "Select a window to switch to");
const picks = windows.map(window => {
const resource = window.filename ? URI.file(window.filename) : window.folderUri ? window.folderUri.uri : window.workspace ? window.workspace.configPath : undefined;
const fileKind = window.filename ? FileKind.FILE : window.workspace ? FileKind.ROOT_FOLDER : window.folderUri ? FileKind.FOLDER : FileKind.FILE;
const resource = window.filename ? URI.file(window.filename) : isSingleFolderWorkspaceIdentifier(window.workspace) ? window.workspace.uri : isWorkspaceIdentifier(window.workspace) ? window.workspace.configPath : undefined;
const fileKind = window.filename ? FileKind.FILE : isSingleFolderWorkspaceIdentifier(window.workspace) ? FileKind.FILE : isWorkspaceIdentifier(window.workspace) ? FileKind.ROOT_FOLDER : FileKind.FILE;
return {
payload: window.id,
label: window.title,

4
src/vs/workbench/services/workspaces/electron-sandbox/workspaceEditingService.ts
View file

@ -8,7 +8,7 @@ import { IWorkspaceEditingService } from 'vs/workbench/services/workspaces/commo
import { URI } from 'vs/base/common/uri';
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
import { IJSONEditingService } from 'vs/workbench/services/configuration/common/jsonEditing';
import { IWorkspacesService, isUntitledWorkspace, IWorkspaceIdentifier, hasWorkspaceFileExtension } from 'vs/platform/workspaces/common/workspaces';
import { IWorkspacesService, isUntitledWorkspace, IWorkspaceIdentifier, hasWorkspaceFileExtension, isWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { WorkspaceService } from 'vs/workbench/services/configuration/browser/configurationService';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
@ -144,7 +144,7 @@ export class NativeWorkspaceEditingService extends AbstractWorkspaceEditingServi
const windows = await this.nativeHostService.getWindows();
// Prevent overwriting a workspace that is currently opened in another window
if (windows.some(window => !!window.workspace && this.uriIdentityService.extUri.isEqual(window.workspace.configPath, path))) {
if (windows.some(window => isWorkspaceIdentifier(window.workspace) && this.uriIdentityService.extUri.isEqual(window.workspace.configPath, path))) {
await this.dialogService.show(
Severity.Info,
localize('workspaceOpenedMessage', "Unable to save workspace '{0}'", basename(path)),