@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/files/browser/views/openEditorsView.js

@@ -0,0 +1,608 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import './media/openeditors.css.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ActionRunner } from 'monaco-editor/esm/vs/base/common/actions.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../../common/editor.js';
+import { SaveAllInGroupAction, CloseGroupAction } from '../fileActions.js';
+import { OpenEditor, OpenEditorsFocusedContext, ExplorerFocusedContext } from '../../common/files.js';
+import { CloseEditorAction, UnpinEditorAction } from '../../../../browser/parts/editor/editorActions.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { asCssVariable, badgeBackground, badgeForeground, contrastBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { ResourceLabels } from '../../../../browser/labels.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { OpenEditorsGroupContext, OpenEditorsDirtyEditorContext, OpenEditorsReadonlyEditorContext } from '../fileConstants.js';
+import { ResourceContextKey } from '../../../../common/contextkeys.js';
+import { containsDragType, CodeDataTransfers } from 'monaco-editor/esm/vs/platform/dnd/browser/dnd.js';
+import { ResourcesDropHandler, fillEditorsDragData } from '../../../../browser/dnd.js';
+import { ViewPane } from '../../../../browser/parts/views/viewPane.js';
+import { DataTransfers } from 'monaco-editor/esm/vs/base/browser/dnd.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { NativeDragAndDropData, ElementsDragAndDropData } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IWorkingCopyService } from '../../../../services/workingCopy/common/workingCopyService.js';
+import { IFilesConfigurationService } from '../../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IViewDescriptorService } from '../../../../common/views.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { compareFileNamesDefault } from 'monaco-editor/esm/vs/base/common/comparers.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+const $ = dom.$;
+let OpenEditorsView = class OpenEditorsView extends ViewPane {
+    constructor(options, instantiationService, viewDescriptorService, contextMenuService, editorGroupService, configurationService, keybindingService, contextKeyService, themeService, telemetryService, workingCopyService, filesConfigurationService, openerService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.editorGroupService = editorGroupService;
+        this.workingCopyService = workingCopyService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.needsRefresh = false;
+        this.elements = [];
+        this.structuralRefreshDelay = 0;
+        this.sortOrder = configurationService.getValue('explorer.openEditors.sortOrder');
+        this.registerUpdateEvents();
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationChange(e)));
+        this._register(this.workingCopyService.onDidChangeDirty(workingCopy => this.updateDirtyIndicator(workingCopy)));
+    }
+    registerUpdateEvents() {
+        const updateWholeList = () => {
+            if (!this.isBodyVisible() || !this.list) {
+                this.needsRefresh = true;
+                return;
+            }
+            this.listRefreshScheduler?.schedule(this.structuralRefreshDelay);
+        };
+        const groupDisposables = ( new Map());
+        const addGroupListener = (group) => {
+            const groupModelChangeListener = group.onDidModelChange(e => {
+                if (this.listRefreshScheduler?.isScheduled()) {
+                    return;
+                }
+                if (!this.isBodyVisible() || !this.list) {
+                    this.needsRefresh = true;
+                    return;
+                }
+                const index = this.getIndex(group, e.editor);
+                switch (e.kind) {
+                    case 6 :
+                    case 0 :
+                        this.focusActiveEditor();
+                        break;
+                    case 1 :
+                        if (index >= 0) {
+                            this.list.splice(index, 1, [group]);
+                        }
+                        break;
+                    case 11 :
+                    case 10 :
+                    case 8 :
+                    case 9 :
+                    case 7 :
+                        this.list.splice(index, 1, [( new OpenEditor(e.editor, group))]);
+                        this.focusActiveEditor();
+                        break;
+                    case 3 :
+                    case 5 :
+                    case 4 :
+                        updateWholeList();
+                        break;
+                }
+            });
+            groupDisposables.set(group.id, groupModelChangeListener);
+            this._register(groupDisposables.get(group.id));
+        };
+        this.editorGroupService.groups.forEach(g => addGroupListener(g));
+        this._register(this.editorGroupService.onDidAddGroup(group => {
+            addGroupListener(group);
+            updateWholeList();
+        }));
+        this._register(this.editorGroupService.onDidMoveGroup(() => updateWholeList()));
+        this._register(this.editorGroupService.onDidRemoveGroup(group => {
+            dispose(groupDisposables.get(group.id));
+            updateWholeList();
+        }));
+    }
+    renderHeaderTitle(container) {
+        super.renderHeaderTitle(container, this.title);
+        const count = dom.append(container, $('.count'));
+        this.dirtyCountElement = dom.append(count, $('.dirty-count.monaco-count-badge.long'));
+        this.dirtyCountElement.style.backgroundColor = asCssVariable(badgeBackground);
+        this.dirtyCountElement.style.color = asCssVariable(badgeForeground);
+        this.dirtyCountElement.style.border = `1px solid ${asCssVariable(contrastBorder)}`;
+        this.updateDirtyIndicator();
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        container.classList.add('open-editors');
+        container.classList.add('show-file-icons');
+        const delegate = ( new OpenEditorsDelegate());
+        if (this.list) {
+            this.list.dispose();
+        }
+        if (this.listLabels) {
+            this.listLabels.clear();
+        }
+        this.listLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this.list = this.instantiationService.createInstance(WorkbenchList, 'OpenEditors', container, delegate, [
+            ( new EditorGroupRenderer(this.keybindingService, this.instantiationService)),
+            ( new OpenEditorRenderer(
+                this.listLabels,
+                this.instantiationService,
+                this.keybindingService,
+                this.configurationService
+            ))
+        ], {
+            identityProvider: { getId: (element) => element instanceof OpenEditor ? element.getId() : ( element.id.toString()) },
+            dnd: ( new OpenEditorsDragAndDrop(this.instantiationService, this.editorGroupService)),
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            },
+            accessibilityProvider: ( new OpenEditorsAccessibilityProvider())
+        });
+        this._register(this.list);
+        this._register(this.listLabels);
+        let labelChangeListeners = [];
+        this.listRefreshScheduler = this._register(( new RunOnceScheduler(() => {
+            if (!this.list) {
+                return;
+            }
+            labelChangeListeners = dispose(labelChangeListeners);
+            const previousLength = this.list.length;
+            const elements = this.getElements();
+            this.list.splice(0, this.list.length, elements);
+            this.focusActiveEditor();
+            if (previousLength !== this.list.length) {
+                this.updateSize();
+            }
+            this.needsRefresh = false;
+            if (this.sortOrder === 'alphabetical' || this.sortOrder === 'fullPath') {
+                elements.forEach(e => {
+                    if (e instanceof OpenEditor) {
+                        labelChangeListeners.push(e.editor.onDidChangeLabel(() => this.listRefreshScheduler?.schedule()));
+                    }
+                });
+            }
+        }, this.structuralRefreshDelay)));
+        this.updateSize();
+        OpenEditorsFocusedContext.bindTo(this.list.contextKeyService);
+        ExplorerFocusedContext.bindTo(this.list.contextKeyService);
+        this.resourceContext = this.instantiationService.createInstance(ResourceContextKey);
+        this._register(this.resourceContext);
+        this.groupFocusedContext = OpenEditorsGroupContext.bindTo(this.contextKeyService);
+        this.dirtyEditorFocusedContext = OpenEditorsDirtyEditorContext.bindTo(this.contextKeyService);
+        this.readonlyEditorFocusedContext = OpenEditorsReadonlyEditorContext.bindTo(this.contextKeyService);
+        this._register(this.list.onContextMenu(e => this.onListContextMenu(e)));
+        this.list.onDidChangeFocus(e => {
+            this.resourceContext.reset();
+            this.groupFocusedContext.reset();
+            this.dirtyEditorFocusedContext.reset();
+            this.readonlyEditorFocusedContext.reset();
+            const element = e.elements.length ? e.elements[0] : undefined;
+            if (element instanceof OpenEditor) {
+                const resource = element.getResource();
+                this.dirtyEditorFocusedContext.set(element.editor.isDirty() && !element.editor.isSaving());
+                this.readonlyEditorFocusedContext.set(element.editor.hasCapability(2 ));
+                this.resourceContext.set(withUndefinedAsNull(resource));
+            }
+            else if (!!element) {
+                this.groupFocusedContext.set(true);
+            }
+        });
+        this._register(this.list.onMouseMiddleClick(e => {
+            if (e && e.element instanceof OpenEditor) {
+                e.element.group.closeEditor(e.element.editor, { preserveFocus: true });
+            }
+        }));
+        this._register(this.list.onDidOpen(e => {
+            if (!e.element) {
+                return;
+            }
+            else if (e.element instanceof OpenEditor) {
+                if (e.browserEvent instanceof MouseEvent && e.browserEvent.button === 1) {
+                    return;
+                }
+                this.openEditor(e.element, { preserveFocus: e.editorOptions.preserveFocus, pinned: e.editorOptions.pinned, sideBySide: e.sideBySide });
+            }
+            else {
+                this.editorGroupService.activateGroup(e.element);
+            }
+        }));
+        this.listRefreshScheduler.schedule(0);
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible && this.needsRefresh) {
+                this.listRefreshScheduler?.schedule(0);
+            }
+        }));
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        this._register(containerModel.onDidChangeAllViewDescriptors(() => {
+            this.updateSize();
+        }));
+    }
+    focus() {
+        super.focus();
+        this.list.domFocus();
+    }
+    getList() {
+        return this.list;
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.list?.layout(height, width);
+    }
+    get showGroups() {
+        return this.editorGroupService.groups.length > 1;
+    }
+    getElements() {
+        this.elements = [];
+        this.editorGroupService.getGroups(2 ).forEach(g => {
+            if (this.showGroups) {
+                this.elements.push(g);
+            }
+            let editors = ( g.editors.map(ei => ( new OpenEditor(ei, g))));
+            if (this.sortOrder === 'alphabetical') {
+                editors = editors.sort((first, second) => compareFileNamesDefault(first.editor.getName(), second.editor.getName()));
+            }
+            else if (this.sortOrder === 'fullPath') {
+                editors = editors.sort((first, second) => {
+                    const firstResource = first.editor.resource;
+                    const secondResource = second.editor.resource;
+                    if (firstResource === undefined && secondResource === undefined) {
+                        return compareFileNamesDefault(first.editor.getName(), second.editor.getName());
+                    }
+                    else if (firstResource === undefined) {
+                        return -1;
+                    }
+                    else if (secondResource === undefined) {
+                        return 1;
+                    }
+                    else {
+                        const firstScheme = firstResource.scheme;
+                        const secondScheme = secondResource.scheme;
+                        if (firstScheme !== Schemas.file && secondScheme !== Schemas.file) {
+                            return extUriIgnorePathCase.compare(firstResource, secondResource);
+                        }
+                        else if (firstScheme !== Schemas.file) {
+                            return -1;
+                        }
+                        else if (secondScheme !== Schemas.file) {
+                            return 1;
+                        }
+                        else {
+                            return extUriIgnorePathCase.compare(firstResource, secondResource);
+                        }
+                    }
+                });
+            }
+            this.elements.push(...editors);
+        });
+        return this.elements;
+    }
+    getIndex(group, editor) {
+        if (!editor) {
+            return this.elements.findIndex(e => !(e instanceof OpenEditor) && e.id === group.id);
+        }
+        return this.elements.findIndex(e => e instanceof OpenEditor && e.editor === editor && e.group.id === group.id);
+    }
+    openEditor(element, options) {
+        if (element) {
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: 'workbench.files.openFile', from: 'openEditors' });
+            const preserveActivateGroup = options.sideBySide && options.preserveFocus;
+            if (!preserveActivateGroup) {
+                this.editorGroupService.activateGroup(element.group);
+            }
+            const targetGroup = options.sideBySide ? this.editorGroupService.sideGroup : this.editorGroupService.activeGroup;
+            targetGroup.openEditor(element.editor, options);
+        }
+    }
+    onListContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const element = e.element;
+        this.contextMenuService.showContextMenu({
+            menuId: MenuId.OpenEditorsContext,
+            menuActionOptions: { shouldForwardArgs: true, arg: element instanceof OpenEditor ? EditorResourceAccessor.getOriginalUri(element.editor) : {} },
+            contextKeyService: this.list.contextKeyService,
+            getAnchor: () => e.anchor,
+            getActionsContext: () => element instanceof OpenEditor ? { groupId: element.groupId, editorIndex: element.group.getIndexOfEditor(element.editor) } : { groupId: element.id }
+        });
+    }
+    focusActiveEditor() {
+        if (this.list.length && this.editorGroupService.activeGroup) {
+            const index = this.getIndex(this.editorGroupService.activeGroup, this.editorGroupService.activeGroup.activeEditor);
+            if (index >= 0) {
+                try {
+                    this.list.setFocus([index]);
+                    this.list.setSelection([index]);
+                    this.list.reveal(index);
+                }
+                catch (e) {
+                }
+                return;
+            }
+        }
+        this.list.setFocus([]);
+        this.list.setSelection([]);
+    }
+    onConfigurationChange(event) {
+        if (event.affectsConfiguration('explorer.openEditors')) {
+            this.updateSize();
+        }
+        if (event.affectsConfiguration('explorer.decorations') || event.affectsConfiguration('explorer.openEditors.sortOrder')) {
+            this.sortOrder = this.configurationService.getValue('explorer.openEditors.sortOrder');
+            this.listRefreshScheduler?.schedule();
+        }
+    }
+    updateSize() {
+        this.minimumBodySize = this.orientation === 0  ? this.getMinExpandedBodySize() : 170;
+        this.maximumBodySize = this.orientation === 0  ? this.getMaxExpandedBodySize() : Number.POSITIVE_INFINITY;
+    }
+    updateDirtyIndicator(workingCopy) {
+        if (workingCopy) {
+            const gotDirty = workingCopy.isDirty();
+            if (gotDirty && !((workingCopy.capabilities & 2) ) && this.filesConfigurationService.getAutoSaveMode() === 1 ) {
+                return;
+            }
+        }
+        const dirty = this.workingCopyService.dirtyCount;
+        if (dirty === 0) {
+            this.dirtyCountElement.classList.add('hidden');
+        }
+        else {
+            this.dirtyCountElement.textContent = ( nls.localize('dirtyCounter', "{0} unsaved", dirty));
+            this.dirtyCountElement.classList.remove('hidden');
+        }
+    }
+    get elementCount() {
+        return ( this.editorGroupService.groups.map(g => g.count))
+            .reduce((first, second) => first + second, this.showGroups ? this.editorGroupService.groups.length : 0);
+    }
+    getMaxExpandedBodySize() {
+        let minVisibleOpenEditors = this.configurationService.getValue('explorer.openEditors.minVisible');
+        if (typeof minVisibleOpenEditors !== 'number') {
+            minVisibleOpenEditors = OpenEditorsView.DEFAULT_MIN_VISIBLE_OPEN_EDITORS;
+        }
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        if (containerModel.visibleViewDescriptors.length <= 1) {
+            return Number.POSITIVE_INFINITY;
+        }
+        return (Math.max(this.elementCount, minVisibleOpenEditors)) * OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    getMinExpandedBodySize() {
+        let visibleOpenEditors = this.configurationService.getValue('explorer.openEditors.visible');
+        if (typeof visibleOpenEditors !== 'number') {
+            visibleOpenEditors = OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS;
+        }
+        return this.computeMinExpandedBodySize(visibleOpenEditors);
+    }
+    computeMinExpandedBodySize(visibleOpenEditors = OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS) {
+        const itemsToShow = Math.min(Math.max(visibleOpenEditors, 1), this.elementCount);
+        return itemsToShow * OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    setStructuralRefreshDelay(delay) {
+        this.structuralRefreshDelay = delay;
+    }
+    getOptimalWidth() {
+        const parentNode = this.list.getHTMLElement();
+        const childNodes = [].slice.call(parentNode.querySelectorAll('.open-editor > a'));
+        return dom.getLargestChildWidth(parentNode, childNodes);
+    }
+};
+OpenEditorsView.DEFAULT_VISIBLE_OPEN_EDITORS = 9;
+OpenEditorsView.DEFAULT_MIN_VISIBLE_OPEN_EDITORS = 0;
+OpenEditorsView.ID = 'workbench.explorer.openEditorsView';
+OpenEditorsView.NAME = ( nls.localize({ key: 'openEditors', comment: ['Open is an adjective'] }, "Open Editors"));
+OpenEditorsView = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IEditorGroupsService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, ITelemetryService)),
+    ( __param(10, IWorkingCopyService)),
+    ( __param(11, IFilesConfigurationService)),
+    ( __param(12, IOpenerService))
+], OpenEditorsView));
+class OpenEditorActionRunner extends ActionRunner {
+    async run(action) {
+        if (!this.editor) {
+            return;
+        }
+        return super.run(action, { groupId: this.editor.groupId, editorIndex: this.editor.group.getIndexOfEditor(this.editor.editor) });
+    }
+}
+class OpenEditorsDelegate {
+    getHeight(_element) {
+        return OpenEditorsDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        if (element instanceof OpenEditor) {
+            return OpenEditorRenderer.ID;
+        }
+        return EditorGroupRenderer.ID;
+    }
+}
+OpenEditorsDelegate.ITEM_HEIGHT = 22;
+class EditorGroupRenderer {
+    constructor(keybindingService, instantiationService) {
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+    }
+    get templateId() {
+        return EditorGroupRenderer.ID;
+    }
+    renderTemplate(container) {
+        const editorGroupTemplate = Object.create(null);
+        editorGroupTemplate.root = dom.append(container, $('.editor-group'));
+        editorGroupTemplate.name = dom.append(editorGroupTemplate.root, $('span.name'));
+        editorGroupTemplate.actionBar = ( new ActionBar(container));
+        const saveAllInGroupAction = this.instantiationService.createInstance(SaveAllInGroupAction, SaveAllInGroupAction.ID, SaveAllInGroupAction.LABEL);
+        const saveAllInGroupKey = this.keybindingService.lookupKeybinding(saveAllInGroupAction.id);
+        editorGroupTemplate.actionBar.push(saveAllInGroupAction, { icon: true, label: false, keybinding: saveAllInGroupKey ? saveAllInGroupKey.getLabel() : undefined });
+        const closeGroupAction = this.instantiationService.createInstance(CloseGroupAction, CloseGroupAction.ID, CloseGroupAction.LABEL);
+        const closeGroupActionKey = this.keybindingService.lookupKeybinding(closeGroupAction.id);
+        editorGroupTemplate.actionBar.push(closeGroupAction, { icon: true, label: false, keybinding: closeGroupActionKey ? closeGroupActionKey.getLabel() : undefined });
+        return editorGroupTemplate;
+    }
+    renderElement(editorGroup, _index, templateData) {
+        templateData.editorGroup = editorGroup;
+        templateData.name.textContent = editorGroup.label;
+        templateData.actionBar.context = { groupId: editorGroup.id };
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+    }
+}
+EditorGroupRenderer.ID = 'editorgroup';
+class OpenEditorRenderer {
+    constructor(labels, instantiationService, keybindingService, configurationService) {
+        this.labels = labels;
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.configurationService = configurationService;
+        this.closeEditorAction = this.instantiationService.createInstance(CloseEditorAction, CloseEditorAction.ID, CloseEditorAction.LABEL);
+        this.unpinEditorAction = this.instantiationService.createInstance(UnpinEditorAction, UnpinEditorAction.ID, UnpinEditorAction.LABEL);
+    }
+    get templateId() {
+        return OpenEditorRenderer.ID;
+    }
+    renderTemplate(container) {
+        const editorTemplate = Object.create(null);
+        editorTemplate.container = container;
+        editorTemplate.actionRunner = ( new OpenEditorActionRunner());
+        editorTemplate.actionBar = ( new ActionBar(container, { actionRunner: editorTemplate.actionRunner }));
+        editorTemplate.root = this.labels.create(container);
+        return editorTemplate;
+    }
+    renderElement(openedEditor, _index, templateData) {
+        const editor = openedEditor.editor;
+        templateData.actionRunner.editor = openedEditor;
+        templateData.container.classList.toggle('dirty', editor.isDirty() && !editor.isSaving());
+        templateData.container.classList.toggle('sticky', openedEditor.isSticky());
+        templateData.root.setResource({
+            resource: EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH }),
+            name: editor.getName(),
+            description: editor.getDescription(1 )
+        }, {
+            italic: openedEditor.isPreview(),
+            extraClasses: ['open-editor'].concat(openedEditor.editor.getLabelExtraClasses()),
+            fileDecorations: this.configurationService.getValue().explorer.decorations,
+            title: editor.getTitle(2 )
+        });
+        const editorAction = openedEditor.isSticky() ? this.unpinEditorAction : this.closeEditorAction;
+        if (!templateData.actionBar.hasAction(editorAction)) {
+            if (!templateData.actionBar.isEmpty()) {
+                templateData.actionBar.clear();
+            }
+            templateData.actionBar.push(editorAction, { icon: true, label: false, keybinding: this.keybindingService.lookupKeybinding(editorAction.id)?.getLabel() });
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.actionBar.dispose();
+        templateData.root.dispose();
+        templateData.actionRunner.dispose();
+    }
+}
+OpenEditorRenderer.ID = 'openeditor';
+class OpenEditorsDragAndDrop {
+    constructor(instantiationService, editorGroupService) {
+        this.instantiationService = instantiationService;
+        this.editorGroupService = editorGroupService;
+    }
+    get dropHandler() {
+        return this.instantiationService.createInstance(ResourcesDropHandler, { allowWorkspaceOpen: false });
+    }
+    getDragURI(element) {
+        if (element instanceof OpenEditor) {
+            const resource = element.getResource();
+            if (resource) {
+                return ( resource.toString());
+            }
+        }
+        return null;
+    }
+    getDragLabel(elements) {
+        if (elements.length > 1) {
+            return String(elements.length);
+        }
+        const element = elements[0];
+        return element instanceof OpenEditor ? element.editor.getName() : element.label;
+    }
+    onDragStart(data, originalEvent) {
+        const items = data.elements;
+        const editors = [];
+        if (items) {
+            for (const item of items) {
+                if (item instanceof OpenEditor) {
+                    editors.push(item);
+                }
+            }
+        }
+        if (editors.length) {
+            this.instantiationService.invokeFunction(fillEditorsDragData, editors, originalEvent);
+        }
+    }
+    onDragOver(data, _targetElement, _targetIndex, originalEvent) {
+        if (data instanceof NativeDragAndDropData) {
+            return containsDragType(originalEvent, DataTransfers.FILES, CodeDataTransfers.FILES);
+        }
+        return true;
+    }
+    drop(data, targetElement, _targetIndex, originalEvent) {
+        const group = targetElement instanceof OpenEditor ? targetElement.group : targetElement || this.editorGroupService.groups[this.editorGroupService.count - 1];
+        const index = targetElement instanceof OpenEditor ? targetElement.group.getIndexOfEditor(targetElement.editor) : 0;
+        if (data instanceof ElementsDragAndDropData) {
+            const elementsData = data.elements;
+            elementsData.forEach((oe, offset) => {
+                oe.group.moveEditor(oe.editor, group, { index: index + offset, preserveFocus: true });
+            });
+            this.editorGroupService.activateGroup(group);
+        }
+        else {
+            this.dropHandler.handleDrop(originalEvent, () => group, () => group.focus(), index);
+        }
+    }
+}
+OpenEditorsDragAndDrop.__decorator = ( __decorate([
+    memoize
+], OpenEditorsDragAndDrop.prototype, "dropHandler", null));
+class OpenEditorsAccessibilityProvider {
+    getWidgetAriaLabel() {
+        return ( nls.localize('openEditors', "Open Editors"));
+    }
+    getAriaLabel(element) {
+        if (element instanceof OpenEditor) {
+            return `${element.editor.getName()}, ${element.editor.getDescription()}`;
+        }
+        return element.ariaLabel;
+    }
+}
+const toggleEditorGroupLayoutId = 'workbench.action.toggleEditorGroupLayout';
+MenuRegistry.appendMenuItem(MenuId.MenubarLayoutMenu, {
+    group: '4_flip',
+    command: {
+        id: toggleEditorGroupLayoutId,
+        title: {
+            original: 'Flip Layout',
+            value: ( nls.localize('miToggleEditorLayoutWithoutMnemonic', "Flip Layout")),
+            mnemonicTitle: ( nls.localize(
+                { key: 'miToggleEditorLayout', comment: ['&& denotes a mnemonic'] },
+                "Flip &&Layout"
+            ))
+        }
+    },
+    order: 1
+});
+export { OpenEditorsView };