@codingame/monaco-vscode-api 28.4.1 → 29.0.0

package/vscode/src/vs/workbench/browser/parts/editor/modalEditorPart.js

@@ -2,13 +2,15 @@
 import { registerCss } from '../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as modalEditorPart from './media/modalEditorPart.css';
-import { $, addDisposableListener, EventType, EventHelper, append, hide, show, isHTMLElement } from '../../../../base/browser/dom.js';
+import { $, addDisposableListener, EventType, EventHelper, Dimension, append, hide, show, setVisibility, isHTMLElement } from '../../../../base/browser/dom.js';
 import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { prepareActions } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { Button } from '../../../../base/browser/ui/button/button.js';
 import { Event, Emitter } from '../../../../base/common/event.js';
 import { DisposableStore, toDisposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { ResizableHTMLElement } from '../../../../base/browser/ui/resizable/resizable.js';
 import { MenuId } from '../../../../platform/actions/common/actions.js';
-import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
+import { WorkbenchToolBar, HiddenItemStrategy, MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
@@ -33,6 +35,14 @@ import { CLOSE_MODAL_EDITOR_COMMAND_ID, MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID, MO
 
 var ModalEditorPartImpl_1;
 registerCss(modalEditorPart);
+const MODAL_MIN_WIDTH = 400;
+const MODAL_MIN_HEIGHT = 300;
+const MODAL_MAX_DEFAULT_WIDTH = 1400;
+const MODAL_MAX_DEFAULT_HEIGHT = 900;
+const MODAL_BORDER_SIZE = 2;
+const MODAL_HEADER_HEIGHT = 33;
+const MODAL_SNAP_THRESHOLD = 20;
+const MODAL_MAXIMIZED_PADDING = 16;
 const defaultModalEditorAllowableCommands = ( new Set([
 "workbench.action.quit", "workbench.action.reloadWindow", "workbench.action.toggleFullScreen",
 "workbench.action.gotoSymbol", "workbench.action.gotoLine",
@@ -42,6 +52,7 @@ const defaultModalEditorAllowableCommands = ( new Set([
 "workbench.action.openSettings", "workbench.action.openSettings2", "workbench.action.openSettingsJson", "workbench.action.openGlobalSettings", "workbench.action.openApplicationSettingsJson", "workbench.action.openRawDefaultSettings", "workbench.action.openWorkspaceSettings", "workbench.action.openWorkspaceSettingsFile", "workbench.action.openFolderSettings", "workbench.action.openFolderSettingsFile", "workbench.action.openRemoteSettings", "workbench.action.openRemoteSettingsFile", "workbench.action.openAccessibilitySettings", "workbench.action.configureLanguageBasedSettings",
 "workbench.action.openGlobalKeybindings", "workbench.action.openDefaultKeybindingsFile", "workbench.action.openGlobalKeybindingsFile", "workbench.action.openKeyboardLayoutPicker",
 CLOSE_MODAL_EDITOR_COMMAND_ID, MOVE_MODAL_EDITOR_TO_MAIN_COMMAND_ID, MOVE_MODAL_EDITOR_TO_WINDOW_COMMAND_ID, TOGGLE_MODAL_EDITOR_MAXIMIZED_COMMAND_ID, NAVIGATE_MODAL_EDITOR_PREVIOUS_COMMAND_ID, NAVIGATE_MODAL_EDITOR_NEXT_COMMAND_ID]));
+const USE_MODAL_EDITOR_SETTING = "workbench.editor.useModal";
 let ModalEditorPart = class ModalEditorPart {
     constructor(
         editorPartsView,
@@ -68,13 +79,13 @@ let ModalEditorPart = class ModalEditorPart {
         disposables.add(addDisposableListener(modalElement, EventType.MOUSE_DOWN, e => {
             if (e.target === modalElement) {
                 EventHelper.stop(e, true);
-                editorPart.close();
+                void editorPart.close();
             }
         }));
-        let useModalMode = this.configurationService.getValue("workbench.editor.useModal");
+        let useModalMode = this.configurationService.getValue(USE_MODAL_EDITOR_SETTING);
         disposables.add(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration("workbench.editor.useModal")) {
-                useModalMode = this.configurationService.getValue("workbench.editor.useModal");
+            if (e.affectsConfiguration(USE_MODAL_EDITOR_SETTING)) {
+                useModalMode = this.configurationService.getValue(USE_MODAL_EDITOR_SETTING);
             }
         }));
         disposables.add(addDisposableListener(modalElement, EventType.KEY_DOWN, e => {
@@ -88,7 +99,14 @@ let ModalEditorPart = class ModalEditorPart {
                 }
             }
         }));
-        const shadowElement = modalElement.appendChild($(".modal-editor-shadow"));
+        const resizableElement = ( new ResizableHTMLElement());
+        disposables.add(toDisposable(() => resizableElement.dispose()));
+        resizableElement.domNode.classList.add("modal-editor-resizable");
+        const configuredMinWidth = options?.minWidth ?? this.configurationService.getValue("workbench.editor.modalMinWidth");
+        const effectiveMinWidth = (typeof configuredMinWidth === "number" && Number.isFinite(configuredMinWidth) && configuredMinWidth >= MODAL_MIN_WIDTH) ? configuredMinWidth : MODAL_MIN_WIDTH;
+        resizableElement.minSize = ( new Dimension(effectiveMinWidth, MODAL_MIN_HEIGHT));
+        modalElement.appendChild(resizableElement.domNode);
+        const shadowElement = resizableElement.domNode.appendChild($(".modal-editor-shadow"));
         const titleId = "modal-editor-title";
         const editorPartContainer = $(".part.editor.modal-editor-part", {
             role: "dialog",
@@ -106,7 +124,7 @@ let ModalEditorPart = class ModalEditorPart {
             addDisposableListener(navigationContainer, EventType.DBLCLICK, e => EventHelper.stop(e, true))
         );
         const previousButton = disposables.add(( new Button(navigationContainer, {
-            title: ( localize(3565, "Previous"))
+            title: ( localize(3573, "Previous"))
         })));
         previousButton.icon = Codicon.chevronLeft;
         previousButton.element.classList.add("modal-editor-nav-button");
@@ -119,7 +137,7 @@ let ModalEditorPart = class ModalEditorPart {
         const navigationLabel = append(navigationContainer, $("span.modal-editor-nav-label"));
         navigationLabel.setAttribute("aria-live", "polite");
         const nextButton = disposables.add(( new Button(navigationContainer, {
-            title: ( localize(3566, "Next"))
+            title: ( localize(3574, "Next"))
         })));
         nextButton.icon = Codicon.chevronRight;
         nextButton.element.classList.add("modal-editor-nav-button");
@@ -143,7 +161,7 @@ let ModalEditorPart = class ModalEditorPart {
         disposables.add(Event.runAndSubscribe(editorPart.onDidChangeNavigation, (navigation => {
             if (navigation && navigation.total > 1) {
                 show(navigationContainer);
-                navigationLabel.textContent = ( localize(3567, "{0} of {1}", navigation.current + 1, navigation.total));
+                navigationLabel.textContent = ( localize(3575, "{0} of {1}", navigation.current + 1, navigation.total));
                 previousButton.enabled = navigation.current > 0;
                 nextButton.enabled = navigation.current < navigation.total - 1;
             } else {
@@ -152,6 +170,33 @@ let ModalEditorPart = class ModalEditorPart {
         }), editorPart.navigation));
         const modalEditorService = this.editorService.createScoped(editorPart, disposables);
         const scopedInstantiationService = disposables.add(editorPart.scopedInstantiationService.createChild(( new ServiceCollection([IEditorService, modalEditorService]))));
+        const editorActionsToolbarContainer = append(actionBarContainer, $("div.modal-editor-editor-actions"));
+        const editorActionsToolbar = disposables.add(
+            scopedInstantiationService.createInstance(WorkbenchToolBar, editorActionsToolbarContainer, {
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                highlightToggledItems: true
+            })
+        );
+        const editorActionsSeparator = append(actionBarContainer, $("div.modal-editor-action-separator"));
+        const editorActionsDisposables = disposables.add(( new DisposableStore()));
+        const updateEditorActions = () => {
+            editorActionsDisposables.clear();
+            const editorActions = editorPart.activeGroup.createEditorActions(editorActionsDisposables, MenuId.ModalEditorEditorTitle);
+            editorActionsDisposables.add(editorActions.onDidChange(() => updateEditorActions()));
+            const {
+                primary,
+                secondary
+            } = editorActions.actions;
+            editorActionsToolbar.setActions(prepareActions(primary), prepareActions(secondary));
+            const hasActions = primary.length > 0 || secondary.length > 0;
+            setVisibility(hasActions, editorActionsSeparator);
+        };
+        disposables.add(
+            Event.runAndSubscribe(modalEditorService.onDidActiveEditorChange, () => updateEditorActions())
+        );
+        disposables.add(
+            modalEditorService.onDidEditorsChange(() => editorPart.enforceModalPartOptions())
+        );
         disposables.add(
             scopedInstantiationService.createInstance(MenuWorkbenchToolBar, actionBarContainer, MenuId.ModalEditorTitle, {
                 hiddenItemStrategy: HiddenItemStrategy.NoHide,
@@ -162,7 +207,9 @@ let ModalEditorPart = class ModalEditorPart {
             })
         );
         const label = disposables.add(scopedInstantiationService.createInstance(ResourceLabel, titleElement, {}));
-        disposables.add(Event.runAndSubscribe(modalEditorService.onDidActiveEditorChange, () => {
+        const labelChangeDisposable = disposables.add(( new MutableDisposable()));
+        let trackedEditor;
+        const updateLabel = () => {
             const activeEditor = editorPart.activeGroup.activeEditor;
             if (activeEditor) {
                 const {
@@ -180,52 +227,233 @@ let ModalEditorPart = class ModalEditorPart {
                     icon: activeEditor.getIcon(),
                     extraClasses: activeEditor.getLabelExtraClasses()
                 });
+                if (trackedEditor !== activeEditor) {
+                    trackedEditor = activeEditor;
+                    labelChangeDisposable.value = activeEditor.onDidChangeLabel(() => updateLabel());
+                }
             } else {
                 label.element.clear();
+                trackedEditor = undefined;
+                labelChangeDisposable.clear();
             }
-            editorPart.notifyActiveEditorChanged();
-        }));
+        };
+        disposables.add(
+            Event.runAndSubscribe(modalEditorService.onDidActiveEditorChange, updateLabel)
+        );
         disposables.add(addDisposableListener(headerElement, EventType.DBLCLICK, e => {
             EventHelper.stop(e);
-            editorPart.toggleMaximized();
+            editorPart.handleHeaderDoubleClick();
+        }));
+        const dragDisposables = disposables.add(( new DisposableStore()));
+        let didDrag = false;
+        disposables.add(addDisposableListener(headerElement, EventType.MOUSE_DOWN, e => {
+            if (editorPart.maximized) {
+                return;
+            }
+            if (e.button !== 0) {
+                return;
+            }
+            const target = e.target;
+            if (target.closest(".monaco-button") || target.closest(".action-item")) {
+                return;
+            }
+            e.preventDefault();
+            dragDisposables.clear();
+            const startX = e.clientX;
+            const startY = e.clientY;
+            const startLeft = parseFloat(resizableElement.domNode.style.left) || 0;
+            const startTop = parseFloat(resizableElement.domNode.style.top) || 0;
+            didDrag = false;
+            const onMouseMove = moveEvent => {
+                didDrag = true;
+                EventHelper.stop(moveEvent, true);
+                const containerDimension = this.layoutService.mainContainerDimension;
+                const titleBarOffset = this.layoutService.mainContainerOffset.top;
+                const dialogWidth = resizableElement.size.width;
+                const dialogHeight = resizableElement.size.height;
+                const minLeft = 0;
+                const minTop = titleBarOffset;
+                const maxLeft = Math.max(minLeft, containerDimension.width - dialogWidth);
+                const maxTop = Math.max(minTop, containerDimension.height - dialogHeight);
+                let newLeft = Math.max(minLeft, Math.min(maxLeft, startLeft + (moveEvent.clientX - startX)));
+                let newTop = Math.max(minTop, Math.min(maxTop, startTop + (moveEvent.clientY - startY)));
+                const centerLeft = (containerDimension.width - dialogWidth) / 2;
+                const centerTop = Math.max(titleBarOffset, (containerDimension.height - dialogHeight) / 2);
+                if (Math.abs(newLeft - centerLeft) < MODAL_SNAP_THRESHOLD && Math.abs(newTop - centerTop) < MODAL_SNAP_THRESHOLD) {
+                    newLeft = centerLeft;
+                    newTop = centerTop;
+                }
+                resizableElement.domNode.style.left = `${newLeft}px`;
+                resizableElement.domNode.style.top = `${newTop}px`;
+            };
+            const onMouseUp = upEvent => {
+                EventHelper.stop(upEvent, true);
+                dragDisposables.clear();
+                if (didDrag) {
+                    const currentLeft = parseFloat(resizableElement.domNode.style.left) || 0;
+                    const currentTop = parseFloat(resizableElement.domNode.style.top) || 0;
+                    const containerDimension = this.layoutService.mainContainerDimension;
+                    const titleBarOffset = this.layoutService.mainContainerOffset.top;
+                    const centerLeft = (containerDimension.width - resizableElement.size.width) / 2;
+                    const centerTop = Math.max(
+                        titleBarOffset,
+                        (containerDimension.height - resizableElement.size.height) / 2
+                    );
+                    if (Math.abs(currentLeft - centerLeft) < 1 && Math.abs(currentTop - centerTop) < 1) {
+                        editorPart.position = undefined;
+                    } else {
+                        editorPart.position = {
+                            left: currentLeft,
+                            top: currentTop
+                        };
+                    }
+                }
+            };
+            dragDisposables.add(addDisposableListener(mainWindow, EventType.MOUSE_MOVE, onMouseMove, true));
+            dragDisposables.add(addDisposableListener(mainWindow, EventType.MOUSE_UP, onMouseUp, true));
         }));
         disposables.add(addDisposableListener(headerElement, EventType.CLICK, e => {
+            const wasDrag = didDrag;
+            didDrag = false;
+            if (wasDrag) {
+                return;
+            }
             EventHelper.stop(e);
             editorPart.activeGroup.focus();
         }));
+        let isResizing = false;
+        let resizeStartLeft = 0;
+        let resizeStartTop = 0;
+        let resizeStartSize = Dimension.None;
+        disposables.add(resizableElement.onDidWillResize(() => {
+            isResizing = true;
+            resizeStartLeft = parseFloat(resizableElement.domNode.style.left) || 0;
+            resizeStartTop = parseFloat(resizableElement.domNode.style.top) || 0;
+            resizeStartSize = ( new Dimension(resizableElement.size.width, resizableElement.size.height));
+        }));
+        disposables.add(resizableElement.onDidResize(e => {
+            if (!e.done) {
+                const containerDimension = this.layoutService.mainContainerDimension;
+                const titleBarOffset = this.layoutService.mainContainerOffset.top;
+                const deltaWidth = e.dimension.width - resizeStartSize.width;
+                const deltaHeight = e.dimension.height - resizeStartSize.height;
+                let newLeft = e.west ? resizeStartLeft - deltaWidth : resizeStartLeft;
+                let newTop = e.north ? resizeStartTop - deltaHeight : resizeStartTop;
+                let newWidth = e.dimension.width;
+                let newHeight = e.dimension.height;
+                if (newLeft < 0) {
+                    newWidth += newLeft;
+                    newLeft = 0;
+                }
+                if (newTop < titleBarOffset) {
+                    newHeight += newTop - titleBarOffset;
+                    newTop = titleBarOffset;
+                }
+                if (newLeft + newWidth > containerDimension.width) {
+                    newWidth = containerDimension.width - newLeft;
+                }
+                if (newTop + newHeight > containerDimension.height) {
+                    newHeight = containerDimension.height - newTop;
+                }
+                if (newWidth !== e.dimension.width || newHeight !== e.dimension.height) {
+                    resizableElement.layout(newHeight, newWidth);
+                }
+                if (e.west) {
+                    resizableElement.domNode.style.left = `${newLeft}px`;
+                }
+                if (e.north) {
+                    resizableElement.domNode.style.top = `${newTop}px`;
+                }
+            }
+            const size = resizableElement.size;
+            editorPart.layout(
+                size.width - MODAL_BORDER_SIZE,
+                size.height - MODAL_BORDER_SIZE - MODAL_HEADER_HEIGHT,
+                0,
+                0
+            );
+            if (e.done) {
+                isResizing = false;
+                const defaultSize = getDefaultSize();
+                if (size.width === defaultSize.width && size.height === defaultSize.height) {
+                    editorPart.size = undefined;
+                    editorPart.position = undefined;
+                    layoutModal();
+                } else {
+                    editorPart.size = ( new Dimension(size.width, size.height));
+                    editorPart.position = {
+                        left: parseFloat(resizableElement.domNode.style.left) || 0,
+                        top: parseFloat(resizableElement.domNode.style.top) || 0
+                    };
+                }
+            }
+        }));
+        const getDefaultSize = () => {
+            const containerDimension = this.layoutService.mainContainerDimension;
+            const titleBarOffset = this.layoutService.mainContainerOffset.top;
+            const availableHeight = Math.max(containerDimension.height - titleBarOffset, 0);
+            const targetWidth = containerDimension.width * 0.8;
+            const targetHeight = availableHeight * 0.8;
+            const width = Math.min(targetWidth, MODAL_MAX_DEFAULT_WIDTH, containerDimension.width);
+            const height = Math.min(targetHeight, MODAL_MAX_DEFAULT_HEIGHT, availableHeight);
+            return ( new Dimension(width, height));
+        };
         const layoutModal = () => {
+            if (isResizing) {
+                return;
+            }
             const containerDimension = this.layoutService.mainContainerDimension;
             const titleBarOffset = this.layoutService.mainContainerOffset.top;
             const availableHeight = Math.max(containerDimension.height - titleBarOffset, 0);
+            const defaultSize = getDefaultSize();
             let width;
             let height;
             if (editorPart.maximized) {
-                const horizontalPadding = 16;
                 const verticalPadding = Math.max(
                     titleBarOffset,
-                    16
+                    MODAL_MAXIMIZED_PADDING
                 );
-                width = Math.max(containerDimension.width - horizontalPadding, 0);
+                width = Math.max(containerDimension.width - MODAL_MAXIMIZED_PADDING, 0);
                 height = Math.max(availableHeight - verticalPadding, 0);
+            } else if (editorPart.size) {
+                width = Math.min(editorPart.size.width, containerDimension.width);
+                height = Math.min(editorPart.size.height, availableHeight);
             } else {
-                const maxWidth = 1400;
-                const maxHeight = 900;
-                const targetWidth = containerDimension.width * 0.8;
-                const targetHeight = availableHeight * 0.8;
-                width = Math.min(targetWidth, maxWidth, containerDimension.width);
-                height = Math.min(targetHeight, maxHeight, availableHeight);
+                width = defaultSize.width;
+                height = defaultSize.height;
             }
             height = Math.min(height, availableHeight);
-            editorPartContainer.style.width = `${width}px`;
-            editorPartContainer.style.height = `${height}px`;
-            const borderSize = 2;
-            const headerHeight = 32 + 1 ;
-            editorPart.layout(width - borderSize, height - borderSize - headerHeight, 0, 0);
+            resizableElement.maxSize = ( new Dimension(containerDimension.width, availableHeight));
+            resizableElement.preferredSize = defaultSize;
+            resizableElement.layout(height, width);
+            const canResize = !editorPart.maximized;
+            resizableElement.enableSashes(canResize, canResize, canResize, canResize);
+            if (!editorPart.maximized && editorPart.position) {
+                const clampedLeft = Math.max(0, Math.min(editorPart.position.left, containerDimension.width - width));
+                const clampedTop = Math.max(
+                    titleBarOffset,
+                    Math.min(editorPart.position.top, titleBarOffset + availableHeight - height)
+                );
+                resizableElement.domNode.style.left = `${clampedLeft}px`;
+                resizableElement.domNode.style.top = `${clampedTop}px`;
+            } else {
+                const left = (containerDimension.width - width) / 2;
+                const top = Math.max(titleBarOffset, (containerDimension.height - height) / 2);
+                resizableElement.domNode.style.left = `${left}px`;
+                resizableElement.domNode.style.top = `${top}px`;
+            }
+            editorPart.layout(
+                width - MODAL_BORDER_SIZE,
+                height - MODAL_BORDER_SIZE - MODAL_HEADER_HEIGHT,
+                0,
+                0
+            );
         };
         disposables.add(
             Event.runAndSubscribe(this.layoutService.onDidLayoutMainContainer, layoutModal)
         );
         disposables.add(editorPart.onDidChangeMaximized(() => layoutModal()));
+        disposables.add(editorPart.onDidRequestLayout(() => layoutModal()));
         this.hostService.setWindowDimmed(mainWindow, true);
         disposables.add(toDisposable(() => this.hostService.setWindowDimmed(mainWindow, false)));
         editorPart.activeGroup.focus();
@@ -247,6 +475,18 @@ let ModalEditorPartImpl = class ModalEditorPartImpl extends EditorPart {
     get maximized() {
         return this._maximized;
     }
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this._position = value;
+    }
     get navigation() {
         return this._navigation;
     }
@@ -264,40 +504,52 @@ let ModalEditorPartImpl = class ModalEditorPartImpl extends EditorPart {
         contextKeyService
     ) {
         const id = ModalEditorPartImpl_1.COUNTER++;
-        super(editorPartsView, `workbench.parts.modalEditor.${id}`, ( localize(3568, "Modal Editor Area")), windowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService);
+        super(editorPartsView, `workbench.parts.modalEditor.${id}`, ( localize(3576, "Modal Editor Area")), windowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService);
         this.modalElement = modalElement;
         this._onWillClose = this._register(( new Emitter()));
         this.onWillClose = this._onWillClose.event;
         this._onDidChangeMaximized = this._register(( new Emitter()));
         this.onDidChangeMaximized = this._onDidChangeMaximized.event;
+        this._onDidRequestLayout = this._register(( new Emitter()));
+        this.onDidRequestLayout = this._onDidRequestLayout.event;
         this._onDidChangeNavigation = this._register(( new Emitter()));
         this.onDidChangeNavigation = this._onDidChangeNavigation.event;
         this.optionsDisposable = this._register(( new MutableDisposable()));
         this.previousMainWindowActiveElement = null;
         this._maximized = options?.maximized ?? false;
+        this._size = options?.size;
+        this._position = options?.position;
         this._navigation = options?.navigation;
+        if (this._maximized) {
+            this.savedSize = this._size;
+            this.savedPosition = this._position;
+        }
         this.enforceModalPartOptions();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(USE_MODAL_EDITOR_SETTING)) {
+                this.enforceModalPartOptions();
+            }
+        }));
     }
     create(parent, options) {
         this.previousMainWindowActiveElement = mainWindow.document.activeElement;
         super.create(parent, options);
     }
     enforceModalPartOptions() {
+        const useModalForAll = this.configurationService.getValue(USE_MODAL_EDITOR_SETTING) === "all";
         const editorCount = this.groups.reduce((count, group) => count + group.count, 0);
+        const showTabs = useModalForAll && editorCount > 1 ? "multiple" : "none";
         this.optionsDisposable.value = this.enforcePartOptions({
-            showTabs: editorCount > 1 ? "multiple" : "none",
+            showTabs,
             enablePreview: true,
             closeEmptyGroups: true,
-            tabActionCloseVisibility: editorCount > 1,
-            editorActionsLocation: "default",
+            tabActionCloseVisibility: showTabs !== "none",
+            editorActionsLocation: "hidden",
             tabHeight: "default",
             wrapTabs: false,
             allowDropIntoGroup: false
         });
     }
-    notifyActiveEditorChanged() {
-        this.enforceModalPartOptions();
-    }
     updateOptions(options) {
         if (typeof options?.maximized === "boolean" && options.maximized !== this._maximized) {
             this.toggleMaximized();
@@ -307,8 +559,30 @@ let ModalEditorPartImpl = class ModalEditorPartImpl extends EditorPart {
     }
     toggleMaximized() {
         this._maximized = !this._maximized;
+        if (this._maximized) {
+            this.savedSize = this._size;
+            this.savedPosition = this._position;
+        } else {
+            this._size = this.savedSize;
+            this._position = this.savedPosition;
+            this.savedSize = undefined;
+            this.savedPosition = undefined;
+        }
         this._onDidChangeMaximized.fire(this._maximized);
     }
+    handleHeaderDoubleClick() {
+        if (this._maximized) {
+            this.savedSize = undefined;
+            this.savedPosition = undefined;
+            this.toggleMaximized();
+        } else if (this._size) {
+            this._size = undefined;
+            this._position = undefined;
+            this._onDidRequestLayout.fire();
+        } else {
+            this.toggleMaximized();
+        }
+    }
     handleContextKeys() {
         const isModalEditorPartContext = EditorPartModalContext.bindTo(this.scopedContextKeyService);
         isModalEditorPartContext.set(true);
@@ -341,36 +615,28 @@ let ModalEditorPartImpl = class ModalEditorPartImpl extends EditorPart {
         } else {
             this.previousMainWindowActiveElement.focus();
         }
-        this.doClose({
-            mergeConfirmingEditorsToMainPart: false
-        });
+        this._onWillClose.fire();
     }
     saveState() {
         return;
     }
-    close(options) {
-        return this.doClose({
-            ...options,
-            mergeConfirmingEditorsToMainPart: true
-        });
-    }
-    doClose(options) {
-        let result = true;
-        if (options?.mergeConfirmingEditorsToMainPart) {
-            if (!options.mergeAllEditorsToMainPart) {
-                for (const group of this.groups) {
-                    group.closeAllEditors({
-                        excludeConfirming: true
-                    });
-                }
-            }
-            result = this.mergeGroupsToMainPart();
+    async close(options) {
+        if (options?.mergeAllEditorsToMainPart) {
+            const result = this.mergeGroupsToMainPart();
             if (!result) {
                 return false;
             }
         }
+        else {
+            for (const group of this.groups) {
+                const closed = await group.closeAllEditors();
+                if (!closed) {
+                    return false;
+                }
+            }
+        }
         this._onWillClose.fire();
-        return result;
+        return true;
     }
     mergeGroupsToMainPart() {
         if (!( this.groups.some(group => group.count > 0))) {

package/vscode/src/vs/workbench/browser/parts/editor/multiEditorTabsControl.js

@@ -651,7 +651,7 @@ let MultiEditorTabsControl = class MultiEditorTabsControl extends EditorTabsCont
             }
         }));
         const tabActionBar = ( new ActionBar(tabActionsContainer, {
-            ariaLabel: ( localize(3569, "Tab actions")),
+            ariaLabel: ( localize(3577, "Tab actions")),
             actionRunner: tabActionRunner
         }));
         const tabActionListener = tabActionBar.onWillRun(e => {

package/vscode/src/vs/workbench/browser/parts/editor/sideBySideEditor.js

@@ -208,7 +208,7 @@ let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewStat
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3570, "Side by Side Editor");
+        return localize(3578, "Side by Side Editor");
     }
     async setInput(input, options, context, token) {
         const oldInput = this.input;

package/vscode/src/vs/workbench/browser/parts/editor/textCodeEditor.js

@@ -20,7 +20,7 @@ class AbstractTextCodeEditor extends AbstractTextEditor {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3571, "Text Editor");
+        return localize(3579, "Text Editor");
     }
     createEditorControl(parent, initialOptions) {
         this.editorControl = this._register(this.instantiationService.createInstance(

package/vscode/src/vs/workbench/browser/parts/editor/textDiffEditor.js

@@ -78,7 +78,7 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
         if (this.input) {
             return this.input.getName();
         }
-        return localize(3572, "Text Diff Editor");
+        return localize(3580, "Text Diff Editor");
     }
     createEditorControl(parent, configuration) {
         this.diffEditorControl = this._register(
@@ -142,13 +142,13 @@ let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
             let message;
             if (error instanceof TooLargeFileOperationError) {
                 message = ( localize(
-                    3573,
+                    3581,
                     "At least one file is not displayed in the text compare editor because it is very large ({0}).",
                     ByteSize.formatSize(error.size)
                 ));
             } else {
                 message = ( localize(
-                    3574,
+                    3582,
                     "At least one file is not displayed in the text compare editor because it is very large."
                 ));
             }

package/vscode/src/vs/workbench/browser/parts/editor/textEditor.js

@@ -103,7 +103,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         return editorConfiguration;
     }
     computeAriaLabel() {
-        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localize(3575, "Editor"));
+        return this.input ? computeEditorAriaLabel(this.input, undefined, this.group, this.editorGroupService.count) : ( localize(3583, "Editor"));
     }
     onDidChangeFileSystemProvider(scheme) {
         if (!this.input) {