mirror of
https://github.com/Microsoft/vscode
synced 2024-09-18 01:58:27 +00:00
editors - require typeId for some methods that are otherwise unspecific
This commit is contained in:
Benjamin Pasero
parent
832a699c00
commit
e09f0ecfcf
|
|
@ -70,6 +70,23 @@ export interface IBaseResourceEditorInput {
|
|||
readonly forceUntitled?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* This identifier allows to uniquely identify an editor with a
|
||||
* resource and type identifier.
|
||||
*/
|
||||
export interface IResourceEditorInputIdentifier {
|
||||
|
||||
/**
|
||||
* The resource URI of the editor.
|
||||
*/
|
||||
readonly resource: URI;
|
||||
|
||||
/**
|
||||
* The type of the editor.
|
||||
*/
|
||||
readonly typeId: string;
|
||||
}
|
||||
|
||||
export interface IResourceEditorInput extends IBaseResourceEditorInput {
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { Registry } from 'vs/platform/registry/common/platform';
|
||||
import { hasWorkspaceFileExtension, IWorkspaceFolderCreationData, IRecentFile, IWorkspacesService } from 'vs/platform/workspaces/common/workspaces';
|
||||
import { normalize } from 'vs/base/common/path';
|
||||
import { basename, isEqual } from 'vs/base/common/resources';
|
||||
|
|
@ -20,7 +21,7 @@ import { MIME_BINARY } from 'vs/base/common/mime';
|
|||
import { isWindows } from 'vs/base/common/platform';
|
||||
import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
|
||||
import { isCodeEditor } from 'vs/editor/browser/editorBrowser';
|
||||
import { IEditorIdentifier, GroupIdentifier } from 'vs/workbench/common/editor';
|
||||
import { IEditorIdentifier, GroupIdentifier, IEditorInputFactoryRegistry, Extensions as EditorExtensions } from 'vs/workbench/common/editor';
|
||||
import { IEditorService, IResourceEditorInputType } from 'vs/workbench/services/editor/common/editorService';
|
||||
import { Disposable, IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
|
||||
import { addDisposableListener, EventType } from 'vs/base/browser/dom';
|
||||
|
|
@ -229,6 +230,7 @@ export class ResourcesDropHandler {
|
|||
}
|
||||
|
||||
private async handleDirtyEditorDrop(droppedDirtyEditor: IDraggedEditor): Promise<boolean> {
|
||||
const fileEditorFactory = Registry.as<IEditorInputFactoryRegistry>(EditorExtensions.EditorInputFactories).getFileEditorInputFactory();
|
||||
|
||||
// Untitled: always ensure that we open a new untitled editor for each file we drop
|
||||
if (droppedDirtyEditor.resource.scheme === Schemas.untitled) {
|
||||
|
|
@ -239,7 +241,7 @@ export class ResourcesDropHandler {
|
|||
}
|
||||
|
||||
// File: ensure the file is not dirty or opened already
|
||||
else if (this.textFileService.isDirty(droppedDirtyEditor.resource) || this.editorService.isOpen({ resource: droppedDirtyEditor.resource })) {
|
||||
else if (this.textFileService.isDirty(droppedDirtyEditor.resource) || this.editorService.isOpened({ resource: droppedDirtyEditor.resource, typeId: fileEditorFactory.typeId })) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -822,10 +822,6 @@ export class EditorGroupView extends Themable implements IEditorGroupView {
|
|||
return this.model.indexOf(editor);
|
||||
}
|
||||
|
||||
isOpened(editor: EditorInput): boolean {
|
||||
return this.model.contains(editor);
|
||||
}
|
||||
|
||||
focus(): void {
|
||||
|
||||
// Pass focus to editor panes
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ export abstract class BaseEditorQuickAccessProvider extends PickerQuickAccessPro
|
|||
if (group) {
|
||||
await group.closeEditor(editor, { preserveFocus: true });
|
||||
|
||||
if (!group.isOpened(editor)) {
|
||||
if (!group.contains(editor)) {
|
||||
return TriggerAction.REMOVE_ITEM;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { IEditorInput, IEditorInputFactoryRegistry, IEditorIdentifier, GroupIdentifier, Extensions, IEditorPartOptionsChangeEvent, EditorsOrder, EditorResourceAccessor, SideBySideEditor } from 'vs/workbench/common/editor';
|
||||
import { IEditorInput, IEditorInputFactoryRegistry, IEditorIdentifier, GroupIdentifier, Extensions, IEditorPartOptionsChangeEvent, EditorsOrder, SideBySideEditorInput } from 'vs/workbench/common/editor';
|
||||
import { dispose, Disposable, DisposableStore } from 'vs/base/common/lifecycle';
|
||||
import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
|
||||
import { Registry } from 'vs/platform/registry/common/platform';
|
||||
|
|
@ -12,6 +12,7 @@ import { IEditorGroupsService, IEditorGroup, GroupChangeKind, GroupsOrder } from
|
|||
import { coalesce } from 'vs/base/common/arrays';
|
||||
import { LinkedMap, Touch, ResourceMap } from 'vs/base/common/map';
|
||||
import { equals } from 'vs/base/common/objects';
|
||||
import { IResourceEditorInputIdentifier } from 'vs/platform/editor/common/editor';
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
|
||||
interface ISerializedEditorsList {
|
||||
|
|
@ -38,7 +39,7 @@ export class EditorsObserver extends Disposable {
|
|||
|
||||
private readonly keyMap = new Map<GroupIdentifier, Map<IEditorInput, IEditorIdentifier>>();
|
||||
private readonly mostRecentEditorsMap = new LinkedMap<IEditorIdentifier, IEditorIdentifier>();
|
||||
private readonly editorResourcesMap = new ResourceMap<number>();
|
||||
private readonly editorsByResourceMap = new ResourceMap<Map<string /* type ID */, number /* counter */>>();
|
||||
|
||||
private readonly _onDidMostRecentlyActiveEditorsChange = this._register(new Emitter<void>());
|
||||
readonly onDidMostRecentlyActiveEditorsChange = this._onDidMostRecentlyActiveEditorsChange.event;
|
||||
|
|
@ -51,8 +52,14 @@ export class EditorsObserver extends Disposable {
|
|||
return [...this.mostRecentEditorsMap.values()];
|
||||
}
|
||||
|
||||
hasEditor(resource: URI): boolean {
|
||||
return this.editorResourcesMap.has(resource);
|
||||
hasEditor(editor: IResourceEditorInputIdentifier): boolean {
|
||||
const editors = this.editorsByResourceMap.get(editor.resource);
|
||||
|
||||
return editors?.has(editor.typeId) ?? false;
|
||||
}
|
||||
|
||||
hasEditors(resource: URI): boolean {
|
||||
return this.editorsByResourceMap.has(resource);
|
||||
}
|
||||
|
||||
constructor(
|
||||
|
|
@ -185,19 +192,41 @@ export class EditorsObserver extends Disposable {
|
|||
}
|
||||
|
||||
private updateEditorResourcesMap(editor: IEditorInput, add: boolean): void {
|
||||
const resource = EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
|
||||
let resource: URI | undefined = undefined;
|
||||
let typeId: string | undefined = undefined;
|
||||
if (editor instanceof SideBySideEditorInput) {
|
||||
resource = editor.primary.resource;
|
||||
typeId = editor.primary.typeId;
|
||||
} else {
|
||||
resource = editor.resource;
|
||||
typeId = editor.typeId;
|
||||
}
|
||||
|
||||
if (!resource) {
|
||||
return; // require a resource
|
||||
}
|
||||
|
||||
// Add entry
|
||||
if (add) {
|
||||
this.editorResourcesMap.set(resource, (this.editorResourcesMap.get(resource) ?? 0) + 1);
|
||||
} else {
|
||||
const counter = this.editorResourcesMap.get(resource) ?? 0;
|
||||
if (counter > 1) {
|
||||
this.editorResourcesMap.set(resource, counter - 1);
|
||||
} else {
|
||||
this.editorResourcesMap.delete(resource);
|
||||
let editorsPerResource = this.editorsByResourceMap.get(resource);
|
||||
if (!editorsPerResource) {
|
||||
editorsPerResource = new Map<string, number>();
|
||||
this.editorsByResourceMap.set(resource, editorsPerResource);
|
||||
}
|
||||
|
||||
editorsPerResource.set(typeId, (editorsPerResource.get(typeId) ?? 0) + 1);
|
||||
}
|
||||
|
||||
// Remove entry
|
||||
else {
|
||||
const editorsPerResource = this.editorsByResourceMap.get(resource);
|
||||
if (editorsPerResource) {
|
||||
const counter = editorsPerResource.get(typeId) ?? 0;
|
||||
if (counter > 1) {
|
||||
editorsPerResource.set(typeId, counter - 1);
|
||||
} else {
|
||||
this.editorsByResourceMap.delete(resource);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ export class TextDiffEditor extends BaseTextEditor implements ITextDiffEditorPan
|
|||
}
|
||||
|
||||
// Clear view state if input is disposed or we are configured to not storing any state
|
||||
if (input.isDisposed() || (!this.shouldRestoreTextEditorViewState(input) && (!this.group || !this.group.isOpened(input)))) {
|
||||
if (input.isDisposed() || (!this.shouldRestoreTextEditorViewState(input) && (!this.group || !this.group.contains(input)))) {
|
||||
super.clearTextEditorViewState([resource], this.group);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -175,6 +175,11 @@ export interface IEditorControl extends ICompositeControl { }
|
|||
|
||||
export interface IFileEditorInputFactory {
|
||||
|
||||
/**
|
||||
* The type identifier of the file editor input.
|
||||
*/
|
||||
typeId: string;
|
||||
|
||||
/**
|
||||
* Creates new new editor input capable of showing files.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -259,7 +259,7 @@ export class TextFileEditor extends BaseTextEditor {
|
|||
|
||||
// If the user configured to not restore view state, we clear the view
|
||||
// state unless the editor is still opened in the group.
|
||||
if (!this.shouldRestoreTextEditorViewState(input) && (!this.group || !this.group.isOpened(input))) {
|
||||
if (!this.shouldRestoreTextEditorViewState(input) && (!this.group || !this.group.contains(input))) {
|
||||
this.clearTextEditorViewState([input.resource], this.group);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ import { IEditorService } from 'vs/workbench/services/editor/common/editorServic
|
|||
import { RunOnceWorker } from 'vs/base/common/async';
|
||||
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
|
||||
import { IFilesConfigurationService, AutoSaveMode } from 'vs/workbench/services/filesConfiguration/common/filesConfigurationService';
|
||||
import { FILE_EDITOR_INPUT_ID } from 'vs/workbench/contrib/files/common/files';
|
||||
|
||||
export class TextFileEditorTracker extends Disposable implements IWorkbenchContribution {
|
||||
|
||||
|
|
@ -65,7 +66,7 @@ export class TextFileEditorTracker extends Disposable implements IWorkbenchContr
|
|||
return false;
|
||||
}
|
||||
|
||||
if (this.editorService.isOpen({ resource })) {
|
||||
if (this.editorService.isOpened({ resource, typeId: FILE_EDITOR_INPUT_ID })) {
|
||||
return false; // model must not be opened already as file
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -67,6 +67,8 @@ Registry.as<IEditorRegistry>(EditorExtensions.Editors).registerEditor(
|
|||
// Register default file input factory
|
||||
Registry.as<IEditorInputFactoryRegistry>(EditorInputExtensions.EditorInputFactories).registerFileEditorInputFactory({
|
||||
|
||||
typeId: FILE_EDITOR_INPUT_ID,
|
||||
|
||||
createFileEditorInput: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredMode, instantiationService): IFileEditorInput => {
|
||||
return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredMode);
|
||||
},
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@ import { IFilesConfigurationService } from 'vs/workbench/services/filesConfigura
|
|||
import { MockContextKeyService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
|
||||
import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
|
||||
import { whenTextEditorClosed } from 'vs/workbench/browser/editor';
|
||||
import { FILE_EDITOR_INPUT_ID } from 'vs/workbench/contrib/files/common/files';
|
||||
|
||||
suite('Files - TextFileEditorTracker', () => {
|
||||
|
||||
|
|
@ -116,7 +117,7 @@ suite('Files - TextFileEditorTracker', () => {
|
|||
async function testDirtyTextFileModelOpensEditorDependingOnAutoSaveSetting(resource: URI, autoSave: boolean, error: boolean): Promise<void> {
|
||||
const accessor = await createTracker(autoSave);
|
||||
|
||||
assert.ok(!accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true })));
|
||||
assert.ok(!accessor.editorService.isOpened({ resource, typeId: FILE_EDITOR_INPUT_ID }));
|
||||
|
||||
if (error) {
|
||||
accessor.textFileService.setWriteErrorOnce(new FileOperationError('fail to write', FileOperationResult.FILE_OTHER_ERROR));
|
||||
|
|
@ -130,13 +131,13 @@ suite('Files - TextFileEditorTracker', () => {
|
|||
await model.save();
|
||||
await timeout(100);
|
||||
if (error) {
|
||||
assert.ok(accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true })));
|
||||
assert.ok(accessor.editorService.isOpened({ resource, typeId: FILE_EDITOR_INPUT_ID }));
|
||||
} else {
|
||||
assert.ok(!accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true })));
|
||||
assert.ok(!accessor.editorService.isOpened({ resource, typeId: FILE_EDITOR_INPUT_ID }));
|
||||
}
|
||||
} else {
|
||||
await awaitEditorOpening(accessor.editorService);
|
||||
assert.ok(accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true })));
|
||||
assert.ok(accessor.editorService.isOpened({ resource, typeId: FILE_EDITOR_INPUT_ID }));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -146,12 +147,12 @@ suite('Files - TextFileEditorTracker', () => {
|
|||
const untitledEditor = accessor.editorService.createEditorInput({ forceUntitled: true }) as UntitledTextEditorInput;
|
||||
const model = disposables.add(await untitledEditor.resolve());
|
||||
|
||||
assert.ok(!accessor.editorService.isOpen(untitledEditor));
|
||||
assert.ok(!accessor.editorService.isOpened(untitledEditor));
|
||||
|
||||
model.textEditorModel?.setValue('Super Good');
|
||||
|
||||
await awaitEditorOpening(accessor.editorService);
|
||||
assert.ok(accessor.editorService.isOpen(untitledEditor));
|
||||
assert.ok(accessor.editorService.isOpened(untitledEditor));
|
||||
});
|
||||
|
||||
function awaitEditorOpening(editorService: IEditorService): Promise<void> {
|
||||
|
|
|
|||
|
|
@ -394,7 +394,7 @@ class NotebookFileTracker implements IWorkbenchContribution {
|
|||
private _openMissingDirtyNotebookEditors(models: IResolvedNotebookEditorModel[]): void {
|
||||
const result: IEditorInputWithOptions[] = [];
|
||||
for (let model of models) {
|
||||
if (model.isDirty() && !this._editorService.isOpen({ resource: model.resource })) {
|
||||
if (model.isDirty() && !this._editorService.isOpened({ resource: model.resource, typeId: NotebookEditorInput.ID })) {
|
||||
result.push({
|
||||
editor: NotebookEditorInput.create(this._instantiationService, model.resource, model.viewType),
|
||||
options: { inactive: true, preserveFocus: true, pinned: true, }
|
||||
|
|
|
|||
|
|
@ -77,7 +77,7 @@ export class PreferencesContribution implements IWorkbenchContribution {
|
|||
// If the resource was already opened before in the group, do not prevent
|
||||
// the opening of that resource. Otherwise we would have the same settings
|
||||
// opened twice (https://github.com/microsoft/vscode/issues/36447)
|
||||
if (group.isOpened(editor)) {
|
||||
if (group.contains(editor)) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ class SearchEditorContribution implements IWorkbenchContribution {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
if (editor instanceof SearchEditorInput && group.isOpened(editor)) {
|
||||
if (editor instanceof SearchEditorInput && group.contains(editor)) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -46,14 +46,14 @@ class WebviewPanelContribution implements IWorkbenchContribution {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
if (group.isOpened(editor)) {
|
||||
if (group.contains(editor)) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
let previousGroup: IEditorGroup | undefined;
|
||||
const groups = this.editorGroupService.groups;
|
||||
for (const group of groups) {
|
||||
if (group.isOpened(editor)) {
|
||||
if (group.contains(editor)) {
|
||||
previousGroup = group;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
|
||||
import { IResourceEditorInput, ITextEditorOptions, IEditorOptions, EditorActivation, EditorOverride } from 'vs/platform/editor/common/editor';
|
||||
import { IResourceEditorInput, ITextEditorOptions, IEditorOptions, EditorActivation, EditorOverride, IResourceEditorInputIdentifier } from 'vs/platform/editor/common/editor';
|
||||
import { SideBySideEditor, IEditorInput, IEditorPane, GroupIdentifier, IFileEditorInput, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, IEditorInputFactoryRegistry, Extensions as EditorExtensions, EditorInput, SideBySideEditorInput, IEditorInputWithOptions, isEditorInputWithOptions, EditorOptions, TextEditorOptions, IEditorIdentifier, IEditorCloseEvent, ITextEditorPane, ITextDiffEditorPane, IRevertOptions, SaveReason, EditorsOrder, isTextEditorPane, IWorkbenchEditorConfiguration, EditorResourceAccessor, IVisibleEditorPane } from 'vs/workbench/common/editor';
|
||||
import { DEFAULT_EDITOR_ASSOCIATION } from 'vs/workbench/browser/editor';
|
||||
import { ResourceEditorInput } from 'vs/workbench/common/editor/resourceEditorInput';
|
||||
|
|
@ -724,7 +724,7 @@ export class EditorService extends Disposable implements EditorServiceImpl {
|
|||
let groupWithInputOpened: IEditorGroup | undefined = undefined;
|
||||
|
||||
for (const group of groupsByLastActive) {
|
||||
if (group.isOpened(editor)) {
|
||||
if (group.contains(editor)) {
|
||||
if (!groupWithInputOpened) {
|
||||
groupWithInputOpened = group;
|
||||
}
|
||||
|
|
@ -843,18 +843,21 @@ export class EditorService extends Disposable implements EditorServiceImpl {
|
|||
|
||||
//#endregion
|
||||
|
||||
//#region isOpen()
|
||||
//#region isOpened()
|
||||
|
||||
isOpen(editor: IEditorInput): boolean;
|
||||
isOpen(editor: IResourceEditorInput): boolean;
|
||||
isOpen(editor: IEditorInput | IResourceEditorInput): boolean;
|
||||
isOpen(editor: IEditorInput | IResourceEditorInput): boolean {
|
||||
isOpened(editor: IEditorInput): boolean;
|
||||
isOpened(editor: IResourceEditorInputIdentifier): boolean;
|
||||
isOpened(editor: IEditorInput | IResourceEditorInputIdentifier): boolean;
|
||||
isOpened(editor: IEditorInput | IResourceEditorInputIdentifier): boolean {
|
||||
if (editor instanceof EditorInput) {
|
||||
return this.editorGroupService.groups.some(group => group.isOpened(editor));
|
||||
return this.editorGroupService.groups.some(group => group.contains(editor));
|
||||
}
|
||||
|
||||
if (editor.resource) {
|
||||
return this.editorsObserver.hasEditor(this.asCanonicalEditorResource(editor.resource));
|
||||
return this.editorsObserver.hasEditor({
|
||||
resource: this.asCanonicalEditorResource(editor.resource),
|
||||
typeId: editor.typeId
|
||||
});
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
@ -865,8 +868,8 @@ export class EditorService extends Disposable implements EditorServiceImpl {
|
|||
//#region findEditors()
|
||||
|
||||
findEditors(resource: URI, group: IEditorGroup | GroupIdentifier): ReadonlyArray<IEditorInput> {
|
||||
if (!this.isOpen({ resource })) {
|
||||
return [];
|
||||
if (!this.editorsObserver.hasEditors(resource)) {
|
||||
return []; // this is a very fast efficient check via editor observer
|
||||
}
|
||||
|
||||
const targetGroup = typeof group === 'number' ? this.editorGroupService.getGroup(group) : group;
|
||||
|
|
@ -1323,9 +1326,9 @@ export class DelegatingEditorService implements IEditorService {
|
|||
return this.editorService.replaceEditors(editors, group);
|
||||
}
|
||||
|
||||
isOpen(editor: IEditorInput): boolean;
|
||||
isOpen(editor: IResourceEditorInput): boolean;
|
||||
isOpen(editor: IEditorInput | IResourceEditorInput): boolean { return this.editorService.isOpen(editor); }
|
||||
isOpened(editor: IEditorInput): boolean;
|
||||
isOpened(editor: IResourceEditorInputIdentifier): boolean;
|
||||
isOpened(editor: IEditorInput | IResourceEditorInputIdentifier): boolean { return this.editorService.isOpened(editor); }
|
||||
|
||||
findEditors(resource: URI, group: IEditorGroup | GroupIdentifier): ReadonlyArray<IEditorInput> { return this.editorService.findEditors(resource, group); }
|
||||
|
||||
|
|
|
|||
|
|
@ -494,7 +494,10 @@ export interface IEditorGroup {
|
|||
getEditors(order: EditorsOrder, options?: { excludeSticky?: boolean }): ReadonlyArray<IEditorInput>;
|
||||
|
||||
/**
|
||||
* Finds all editors for the given resource that are currently opened in the group
|
||||
* Finds all editors for the given resource that are currently
|
||||
* opened in the group. This method will return an entry for
|
||||
* each editor that reports a `resource` that matches the
|
||||
* provided one.
|
||||
*
|
||||
* @param resource The resource of the editor to find
|
||||
*/
|
||||
|
|
@ -528,13 +531,6 @@ export interface IEditorGroup {
|
|||
*/
|
||||
openEditors(editors: IEditorInputWithOptions[]): Promise<IEditorPane | null>;
|
||||
|
||||
/**
|
||||
* Find out if the provided editor is opened in the group.
|
||||
*
|
||||
* Note: An editor can be opened but not actively visible.
|
||||
*/
|
||||
isOpened(editor: IEditorInput): boolean;
|
||||
|
||||
/**
|
||||
* Find out if the provided editor is pinned in the group.
|
||||
*/
|
||||
|
|
@ -552,6 +548,12 @@ export interface IEditorGroup {
|
|||
|
||||
/**
|
||||
* Find out if a certain editor is included in the group.
|
||||
*
|
||||
* @param candidate the editor to find
|
||||
* @param options with `supportSideBySide: true`, will also
|
||||
* consider each editor of a side by side editor as matching
|
||||
* and with `strictEquals: true` will require strict `===`
|
||||
* check instead of the `IEditorInput#matches()` method.
|
||||
*/
|
||||
contains(candidate: IEditorInput, options?: { supportSideBySide?: boolean, strictEquals?: boolean }): boolean;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
|
||||
import { IResourceEditorInput, IEditorOptions, ITextEditorOptions } from 'vs/platform/editor/common/editor';
|
||||
import { IResourceEditorInput, IEditorOptions, ITextEditorOptions, IResourceEditorInputIdentifier } from 'vs/platform/editor/common/editor';
|
||||
import { IEditorInput, IEditorPane, GroupIdentifier, IEditorInputWithOptions, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, ITextEditorPane, ITextDiffEditorPane, IEditorIdentifier, ISaveOptions, IRevertOptions, EditorsOrder, IVisibleEditorPane, IEditorCloseEvent } from 'vs/workbench/common/editor';
|
||||
import { Event } from 'vs/base/common/event';
|
||||
import { IEditor, IDiffEditor } from 'vs/editor/common/editorCommon';
|
||||
|
|
@ -213,14 +213,9 @@ export interface IEditorService {
|
|||
* Find out if the provided editor is opened in any editor group.
|
||||
*
|
||||
* Note: An editor can be opened but not actively visible.
|
||||
*
|
||||
* @param editor the editor to check for being opened. If a
|
||||
* `IResourceEditorInput` is passed in, the resource is checked on
|
||||
* all opened editors. In case of a side by side editor, the
|
||||
* right hand side resource is considered only.
|
||||
*/
|
||||
isOpen(editor: IResourceEditorInput): boolean;
|
||||
isOpen(editor: IEditorInput): boolean;
|
||||
isOpened(editor: IEditorInput): boolean;
|
||||
isOpened(editor: IResourceEditorInputIdentifier): boolean;
|
||||
|
||||
/**
|
||||
* Find the existing editors for a given resource. It is possible
|
||||
|
|
|
|||
|
|
@ -417,8 +417,8 @@ suite('EditorGroupsService', () => {
|
|||
|
||||
assert.strictEqual(group.isActive(input), true);
|
||||
assert.strictEqual(group.isActive(inputInactive), false);
|
||||
assert.strictEqual(group.isOpened(input), true);
|
||||
assert.strictEqual(group.isOpened(inputInactive), true);
|
||||
assert.strictEqual(group.contains(input), true);
|
||||
assert.strictEqual(group.contains(inputInactive), true);
|
||||
assert.strictEqual(group.isEmpty, false);
|
||||
assert.strictEqual(group.count, 2);
|
||||
assert.strictEqual(editorDidOpenCounter, 2);
|
||||
|
|
|
|||
|
|
@ -102,8 +102,9 @@ suite('EditorService', () => {
|
|||
assert.ok(!service.activeTextEditorControl);
|
||||
assert.ok(!service.activeTextEditorMode);
|
||||
assert.strictEqual(service.visibleTextEditorControls.length, 0);
|
||||
assert.strictEqual(service.isOpen(input), true);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), true);
|
||||
assert.strictEqual(service.isOpened(input), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: 'unknownTypeId' }), false);
|
||||
assert.strictEqual(activeEditorChangeEventCounter, 1);
|
||||
assert.strictEqual(visibleEditorChangeEventCounter, 1);
|
||||
|
||||
|
|
@ -135,10 +136,10 @@ suite('EditorService', () => {
|
|||
assert.strictEqual(input, service.getEditors(EditorsOrder.SEQUENTIAL)[0].editor);
|
||||
assert.strictEqual(otherInput, service.getEditors(EditorsOrder.SEQUENTIAL)[1].editor);
|
||||
assert.strictEqual(service.visibleEditorPanes.length, 1);
|
||||
assert.strictEqual(service.isOpen(input), true);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), true);
|
||||
assert.strictEqual(service.isOpen(otherInput), true);
|
||||
assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true);
|
||||
assert.strictEqual(service.isOpened(input), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), true);
|
||||
assert.strictEqual(service.isOpened(otherInput), true);
|
||||
assert.strictEqual(service.isOpened({ resource: otherInput.resource, typeId: otherInput.typeId }), true);
|
||||
|
||||
assert.strictEqual(activeEditorChangeEventCounter, 4);
|
||||
assert.strictEqual(visibleEditorChangeEventCounter, 4);
|
||||
|
|
@ -179,37 +180,37 @@ suite('EditorService', () => {
|
|||
const editor1 = await service.openEditor(sideBySideInput, { pinned: true });
|
||||
assert.strictEqual(part.activeGroup.count, 1);
|
||||
|
||||
assert.strictEqual(service.isOpen(input), false);
|
||||
assert.strictEqual(service.isOpen(otherInput), false);
|
||||
assert.strictEqual(service.isOpen(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), false);
|
||||
assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true);
|
||||
assert.strictEqual(service.isOpened(input), false);
|
||||
assert.strictEqual(service.isOpened(otherInput), false);
|
||||
assert.strictEqual(service.isOpened(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), false);
|
||||
assert.strictEqual(service.isOpened({ resource: otherInput.resource, typeId: otherInput.typeId }), true);
|
||||
|
||||
const editor2 = await service.openEditor(input, { pinned: true });
|
||||
assert.strictEqual(part.activeGroup.count, 2);
|
||||
|
||||
assert.strictEqual(service.isOpen(input), true);
|
||||
assert.strictEqual(service.isOpen(otherInput), false);
|
||||
assert.strictEqual(service.isOpen(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), true);
|
||||
assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true);
|
||||
assert.strictEqual(service.isOpened(input), true);
|
||||
assert.strictEqual(service.isOpened(otherInput), false);
|
||||
assert.strictEqual(service.isOpened(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), true);
|
||||
assert.strictEqual(service.isOpened({ resource: otherInput.resource, typeId: otherInput.typeId }), true);
|
||||
|
||||
await editor2?.group?.closeEditor(input);
|
||||
assert.strictEqual(part.activeGroup.count, 1);
|
||||
|
||||
assert.strictEqual(service.isOpen(input), false);
|
||||
assert.strictEqual(service.isOpen(otherInput), false);
|
||||
assert.strictEqual(service.isOpen(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), false);
|
||||
assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true);
|
||||
assert.strictEqual(service.isOpened(input), false);
|
||||
assert.strictEqual(service.isOpened(otherInput), false);
|
||||
assert.strictEqual(service.isOpened(sideBySideInput), true);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), false);
|
||||
assert.strictEqual(service.isOpened({ resource: otherInput.resource, typeId: otherInput.typeId }), true);
|
||||
|
||||
await editor1?.group?.closeEditor(sideBySideInput);
|
||||
|
||||
assert.strictEqual(service.isOpen(input), false);
|
||||
assert.strictEqual(service.isOpen(otherInput), false);
|
||||
assert.strictEqual(service.isOpen(sideBySideInput), false);
|
||||
assert.strictEqual(service.isOpen({ resource: input.resource }), false);
|
||||
assert.strictEqual(service.isOpen({ resource: otherInput.resource }), false);
|
||||
assert.strictEqual(service.isOpened(input), false);
|
||||
assert.strictEqual(service.isOpened(otherInput), false);
|
||||
assert.strictEqual(service.isOpened(sideBySideInput), false);
|
||||
assert.strictEqual(service.isOpened({ resource: input.resource, typeId: input.typeId }), false);
|
||||
assert.strictEqual(service.isOpened({ resource: otherInput.resource, typeId: otherInput.typeId }), false);
|
||||
});
|
||||
|
||||
test('openEditors() / replaceEditors()', async () => {
|
||||
|
|
|
|||
|
|
@ -73,7 +73,8 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[0].groupId, part.activeGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[0].editor, input1);
|
||||
assert.strictEqual(onDidMostRecentlyActiveEditorsChangeCalled, true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: 'unknownTypeId' }), false);
|
||||
|
||||
const input2 = new TestFileEditorInput(URI.parse('foo://bar2'), TEST_SERIALIZABLE_EDITOR_INPUT_ID);
|
||||
const input3 = new TestFileEditorInput(URI.parse('foo://bar3'), TEST_SERIALIZABLE_EDITOR_INPUT_ID);
|
||||
|
|
@ -89,8 +90,8 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, part.activeGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
await part.activeGroup.openEditor(input2, EditorOptions.create({ pinned: true }));
|
||||
|
||||
|
|
@ -102,9 +103,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input3);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, part.activeGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
onDidMostRecentlyActiveEditorsChangeCalled = false;
|
||||
await part.activeGroup.closeEditor(input1);
|
||||
|
|
@ -116,16 +117,16 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].groupId, part.activeGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[1].editor, input3);
|
||||
assert.strictEqual(onDidMostRecentlyActiveEditorsChangeCalled, true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
await part.activeGroup.closeAllEditors();
|
||||
currentEditorsMRU = observer.editors;
|
||||
assert.strictEqual(currentEditorsMRU.length, 0);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), false);
|
||||
|
||||
listener.dispose();
|
||||
});
|
||||
|
|
@ -151,7 +152,7 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[0].editor, input1);
|
||||
assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[1].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
|
||||
await rootGroup.openEditor(input1, EditorOptions.create({ pinned: true, activation: EditorActivation.ACTIVATE }));
|
||||
|
||||
|
|
@ -161,7 +162,7 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[0].editor, input1);
|
||||
assert.strictEqual(currentEditorsMRU[1].groupId, sideGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[1].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
|
||||
// Opening an editor inactive should not change
|
||||
// the most recent editor, but rather put it behind
|
||||
|
|
@ -177,8 +178,8 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, sideGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
|
||||
await rootGroup.closeAllEditors();
|
||||
|
||||
|
|
@ -186,15 +187,15 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU.length, 1);
|
||||
assert.strictEqual(currentEditorsMRU[0].groupId, sideGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[0].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
|
||||
await sideGroup.closeAllEditors();
|
||||
|
||||
currentEditorsMRU = observer.editors;
|
||||
assert.strictEqual(currentEditorsMRU.length, 0);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
});
|
||||
|
||||
test('copy group', async function () {
|
||||
|
|
@ -218,9 +219,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
const copiedGroup = part.copyGroup(rootGroup, rootGroup, GroupDirection.RIGHT);
|
||||
copiedGroup.setActive(true);
|
||||
|
|
@ -240,21 +241,21 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[4].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[5].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[5].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
await rootGroup.closeAllEditors();
|
||||
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
await copiedGroup.closeAllEditors();
|
||||
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), false);
|
||||
});
|
||||
|
||||
test('initial editors are part of observer and state is persisted & restored (single group)', async () => {
|
||||
|
|
@ -282,9 +283,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN);
|
||||
|
||||
|
|
@ -299,9 +300,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
});
|
||||
|
||||
test('initial editors are part of observer (multi group)', async () => {
|
||||
|
|
@ -331,9 +332,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
|
||||
storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN);
|
||||
|
||||
|
|
@ -348,9 +349,9 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU[1].editor, input2);
|
||||
assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[2].editor, input1);
|
||||
assert.strictEqual(restoredObserver.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(restoredObserver.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(restoredObserver.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(restoredObserver.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(restoredObserver.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(restoredObserver.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
});
|
||||
|
||||
test('observer does not restore editors that cannot be serialized', async () => {
|
||||
|
|
@ -370,7 +371,7 @@ suite('EditorsObserver', function () {
|
|||
assert.strictEqual(currentEditorsMRU.length, 1);
|
||||
assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id);
|
||||
assert.strictEqual(currentEditorsMRU[0].editor, input1);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
|
||||
storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN);
|
||||
|
||||
|
|
@ -379,7 +380,7 @@ suite('EditorsObserver', function () {
|
|||
|
||||
currentEditorsMRU = restoredObserver.editors;
|
||||
assert.strictEqual(currentEditorsMRU.length, 0);
|
||||
assert.strictEqual(restoredObserver.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(restoredObserver.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
});
|
||||
|
||||
test('observer closes editors when limit reached (across all groups)', async () => {
|
||||
|
|
@ -403,14 +404,14 @@ suite('EditorsObserver', function () {
|
|||
await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true }));
|
||||
|
||||
assert.strictEqual(rootGroup.count, 3);
|
||||
assert.strictEqual(rootGroup.isOpened(input1), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input3), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), false);
|
||||
assert.strictEqual(rootGroup.contains(input2), true);
|
||||
assert.strictEqual(rootGroup.contains(input3), true);
|
||||
assert.strictEqual(rootGroup.contains(input4), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
|
||||
input2.setDirty();
|
||||
part.enforcePartOptions({ limit: { enabled: true, value: 1 } });
|
||||
|
|
@ -418,29 +419,29 @@ suite('EditorsObserver', function () {
|
|||
await timeout(0);
|
||||
|
||||
assert.strictEqual(rootGroup.count, 2);
|
||||
assert.strictEqual(rootGroup.isOpened(input1), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), true); // dirty
|
||||
assert.strictEqual(rootGroup.isOpened(input3), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), false);
|
||||
assert.strictEqual(rootGroup.contains(input2), true); // dirty
|
||||
assert.strictEqual(rootGroup.contains(input3), false);
|
||||
assert.strictEqual(rootGroup.contains(input4), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
|
||||
const input5 = new TestFileEditorInput(URI.parse('foo://bar5'), TEST_EDITOR_INPUT_ID);
|
||||
await sideGroup.openEditor(input5, EditorOptions.create({ pinned: true }));
|
||||
|
||||
assert.strictEqual(rootGroup.count, 1);
|
||||
assert.strictEqual(rootGroup.isOpened(input1), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), true); // dirty
|
||||
assert.strictEqual(rootGroup.isOpened(input3), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), false);
|
||||
assert.strictEqual(sideGroup.isOpened(input5), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input5.resource), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), false);
|
||||
assert.strictEqual(rootGroup.contains(input2), true); // dirty
|
||||
assert.strictEqual(rootGroup.contains(input3), false);
|
||||
assert.strictEqual(rootGroup.contains(input4), false);
|
||||
assert.strictEqual(sideGroup.contains(input5), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input5.resource, typeId: input5.typeId }), true);
|
||||
});
|
||||
|
||||
test('observer closes editors when limit reached (in group)', async () => {
|
||||
|
|
@ -464,14 +465,14 @@ suite('EditorsObserver', function () {
|
|||
await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true }));
|
||||
|
||||
assert.strictEqual(rootGroup.count, 3); // 1 editor got closed due to our limit!
|
||||
assert.strictEqual(rootGroup.isOpened(input1), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input3), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), false);
|
||||
assert.strictEqual(rootGroup.contains(input2), true);
|
||||
assert.strictEqual(rootGroup.contains(input3), true);
|
||||
assert.strictEqual(rootGroup.contains(input4), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
|
||||
await sideGroup.openEditor(input1, EditorOptions.create({ pinned: true }));
|
||||
await sideGroup.openEditor(input2, EditorOptions.create({ pinned: true }));
|
||||
|
|
@ -479,35 +480,35 @@ suite('EditorsObserver', function () {
|
|||
await sideGroup.openEditor(input4, EditorOptions.create({ pinned: true }));
|
||||
|
||||
assert.strictEqual(sideGroup.count, 3);
|
||||
assert.strictEqual(sideGroup.isOpened(input1), false);
|
||||
assert.strictEqual(sideGroup.isOpened(input2), true);
|
||||
assert.strictEqual(sideGroup.isOpened(input3), true);
|
||||
assert.strictEqual(sideGroup.isOpened(input4), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(sideGroup.contains(input1), false);
|
||||
assert.strictEqual(sideGroup.contains(input2), true);
|
||||
assert.strictEqual(sideGroup.contains(input3), true);
|
||||
assert.strictEqual(sideGroup.contains(input4), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
|
||||
part.enforcePartOptions({ limit: { enabled: true, value: 1, perEditorGroup: true } });
|
||||
|
||||
await timeout(10);
|
||||
|
||||
assert.strictEqual(rootGroup.count, 1);
|
||||
assert.strictEqual(rootGroup.isOpened(input1), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input3), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), false);
|
||||
assert.strictEqual(rootGroup.contains(input2), false);
|
||||
assert.strictEqual(rootGroup.contains(input3), false);
|
||||
assert.strictEqual(rootGroup.contains(input4), true);
|
||||
|
||||
assert.strictEqual(sideGroup.count, 1);
|
||||
assert.strictEqual(sideGroup.isOpened(input1), false);
|
||||
assert.strictEqual(sideGroup.isOpened(input2), false);
|
||||
assert.strictEqual(sideGroup.isOpened(input3), false);
|
||||
assert.strictEqual(sideGroup.isOpened(input4), true);
|
||||
assert.strictEqual(sideGroup.contains(input1), false);
|
||||
assert.strictEqual(sideGroup.contains(input2), false);
|
||||
assert.strictEqual(sideGroup.contains(input3), false);
|
||||
assert.strictEqual(sideGroup.contains(input4), true);
|
||||
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
});
|
||||
|
||||
test('observer does not close sticky', async () => {
|
||||
|
|
@ -530,13 +531,13 @@ suite('EditorsObserver', function () {
|
|||
await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true }));
|
||||
|
||||
assert.strictEqual(rootGroup.count, 3);
|
||||
assert.strictEqual(rootGroup.isOpened(input1), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input2), false);
|
||||
assert.strictEqual(rootGroup.isOpened(input3), true);
|
||||
assert.strictEqual(rootGroup.isOpened(input4), true);
|
||||
assert.strictEqual(observer.hasEditor(input1.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input2.resource), false);
|
||||
assert.strictEqual(observer.hasEditor(input3.resource), true);
|
||||
assert.strictEqual(observer.hasEditor(input4.resource), true);
|
||||
assert.strictEqual(rootGroup.contains(input1), true);
|
||||
assert.strictEqual(rootGroup.contains(input2), false);
|
||||
assert.strictEqual(rootGroup.contains(input3), true);
|
||||
assert.strictEqual(rootGroup.contains(input4), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input1.resource, typeId: input1.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input2.resource, typeId: input2.typeId }), false);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input3.resource, typeId: input3.typeId }), true);
|
||||
assert.strictEqual(observer.hasEditor({ resource: input4.resource, typeId: input4.typeId }), true);
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -769,7 +769,7 @@ export class HistoryService extends Disposable implements IHistoryService {
|
|||
// Deserialize and open editor unless already opened
|
||||
const restoredEditor = this.editorInputFactory.getEditorInputSerializer(lastClosedEditor.serialized.typeId)?.deserialize(this.instantiationService, lastClosedEditor.serialized.value);
|
||||
let editorPane: IEditorPane | undefined = undefined;
|
||||
if (restoredEditor && !this.editorGroupService.activeGroup.isOpened(restoredEditor)) {
|
||||
if (restoredEditor && !this.editorGroupService.activeGroup.contains(restoredEditor)) {
|
||||
// Fix for https://github.com/microsoft/vscode/issues/107850
|
||||
// If opening an editor fails, it is possible that we get
|
||||
// another editor-close event as a result. But we really do
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configur
|
|||
import { IWorkbenchLayoutService, Parts, Position as PartPosition } from 'vs/workbench/services/layout/browser/layoutService';
|
||||
import { TextModelResolverService } from 'vs/workbench/services/textmodelResolver/common/textModelResolverService';
|
||||
import { ITextModelService } from 'vs/editor/common/services/resolverService';
|
||||
import { IEditorOptions, IResourceEditorInput, IEditorModel, ITextEditorOptions } from 'vs/platform/editor/common/editor';
|
||||
import { IEditorOptions, IResourceEditorInput, IEditorModel, ITextEditorOptions, IResourceEditorInputIdentifier } from 'vs/platform/editor/common/editor';
|
||||
import { IUntitledTextEditorService, UntitledTextEditorService } from 'vs/workbench/services/untitled/common/untitledTextEditorService';
|
||||
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
|
||||
import { ILifecycleService, BeforeShutdownEvent, ShutdownReason, StartupKind, LifecyclePhase, WillShutdownEvent } from 'vs/workbench/services/lifecycle/common/lifecycle';
|
||||
|
|
@ -131,6 +131,7 @@ import { ITerminalInstanceService } from 'vs/workbench/contrib/terminal/browser/
|
|||
import { isArray } from 'vs/base/common/types';
|
||||
import { IShellLaunchConfigResolveOptions, ITerminalProfile, ITerminalProfileResolverService } from 'vs/workbench/contrib/terminal/common/terminal';
|
||||
import { EditorOverrideService, IEditorOverrideService } from 'vs/workbench/services/editor/browser/editorOverrideService';
|
||||
import { FILE_EDITOR_INPUT_ID } from 'vs/workbench/contrib/files/common/files';
|
||||
|
||||
export function createFileEditorInput(instantiationService: IInstantiationService, resource: URI): FileEditorInput {
|
||||
return instantiationService.createInstance(FileEditorInput, resource, undefined, undefined, undefined, undefined, undefined);
|
||||
|
|
@ -138,6 +139,8 @@ export function createFileEditorInput(instantiationService: IInstantiationServic
|
|||
|
||||
Registry.as<IEditorInputFactoryRegistry>(EditorExtensions.EditorInputFactories).registerFileEditorInputFactory({
|
||||
|
||||
typeId: FILE_EDITOR_INPUT_ID,
|
||||
|
||||
createFileEditorInput: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredMode, instantiationService): IFileEditorInput => {
|
||||
return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredMode);
|
||||
},
|
||||
|
|
@ -701,7 +704,6 @@ export class TestEditorGroupView implements IEditorGroupView {
|
|||
getIndexOfEditor(_editor: IEditorInput): number { return -1; }
|
||||
openEditor(_editor: IEditorInput, _options?: IEditorOptions): Promise<IEditorPane> { throw new Error('not implemented'); }
|
||||
openEditors(_editors: IEditorInputWithOptions[]): Promise<IEditorPane> { throw new Error('not implemented'); }
|
||||
isOpened(_editor: IEditorInput | IResourceEditorInput): boolean { return false; }
|
||||
isPinned(_editor: IEditorInput): boolean { return false; }
|
||||
isSticky(_editor: IEditorInput): boolean { return false; }
|
||||
isActive(_editor: IEditorInput): boolean { return false; }
|
||||
|
|
@ -794,7 +796,7 @@ export class TestEditorService implements EditorServiceImpl {
|
|||
return [this.editorGroupService.activeGroup, editor as EditorInput, undefined];
|
||||
}
|
||||
openEditors(_editors: any, _group?: any): Promise<IEditorPane[]> { throw new Error('not implemented'); }
|
||||
isOpen(_editor: IEditorInput | IResourceEditorInput): boolean { return false; }
|
||||
isOpened(_editor: IEditorInput | IResourceEditorInputIdentifier): boolean { return false; }
|
||||
replaceEditors(_editors: any, _group: any) { return Promise.resolve(undefined); }
|
||||
createEditorInput(_input: IResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput): EditorInput { throw new Error('not implemented'); }
|
||||
save(editors: IEditorIdentifier[], options?: ISaveEditorsOptions): Promise<boolean> { throw new Error('Method not implemented.'); }
|
||||
|
|
|
|||
Loading…
Reference in a new issue