@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/browser/layout.js

@@ -1,2059 +0,0 @@
-import { Disposable, DisposableStore, toDisposable, DisposableMap } from '../../base/common/lifecycle.js';
-import { Emitter } from '../../base/common/event.js';
-import { getClientArea, getActiveDocument, getWindows, getWindow, addDisposableListener, EventType, isActiveDocument, getWindowId, getActiveWindow, getActiveElement, isAncestorUsingFlowTo, position, size, computeScreenAwareSize } from '../../base/browser/dom.js';
-import { onDidChangeFullscreen, isFullscreen, isWCOEnabled } from '../../base/browser/browser.js';
-import { IWorkingCopyBackupService } from '../services/workingCopy/common/workingCopyBackup.js';
-import { isWindows, isLinux, isWeb, isMacintosh, isIOS } from '../../base/common/platform.js';
-import { pathsToEditors, isResourceEditorInput } from '../common/editor.js';
-import { SidebarPart } from './parts/sidebar/sidebarPart.js';
-import { PanelPart } from './parts/panel/panelPart.js';
-import { positionFromString, positionToString, shouldShowCustomTitleBar, panelOpensMaximizedFromString } from '../services/layout/browser/layoutService.js';
-import { IWorkspaceContextService, isTemporaryWorkspace } from '../../platform/workspace/common/workspace.js';
-import { IStorageService, WillSaveStateReason } from '../../platform/storage/common/storage.js';
-import { IConfigurationService } from '../../platform/configuration/common/configuration.js';
-import { ITitleService } from '../services/title/browser/titleService.js';
-import { ILifecycleService } from '../services/lifecycle/common/lifecycle.js';
-import { hasNativeTitlebar, getMenuBarVisibility } from '../../platform/window/common/window.js';
-import { IHostService } from '../services/host/browser/host.js';
-import { IBrowserWorkbenchEnvironmentService } from '../services/environment/browser/environmentService.js';
-import { IEditorService } from '../services/editor/common/editorService.js';
-import { IEditorGroupsService } from '../services/editor/common/editorGroupsService.js';
-import { SerializableGrid, Sizing } from '../../base/browser/ui/grid/grid.js';
-import { Part } from './part.js';
-import { IStatusbarService } from '../services/statusbar/browser/statusbar.js';
-import { IFileService } from '../../platform/files/common/files.js';
-import { isCodeEditor } from '../../editor/browser/editorBrowser.js';
-import { coalesce } from '../../base/common/arrays.js';
-import { assertIsDefined } from '../../base/common/types.js';
-import { INotificationService, NotificationsFilter } from '../../platform/notification/common/notification.js';
-import { IThemeService } from '../../platform/theme/common/themeService.js';
-import { WINDOW_ACTIVE_BORDER, WINDOW_INACTIVE_BORDER } from '../common/theme.js';
-import { URI } from '../../base/common/uri.js';
-import { IViewDescriptorService } from '../common/views.js';
-import { DiffEditorInput } from '../common/editor/diffEditorInput.js';
-import { mark } from '../../base/common/performance.js';
-import { IExtensionService } from '../services/extensions/common/extensions.js';
-import { ILogService } from '../../platform/log/common/log.js';
-import { DeferredPromise, Promises } from '../../base/common/async.js';
-import { IBannerService } from '../services/banner/browser/bannerService.js';
-import { IPaneCompositePartService } from '../services/panecomposite/browser/panecomposite.js';
-import { AuxiliaryBarPart } from './parts/auxiliarybar/auxiliaryBarPart.js';
-import { ITelemetryService } from '../../platform/telemetry/common/telemetry.js';
-import { IAuxiliaryWindowService } from '../services/auxiliaryWindow/browser/auxiliaryWindowService.js';
-import { mainWindow } from '../../base/browser/window.js';
-var LayoutClasses;
-( (function(LayoutClasses) {
-    LayoutClasses["SIDEBAR_HIDDEN"] = "nosidebar";
-    LayoutClasses["MAIN_EDITOR_AREA_HIDDEN"] = "nomaineditorarea";
-    LayoutClasses["PANEL_HIDDEN"] = "nopanel";
-    LayoutClasses["AUXILIARYBAR_HIDDEN"] = "noauxiliarybar";
-    LayoutClasses["STATUSBAR_HIDDEN"] = "nostatusbar";
-    LayoutClasses["FULLSCREEN"] = "fullscreen";
-    LayoutClasses["MAXIMIZED"] = "maximized";
-    LayoutClasses["WINDOW_BORDER"] = "border";
-})(LayoutClasses || (LayoutClasses = {})));
-const TITLE_BAR_SETTINGS = [
-    "workbench.activityBar.location" ,
-    "window.commandCenter" ,
-    "workbench.editor.editorActionsLocation" ,
-    "workbench.layoutControl.enabled" ,
-    'window.menuBarVisibility',
-    "window.titleBarStyle" ,
-    "window.customTitleBarVisibility" ,
-];
-class Layout extends Disposable {
-    get activeContainer() { return this.getContainerFromDocument(getActiveDocument()); }
-    get containers() {
-        const containers = [];
-        for (const { window } of getWindows()) {
-            containers.push(this.getContainerFromDocument(window.document));
-        }
-        return containers;
-    }
-    getContainerFromDocument(targetDocument) {
-        if (targetDocument === this.mainContainer.ownerDocument) {
-            return this.mainContainer;
-        }
-        else {
-            return targetDocument.body.getElementsByClassName('monaco-workbench')[0];
-        }
-    }
-    whenContainerStylesLoaded(window) {
-        return this.containerStylesLoaded.get(window.vscodeWindowId);
-    }
-    get mainContainerDimension() { return this._mainContainerDimension; }
-    get activeContainerDimension() {
-        return this.getContainerDimension(this.activeContainer);
-    }
-    getContainerDimension(container) {
-        if (container === this.mainContainer) {
-            return this.mainContainerDimension;
-        }
-        else {
-            return getClientArea(container);
-        }
-    }
-    get mainContainerOffset() {
-        return this.computeContainerOffset(mainWindow);
-    }
-    get activeContainerOffset() {
-        return this.computeContainerOffset(getWindow(this.activeContainer));
-    }
-    computeContainerOffset(targetWindow) {
-        let top = 0;
-        let quickPickTop = 0;
-        if (this.isVisible("workbench.parts.banner" )) {
-            top = this.getPart("workbench.parts.banner" ).maximumHeight;
-            quickPickTop = top;
-        }
-        const titlebarVisible = this.isVisible("workbench.parts.titlebar" , targetWindow);
-        if (titlebarVisible) {
-            top += this.getPart("workbench.parts.titlebar" ).maximumHeight;
-            quickPickTop = top;
-        }
-        const isCommandCenterVisible = titlebarVisible && this.configurationService.getValue("window.commandCenter" ) !== false;
-        if (isCommandCenterVisible) {
-            quickPickTop = 6;
-        }
-        return { top, quickPickTop };
-    }
-    constructor(parent) {
-        super();
-        this.parent = parent;
-        this._onDidChangeZenMode = this._register(( new Emitter()));
-        this.onDidChangeZenMode = this._onDidChangeZenMode.event;
-        this._onDidChangeMainEditorCenteredLayout = this._register(( new Emitter()));
-        this.onDidChangeMainEditorCenteredLayout = this._onDidChangeMainEditorCenteredLayout.event;
-        this._onDidChangePanelAlignment = this._register(( new Emitter()));
-        this.onDidChangePanelAlignment = this._onDidChangePanelAlignment.event;
-        this._onDidChangeWindowMaximized = this._register(( new Emitter()));
-        this.onDidChangeWindowMaximized = this._onDidChangeWindowMaximized.event;
-        this._onDidChangePanelPosition = this._register(( new Emitter()));
-        this.onDidChangePanelPosition = this._onDidChangePanelPosition.event;
-        this._onDidChangePartVisibility = this._register(( new Emitter()));
-        this.onDidChangePartVisibility = this._onDidChangePartVisibility.event;
-        this._onDidChangeNotificationsVisibility = this._register(( new Emitter()));
-        this.onDidChangeNotificationsVisibility = this._onDidChangeNotificationsVisibility.event;
-        this._onDidLayoutMainContainer = this._register(( new Emitter()));
-        this.onDidLayoutMainContainer = this._onDidLayoutMainContainer.event;
-        this._onDidLayoutActiveContainer = this._register(( new Emitter()));
-        this.onDidLayoutActiveContainer = this._onDidLayoutActiveContainer.event;
-        this._onDidLayoutContainer = this._register(( new Emitter()));
-        this.onDidLayoutContainer = this._onDidLayoutContainer.event;
-        this._onDidAddContainer = this._register(( new Emitter()));
-        this.onDidAddContainer = this._onDidAddContainer.event;
-        this._onDidChangeActiveContainer = this._register(( new Emitter()));
-        this.onDidChangeActiveContainer = this._onDidChangeActiveContainer.event;
-        this.mainContainer = document.createElement('div');
-        this.containerStylesLoaded = ( new Map());
-        this.parts = ( new Map());
-        this.initialized = false;
-        this.disposed = false;
-        this._openedDefaultEditors = false;
-        this.whenReadyPromise = ( new DeferredPromise());
-        this.whenReady = this.whenReadyPromise.p;
-        this.whenRestoredPromise = ( new DeferredPromise());
-        this.whenRestored = this.whenRestoredPromise.p;
-        this.restored = false;
-    }
-    initLayout(accessor) {
-        this.environmentService = accessor.get(IBrowserWorkbenchEnvironmentService);
-        this.configurationService = accessor.get(IConfigurationService);
-        this.hostService = accessor.get(IHostService);
-        this.contextService = accessor.get(IWorkspaceContextService);
-        this.storageService = accessor.get(IStorageService);
-        this.workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
-        this.themeService = accessor.get(IThemeService);
-        this.extensionService = accessor.get(IExtensionService);
-        this.logService = accessor.get(ILogService);
-        this.telemetryService = accessor.get(ITelemetryService);
-        this.auxiliaryWindowService = accessor.get(IAuxiliaryWindowService);
-        this.editorService = accessor.get(IEditorService);
-        this.mainPartEditorService = this.editorService.createScoped('main', this._store);
-        this.editorGroupService = accessor.get(IEditorGroupsService);
-        this.paneCompositeService = accessor.get(IPaneCompositePartService);
-        this.viewDescriptorService = accessor.get(IViewDescriptorService);
-        this.titleService = accessor.get(ITitleService);
-        this.notificationService = accessor.get(INotificationService);
-        this.statusBarService = accessor.get(IStatusbarService);
-        accessor.get(IBannerService);
-        this.registerLayoutListeners();
-        this.initLayoutState(accessor.get(ILifecycleService), accessor.get(IFileService));
-    }
-    registerLayoutListeners() {
-        const showEditorIfHidden = () => {
-            if (!this.isVisible("workbench.parts.editor" , mainWindow)) {
-                this.toggleMaximizedPanel();
-            }
-        };
-        this.editorGroupService.whenRestored.then(() => {
-            this._register(this.mainPartEditorService.onDidVisibleEditorsChange(showEditorIfHidden));
-            this._register(this.editorGroupService.mainPart.onDidActivateGroup(showEditorIfHidden));
-            this._register(this.mainPartEditorService.onDidActiveEditorChange(() => this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED))));
-        });
-        this._register(this.configurationService.onDidChangeConfiguration((e) => {
-            if (( [
-                ...TITLE_BAR_SETTINGS,
-                LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION,
-                LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE,
-            ].some(setting => e.affectsConfiguration(setting)))) {
-                const editorActionsMovedToTitlebar = e.affectsConfiguration("workbench.editor.editorActionsLocation" ) && this.configurationService.getValue("workbench.editor.editorActionsLocation" ) === "titleBar" ;
-                let activityBarMovedToTopOrBottom = false;
-                if (e.affectsConfiguration("workbench.activityBar.location" )) {
-                    const activityBarPosition = this.configurationService.getValue("workbench.activityBar.location" );
-                    activityBarMovedToTopOrBottom = activityBarPosition === "top"  || activityBarPosition === "bottom" ;
-                }
-                if (activityBarMovedToTopOrBottom || editorActionsMovedToTitlebar) {
-                    if (this.configurationService.getValue("window.customTitleBarVisibility" ) === "never" ) {
-                        this.configurationService.updateValue("window.customTitleBarVisibility" , "auto" );
-                    }
-                }
-                this.doUpdateLayoutConfiguration();
-            }
-        }));
-        this._register(onDidChangeFullscreen(windowId => this.onFullscreenChanged(windowId)));
-        this._register(this.editorGroupService.mainPart.onDidAddGroup(() => this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED))));
-        this._register(this.editorGroupService.mainPart.onDidRemoveGroup(() => this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED))));
-        this._register(this.editorGroupService.mainPart.onDidChangeGroupMaximized(() => this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED))));
-        this._register(addDisposableListener(this.mainContainer, EventType.SCROLL, () => this.mainContainer.scrollTop = 0));
-        const showingCustomMenu = (isWindows || isLinux || isWeb) && !hasNativeTitlebar(this.configurationService);
-        if (showingCustomMenu) {
-            this._register(this.titleService.onMenubarVisibilityChange(visible => this.onMenubarToggled(visible)));
-        }
-        this._register(this.themeService.onDidColorThemeChange(() => this.updateWindowsBorder()));
-        this._register(this.hostService.onDidChangeFocus(focused => this.onWindowFocusChanged(focused)));
-        this._register(this.hostService.onDidChangeActiveWindow(() => this.onActiveWindowChanged()));
-        if (isWeb && typeof navigator.windowControlsOverlay === 'object') {
-            this._register(addDisposableListener(navigator.windowControlsOverlay, 'geometrychange', () => this.onDidChangeWCO()));
-        }
-        this._register(this.auxiliaryWindowService.onDidOpenAuxiliaryWindow(({ window, disposables }) => {
-            const windowId = window.window.vscodeWindowId;
-            this.containerStylesLoaded.set(windowId, window.whenStylesHaveLoaded);
-            window.whenStylesHaveLoaded.then(() => this.containerStylesLoaded.delete(windowId));
-            disposables.add(toDisposable(() => this.containerStylesLoaded.delete(windowId)));
-            const eventDisposables = disposables.add(( new DisposableStore()));
-            this._onDidAddContainer.fire({ container: window.container, disposables: eventDisposables });
-            disposables.add(window.onDidLayout(dimension => this.handleContainerDidLayout(window.container, dimension)));
-        }));
-    }
-    onMenubarToggled(visible) {
-        if (visible !== this.state.runtime.menuBar.toggled) {
-            this.state.runtime.menuBar.toggled = visible;
-            const menuBarVisibility = getMenuBarVisibility(this.configurationService);
-            if (isWeb && menuBarVisibility === 'toggle') {
-                this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled));
-            }
-            else if (this.state.runtime.mainWindowFullscreen && (menuBarVisibility === 'toggle' || menuBarVisibility === 'classic')) {
-                this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled));
-            }
-            this.handleContainerDidLayout(this.mainContainer, this._mainContainerDimension);
-        }
-    }
-    handleContainerDidLayout(container, dimension) {
-        if (container === this.mainContainer) {
-            this._onDidLayoutMainContainer.fire(dimension);
-        }
-        if (isActiveDocument(container)) {
-            this._onDidLayoutActiveContainer.fire(dimension);
-        }
-        this._onDidLayoutContainer.fire({ container, dimension });
-    }
-    onFullscreenChanged(windowId) {
-        if (windowId !== mainWindow.vscodeWindowId) {
-            return;
-        }
-        this.state.runtime.mainWindowFullscreen = isFullscreen(mainWindow);
-        if (this.state.runtime.mainWindowFullscreen) {
-            this.mainContainer.classList.add(LayoutClasses.FULLSCREEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.FULLSCREEN);
-            const zenModeExitInfo = this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_EXIT_INFO);
-            const zenModeActive = this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-            if (zenModeExitInfo.transitionedToFullScreen && zenModeActive) {
-                this.toggleZenMode();
-            }
-        }
-        this.workbenchGrid.edgeSnapping = this.state.runtime.mainWindowFullscreen;
-        {
-            this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled));
-            this.updateWindowsBorder(true);
-        }
-    }
-    onActiveWindowChanged() {
-        const activeContainerId = this.getActiveContainerId();
-        if (this.state.runtime.activeContainerId !== activeContainerId) {
-            this.state.runtime.activeContainerId = activeContainerId;
-            this.updateWindowsBorder();
-            this._onDidChangeActiveContainer.fire();
-        }
-    }
-    onWindowFocusChanged(hasFocus) {
-        if (this.state.runtime.hasFocus !== hasFocus) {
-            this.state.runtime.hasFocus = hasFocus;
-            this.updateWindowsBorder();
-        }
-    }
-    getActiveContainerId() {
-        const activeContainer = this.activeContainer;
-        return getWindow(activeContainer).vscodeWindowId;
-    }
-    doUpdateLayoutConfiguration(skipLayout) {
-        this.updateCustomTitleBarVisibility();
-        this.updateMenubarVisibility(!!skipLayout);
-        this.editorGroupService.whenRestored.then(() => {
-            this.centerMainEditorLayout(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED), skipLayout);
-        });
-    }
-    setSideBarPosition(position) {
-        const activityBar = this.getPart("workbench.parts.activitybar" );
-        const sideBar = this.getPart("workbench.parts.sidebar" );
-        const auxiliaryBar = this.getPart("workbench.parts.auxiliarybar" );
-        const newPositionValue = ((position === 0) ) ? 'left' : 'right';
-        const oldPositionValue = ((position === 1) ) ? 'left' : 'right';
-        const panelAlignment = this.getPanelAlignment();
-        const panelPosition = this.getPanelPosition();
-        this.stateModel.setRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON, position);
-        const activityBarContainer = assertIsDefined(activityBar.getContainer());
-        const sideBarContainer = assertIsDefined(sideBar.getContainer());
-        const auxiliaryBarContainer = assertIsDefined(auxiliaryBar.getContainer());
-        activityBarContainer.classList.remove(oldPositionValue);
-        sideBarContainer.classList.remove(oldPositionValue);
-        activityBarContainer.classList.add(newPositionValue);
-        sideBarContainer.classList.add(newPositionValue);
-        auxiliaryBarContainer.classList.remove(newPositionValue);
-        auxiliaryBarContainer.classList.add(oldPositionValue);
-        activityBar.updateStyles();
-        sideBar.updateStyles();
-        auxiliaryBar.updateStyles();
-        this.adjustPartPositions(position, panelAlignment, panelPosition);
-    }
-    updateWindowsBorder(skipLayout = false) {
-        if (isWeb ||
-            isWindows ||
-            hasNativeTitlebar(this.configurationService)) {
-            return;
-        }
-        const theme = this.themeService.getColorTheme();
-        const activeBorder = theme.getColor(WINDOW_ACTIVE_BORDER);
-        const inactiveBorder = theme.getColor(WINDOW_INACTIVE_BORDER);
-        const didHaveMainWindowBorder = this.hasMainWindowBorder();
-        for (const container of this.containers) {
-            const isMainContainer = container === this.mainContainer;
-            const isActiveContainer = this.activeContainer === container;
-            const containerWindowId = getWindowId(getWindow(container));
-            let windowBorder = false;
-            if (!this.state.runtime.mainWindowFullscreen && !( this.state.runtime.maximized.has(containerWindowId)) && (activeBorder || inactiveBorder)) {
-                windowBorder = true;
-                const borderColor = isActiveContainer && this.state.runtime.hasFocus ? activeBorder : inactiveBorder ?? activeBorder;
-                container.style.setProperty('--window-border-color', borderColor?.toString() ?? 'transparent');
-            }
-            if (isMainContainer) {
-                this.state.runtime.mainWindowBorder = windowBorder;
-            }
-            container.classList.toggle(LayoutClasses.WINDOW_BORDER, windowBorder);
-        }
-        if (!skipLayout && didHaveMainWindowBorder !== this.hasMainWindowBorder()) {
-            this.layout();
-        }
-    }
-    initLayoutState(lifecycleService, fileService) {
-        this.stateModel = ( new LayoutStateModel(
-            this.storageService,
-            this.configurationService,
-            this.contextService,
-            this.parent
-        ));
-        this.stateModel.load();
-        if (this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN) && this.stateModel.getRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN)) {
-            this.stateModel.setRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN, false);
-        }
-        this.stateModel.onDidChangeState(change => {
-            if (change.key === LayoutStateKeys.ACTIVITYBAR_HIDDEN) {
-                this.setActivityBarHidden(change.value);
-            }
-            if (change.key === LayoutStateKeys.STATUSBAR_HIDDEN) {
-                this.setStatusBarHidden(change.value);
-            }
-            if (change.key === LayoutStateKeys.SIDEBAR_POSITON) {
-                this.setSideBarPosition(change.value);
-            }
-            if (change.key === LayoutStateKeys.PANEL_POSITION) {
-                this.setPanelPosition(change.value);
-            }
-            if (change.key === LayoutStateKeys.PANEL_ALIGNMENT) {
-                this.setPanelAlignment(change.value);
-            }
-            this.doUpdateLayoutConfiguration();
-        });
-        const initialEditorsState = this.getInitialEditorsState();
-        if (initialEditorsState) {
-            this.logService.info('Initial editor state', initialEditorsState);
-        }
-        const initialLayoutState = {
-            layout: {
-                editors: initialEditorsState?.layout
-            },
-            editor: {
-                restoreEditors: this.shouldRestoreEditors(this.contextService, initialEditorsState),
-                editorsToOpen: this.resolveEditorsToOpen(fileService, initialEditorsState),
-            },
-            views: {
-                defaults: this.getDefaultLayoutViews(this.environmentService, this.storageService),
-                containerToRestore: {}
-            }
-        };
-        const layoutRuntimeState = {
-            activeContainerId: this.getActiveContainerId(),
-            mainWindowFullscreen: isFullscreen(mainWindow),
-            hasFocus: this.hostService.hasFocus,
-            maximized: ( new Set()),
-            mainWindowBorder: false,
-            menuBar: {
-                toggled: false,
-            },
-            zenMode: {
-                transitionDisposables: ( new DisposableMap()),
-            }
-        };
-        this.state = {
-            initialization: initialLayoutState,
-            runtime: layoutRuntimeState,
-        };
-        if (this.isVisible("workbench.parts.sidebar" )) {
-            let viewContainerToRestore;
-            if (!this.environmentService.isBuilt || lifecycleService.startupKind === 3 ) {
-                viewContainerToRestore = this.storageService.get(SidebarPart.activeViewletSettingsKey, 1 , this.viewDescriptorService.getDefaultViewContainer(0 )?.id);
-            }
-            else {
-                viewContainerToRestore = this.viewDescriptorService.getDefaultViewContainer(0 )?.id;
-            }
-            if (viewContainerToRestore) {
-                this.state.initialization.views.containerToRestore.sideBar = viewContainerToRestore;
-            }
-            else {
-                this.stateModel.setRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN, true);
-            }
-        }
-        if (this.isVisible("workbench.parts.panel" )) {
-            const viewContainerToRestore = this.storageService.get(PanelPart.activePanelSettingsKey, 1 , this.viewDescriptorService.getDefaultViewContainer(1 )?.id);
-            if (viewContainerToRestore) {
-                this.state.initialization.views.containerToRestore.panel = viewContainerToRestore;
-            }
-            else {
-                this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_HIDDEN, true);
-            }
-        }
-        if (this.isVisible("workbench.parts.auxiliarybar" )) {
-            const viewContainerToRestore = this.storageService.get(AuxiliaryBarPart.activePanelSettingsKey, 1 , this.viewDescriptorService.getDefaultViewContainer(2 )?.id);
-            if (viewContainerToRestore) {
-                this.state.initialization.views.containerToRestore.auxiliaryBar = viewContainerToRestore;
-            }
-            else {
-                this.stateModel.setRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN, true);
-            }
-        }
-        this.updateWindowsBorder(true);
-    }
-    getDefaultLayoutViews(environmentService, storageService) {
-        const defaultLayout = environmentService.options?.defaultLayout;
-        if (!defaultLayout) {
-            return undefined;
-        }
-        if (!defaultLayout.force && !storageService.isNew(1 )) {
-            return undefined;
-        }
-        const { views } = defaultLayout;
-        if (views?.length) {
-            return ( views.map(view => view.id));
-        }
-        return undefined;
-    }
-    shouldRestoreEditors(contextService, initialEditorsState) {
-        if (isTemporaryWorkspace(contextService.getWorkspace())) {
-            return false;
-        }
-        const forceRestoreEditors = this.configurationService.getValue('window.restoreWindows') === 'preserve';
-        return !!forceRestoreEditors || initialEditorsState === undefined;
-    }
-    willRestoreEditors() {
-        return this.state.initialization.editor.restoreEditors;
-    }
-    async resolveEditorsToOpen(fileService, initialEditorsState) {
-        if (initialEditorsState) {
-            const filesToMerge = coalesce(await pathsToEditors(initialEditorsState.filesToMerge, fileService, this.logService));
-            if (filesToMerge.length === 4 && isResourceEditorInput(filesToMerge[0]) && isResourceEditorInput(filesToMerge[1]) && isResourceEditorInput(filesToMerge[2]) && isResourceEditorInput(filesToMerge[3])) {
-                return [{
-                        editor: {
-                            input1: { resource: filesToMerge[0].resource },
-                            input2: { resource: filesToMerge[1].resource },
-                            base: { resource: filesToMerge[2].resource },
-                            result: { resource: filesToMerge[3].resource },
-                            options: { pinned: true }
-                        }
-                    }];
-            }
-            const filesToDiff = coalesce(await pathsToEditors(initialEditorsState.filesToDiff, fileService, this.logService));
-            if (filesToDiff.length === 2) {
-                return [{
-                        editor: {
-                            original: { resource: filesToDiff[0].resource },
-                            modified: { resource: filesToDiff[1].resource },
-                            options: { pinned: true }
-                        }
-                    }];
-            }
-            const filesToOpenOrCreate = [];
-            const resolvedFilesToOpenOrCreate = await pathsToEditors(initialEditorsState.filesToOpenOrCreate, fileService, this.logService);
-            for (let i = 0; i < resolvedFilesToOpenOrCreate.length; i++) {
-                const resolvedFileToOpenOrCreate = resolvedFilesToOpenOrCreate[i];
-                if (resolvedFileToOpenOrCreate) {
-                    filesToOpenOrCreate.push({
-                        editor: resolvedFileToOpenOrCreate,
-                        viewColumn: initialEditorsState.filesToOpenOrCreate?.[i].viewColumn
-                    });
-                }
-            }
-            return filesToOpenOrCreate;
-        }
-        else if (this.contextService.getWorkbenchState() === 1  && this.configurationService.getValue('workbench.startupEditor') === 'newUntitledFile') {
-            if (this.editorGroupService.hasRestorableState) {
-                return [];
-            }
-            const hasBackups = await this.workingCopyBackupService.hasBackups();
-            if (hasBackups) {
-                return [];
-            }
-            return [{
-                    editor: { resource: undefined }
-                }];
-        }
-        return [];
-    }
-    get openedDefaultEditors() { return this._openedDefaultEditors; }
-    getInitialEditorsState() {
-        const defaultLayout = this.environmentService.options?.defaultLayout;
-        if ((defaultLayout?.editors?.length || defaultLayout?.layout?.editors) && (defaultLayout.force || this.storageService.isNew(1 ))) {
-            this._openedDefaultEditors = true;
-            return {
-                layout: defaultLayout.layout?.editors,
-                filesToOpenOrCreate: defaultLayout?.editors?.map(editor => {
-                    return {
-                        viewColumn: editor.viewColumn,
-                        fileUri: URI.revive(editor.uri),
-                        openOnlyIfExists: editor.openOnlyIfExists,
-                        options: editor.options
-                    };
-                })
-            };
-        }
-        const { filesToOpenOrCreate, filesToDiff, filesToMerge } = this.environmentService;
-        if (filesToOpenOrCreate || filesToDiff || filesToMerge) {
-            return { filesToOpenOrCreate, filesToDiff, filesToMerge };
-        }
-        return undefined;
-    }
-    isRestored() {
-        return this.restored;
-    }
-    restoreParts() {
-        const layoutReadyPromises = [];
-        const layoutRestoredPromises = [];
-        layoutReadyPromises.push((async () => {
-            mark('code/willRestoreEditors');
-            await this.editorGroupService.whenReady;
-            mark('code/restoreEditors/editorGroupsReady');
-            if (this.state.initialization.layout?.editors) {
-                this.editorGroupService.mainPart.applyLayout(this.state.initialization.layout.editors);
-            }
-            const editors = await this.state.initialization.editor.editorsToOpen;
-            mark('code/restoreEditors/editorsToOpenResolved');
-            let openEditorsPromise = undefined;
-            if (editors.length) {
-                const editorGroupsInVisualOrder = this.editorGroupService.mainPart.getGroups(2 );
-                const mapEditorsToGroup = ( new Map());
-                for (const editor of editors) {
-                    const group = editorGroupsInVisualOrder[(editor.viewColumn ?? 1) - 1];
-                    let editorsByGroup = mapEditorsToGroup.get(group.id);
-                    if (!editorsByGroup) {
-                        editorsByGroup = ( new Set());
-                        mapEditorsToGroup.set(group.id, editorsByGroup);
-                    }
-                    editorsByGroup.add(editor.editor);
-                }
-                openEditorsPromise = Promise.all(( Array.from(mapEditorsToGroup).map(async ([groupId, editors]) => {
-                    try {
-                        await this.editorService.openEditors(Array.from(editors), groupId, { validateTrust: true });
-                    }
-                    catch (error) {
-                        this.logService.error(error);
-                    }
-                })));
-            }
-            layoutRestoredPromises.push(Promise.all([
-                openEditorsPromise?.finally(() => mark('code/restoreEditors/editorsOpened')),
-                this.editorGroupService.whenRestored.finally(() => mark('code/restoreEditors/editorGroupsRestored'))
-            ]).finally(() => {
-                mark('code/didRestoreEditors');
-            }));
-        })());
-        const restoreDefaultViewsPromise = (async () => {
-            if (this.state.initialization.views.defaults?.length) {
-                mark('code/willOpenDefaultViews');
-                const locationsRestored = [];
-                const tryOpenView = (view) => {
-                    const location = this.viewDescriptorService.getViewLocationById(view.id);
-                    if (location !== null) {
-                        const container = this.viewDescriptorService.getViewContainerByViewId(view.id);
-                        if (container) {
-                            if (view.order >= (locationsRestored?.[location]?.order ?? 0)) {
-                                locationsRestored[location] = { id: container.id, order: view.order };
-                            }
-                            const containerModel = this.viewDescriptorService.getViewContainerModel(container);
-                            containerModel.setCollapsed(view.id, false);
-                            containerModel.setVisible(view.id, true);
-                            return true;
-                        }
-                    }
-                    return false;
-                };
-                const defaultViews = ( [...this.state.initialization.views.defaults].reverse().map((v, index) => ({ id: v, order: index })));
-                let i = defaultViews.length;
-                while (i) {
-                    i--;
-                    if (tryOpenView(defaultViews[i])) {
-                        defaultViews.splice(i, 1);
-                    }
-                }
-                if (defaultViews.length) {
-                    await this.extensionService.whenInstalledExtensionsRegistered();
-                    let i = defaultViews.length;
-                    while (i) {
-                        i--;
-                        if (tryOpenView(defaultViews[i])) {
-                            defaultViews.splice(i, 1);
-                        }
-                    }
-                }
-                if (locationsRestored[0 ]) {
-                    this.state.initialization.views.containerToRestore.sideBar = locationsRestored[0 ].id;
-                }
-                if (locationsRestored[1 ]) {
-                    this.state.initialization.views.containerToRestore.panel = locationsRestored[1 ].id;
-                }
-                if (locationsRestored[2 ]) {
-                    this.state.initialization.views.containerToRestore.auxiliaryBar = locationsRestored[2 ].id;
-                }
-                mark('code/didOpenDefaultViews');
-            }
-        })();
-        layoutReadyPromises.push(restoreDefaultViewsPromise);
-        layoutReadyPromises.push((async () => {
-            await restoreDefaultViewsPromise;
-            if (!this.state.initialization.views.containerToRestore.sideBar) {
-                return;
-            }
-            mark('code/willRestoreViewlet');
-            const viewlet = await this.paneCompositeService.openPaneComposite(this.state.initialization.views.containerToRestore.sideBar, 0 );
-            if (!viewlet) {
-                await this.paneCompositeService.openPaneComposite(this.viewDescriptorService.getDefaultViewContainer(0 )?.id, 0 );
-            }
-            mark('code/didRestoreViewlet');
-        })());
-        layoutReadyPromises.push((async () => {
-            await restoreDefaultViewsPromise;
-            if (!this.state.initialization.views.containerToRestore.panel) {
-                return;
-            }
-            mark('code/willRestorePanel');
-            const panel = await this.paneCompositeService.openPaneComposite(this.state.initialization.views.containerToRestore.panel, 1 );
-            if (!panel) {
-                await this.paneCompositeService.openPaneComposite(this.viewDescriptorService.getDefaultViewContainer(1 )?.id, 1 );
-            }
-            mark('code/didRestorePanel');
-        })());
-        layoutReadyPromises.push((async () => {
-            await restoreDefaultViewsPromise;
-            if (!this.state.initialization.views.containerToRestore.auxiliaryBar) {
-                return;
-            }
-            mark('code/willRestoreAuxiliaryBar');
-            const panel = await this.paneCompositeService.openPaneComposite(this.state.initialization.views.containerToRestore.auxiliaryBar, 2 );
-            if (!panel) {
-                await this.paneCompositeService.openPaneComposite(this.viewDescriptorService.getDefaultViewContainer(2 )?.id, 2 );
-            }
-            mark('code/didRestoreAuxiliaryBar');
-        })());
-        const zenModeWasActive = this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-        const restoreZenMode = getZenModeConfiguration(this.configurationService).restore;
-        if (zenModeWasActive) {
-            this.stateModel.setRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE, !restoreZenMode);
-            this.toggleZenMode(false, true);
-        }
-        if (this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED)) {
-            this.centerMainEditorLayout(true, true);
-        }
-        Promises.settled(layoutReadyPromises).finally(() => {
-            this.whenReadyPromise.complete();
-            Promises.settled(layoutRestoredPromises).finally(() => {
-                this.restored = true;
-                this.whenRestoredPromise.complete();
-            });
-        });
-    }
-    registerPart(part) {
-        const id = part.getId();
-        this.parts.set(id, part);
-        return toDisposable(() => this.parts.delete(id));
-    }
-    getPart(key) {
-        const part = this.parts.get(key);
-        if (!part) {
-            throw new Error(`Unknown part ${key}`);
-        }
-        return part;
-    }
-    registerNotifications(delegate) {
-        this._register(delegate.onDidChangeNotificationsVisibility(visible => this._onDidChangeNotificationsVisibility.fire(visible)));
-    }
-    hasFocus(part) {
-        const container = this.getContainer(getActiveWindow(), part);
-        if (!container) {
-            return false;
-        }
-        const activeElement = getActiveElement();
-        if (!activeElement) {
-            return false;
-        }
-        return isAncestorUsingFlowTo(activeElement, container);
-    }
-    focusPart(part, targetWindow = mainWindow) {
-        const container = this.getContainer(targetWindow, part) ?? this.mainContainer;
-        switch (part) {
-            case "workbench.parts.editor" :
-                this.editorGroupService.getPart(container).activeGroup.focus();
-                break;
-            case "workbench.parts.panel" : {
-                this.paneCompositeService.getActivePaneComposite(1 )?.focus();
-                break;
-            }
-            case "workbench.parts.sidebar" : {
-                this.paneCompositeService.getActivePaneComposite(0 )?.focus();
-                break;
-            }
-            case "workbench.parts.activitybar" :
-                this.getPart("workbench.parts.sidebar" ).focusActivityBar();
-                break;
-            case "workbench.parts.statusbar" :
-                this.statusBarService.getPart(container).focus();
-                break;
-            default: {
-                container?.focus();
-            }
-        }
-    }
-    getContainer(targetWindow, part) {
-        if (typeof part === 'undefined') {
-            return this.getContainerFromDocument(targetWindow.document);
-        }
-        if (targetWindow === mainWindow) {
-            return this.getPart(part).getContainer();
-        }
-        let partCandidate;
-        if (part === "workbench.parts.editor" ) {
-            partCandidate = this.editorGroupService.getPart(this.getContainerFromDocument(targetWindow.document));
-        }
-        else if (part === "workbench.parts.statusbar" ) {
-            partCandidate = this.statusBarService.getPart(this.getContainerFromDocument(targetWindow.document));
-        }
-        else if (part === "workbench.parts.titlebar" ) {
-            partCandidate = this.titleService.getPart(this.getContainerFromDocument(targetWindow.document));
-        }
-        if (partCandidate instanceof Part) {
-            return partCandidate.getContainer();
-        }
-        return undefined;
-    }
-    isVisible(part, targetWindow = mainWindow) {
-        if (targetWindow !== mainWindow && part === "workbench.parts.editor" ) {
-            return true;
-        }
-        if (this.initialized) {
-            switch (part) {
-                case "workbench.parts.titlebar" :
-                    return this.workbenchGrid.isViewVisible(this.titleBarPartView);
-                case "workbench.parts.sidebar" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN);
-                case "workbench.parts.panel" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN);
-                case "workbench.parts.auxiliarybar" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN);
-                case "workbench.parts.statusbar" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN);
-                case "workbench.parts.activitybar" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN);
-                case "workbench.parts.editor" :
-                    return !this.stateModel.getRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN);
-                case "workbench.parts.banner" :
-                    return this.workbenchGrid.isViewVisible(this.bannerPartView);
-                default:
-                    return false;
-            }
-        }
-        switch (part) {
-            case "workbench.parts.titlebar" :
-                return shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled);
-            case "workbench.parts.sidebar" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN);
-            case "workbench.parts.panel" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN);
-            case "workbench.parts.auxiliarybar" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN);
-            case "workbench.parts.statusbar" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN);
-            case "workbench.parts.activitybar" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN);
-            case "workbench.parts.editor" :
-                return !this.stateModel.getRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN);
-            default:
-                return false;
-        }
-    }
-    shouldShowBannerFirst() {
-        return isWeb && !isWCOEnabled();
-    }
-    focus() {
-        this.focusPart("workbench.parts.editor" , getWindow(this.activeContainer));
-    }
-    focusPanelOrEditor() {
-        const activePanel = this.paneCompositeService.getActivePaneComposite(1 );
-        if ((this.hasFocus("workbench.parts.panel" ) || !this.isVisible("workbench.parts.editor" )) && activePanel) {
-            activePanel.focus();
-        }
-        else {
-            this.focus();
-        }
-    }
-    getMaximumEditorDimensions(container) {
-        const targetWindow = getWindow(container);
-        const containerDimension = this.getContainerDimension(container);
-        if (container === this.mainContainer) {
-            const panelPosition = this.getPanelPosition();
-            const isColumn = panelPosition === 1  || panelPosition === 0 ;
-            const takenWidth = (this.isVisible("workbench.parts.activitybar" ) ? this.activityBarPartView.minimumWidth : 0) +
-                (this.isVisible("workbench.parts.sidebar" ) ? this.sideBarPartView.minimumWidth : 0) +
-                (this.isVisible("workbench.parts.panel" ) && isColumn ? this.panelPartView.minimumWidth : 0) +
-                (this.isVisible("workbench.parts.auxiliarybar" ) ? this.auxiliaryBarPartView.minimumWidth : 0);
-            const takenHeight = (this.isVisible("workbench.parts.titlebar" , targetWindow) ? this.titleBarPartView.minimumHeight : 0) +
-                (this.isVisible("workbench.parts.statusbar" , targetWindow) ? this.statusBarPartView.minimumHeight : 0) +
-                (this.isVisible("workbench.parts.panel" ) && !isColumn ? this.panelPartView.minimumHeight : 0);
-            const availableWidth = containerDimension.width - takenWidth;
-            const availableHeight = containerDimension.height - takenHeight;
-            return { width: availableWidth, height: availableHeight };
-        }
-        else {
-            const takenHeight = (this.isVisible("workbench.parts.titlebar" , targetWindow) ? this.titleBarPartView.minimumHeight : 0) +
-                (this.isVisible("workbench.parts.statusbar" , targetWindow) ? this.statusBarPartView.minimumHeight : 0);
-            return { width: containerDimension.width, height: containerDimension.height - takenHeight };
-        }
-    }
-    toggleZenMode(skipLayout, restoring = false) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE, !this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE));
-        this.state.runtime.zenMode.transitionDisposables.clearAndDisposeAll();
-        const setLineNumbers = (lineNumbers) => {
-            for (const editor of this.mainPartEditorService.visibleTextEditorControls) {
-                if (!lineNumbers && isCodeEditor(editor) && editor.hasModel()) {
-                    const model = editor.getModel();
-                    lineNumbers = this.configurationService.getValue('editor.lineNumbers', { resource: model.uri, overrideIdentifier: model.getLanguageId() });
-                }
-                if (!lineNumbers) {
-                    lineNumbers = this.configurationService.getValue('editor.lineNumbers');
-                }
-                editor.updateOptions({ lineNumbers });
-            }
-        };
-        let toggleMainWindowFullScreen = false;
-        const config = getZenModeConfiguration(this.configurationService);
-        const zenModeExitInfo = this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_EXIT_INFO);
-        if (this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE)) {
-            toggleMainWindowFullScreen = !this.state.runtime.mainWindowFullscreen && config.fullScreen && !isIOS;
-            if (!restoring) {
-                zenModeExitInfo.transitionedToFullScreen = toggleMainWindowFullScreen;
-                zenModeExitInfo.transitionedToCenteredEditorLayout = !this.isMainEditorLayoutCentered() && config.centerLayout;
-                zenModeExitInfo.handleNotificationsDoNotDisturbMode = this.notificationService.getFilter() === NotificationsFilter.OFF;
-                zenModeExitInfo.wasVisible.sideBar = this.isVisible("workbench.parts.sidebar" );
-                zenModeExitInfo.wasVisible.panel = this.isVisible("workbench.parts.panel" );
-                zenModeExitInfo.wasVisible.auxiliaryBar = this.isVisible("workbench.parts.auxiliarybar" );
-                this.stateModel.setRuntimeValue(LayoutStateKeys.ZEN_MODE_EXIT_INFO, zenModeExitInfo);
-            }
-            this.setPanelHidden(true, true);
-            this.setAuxiliaryBarHidden(true, true);
-            this.setSideBarHidden(true, true);
-            if (config.hideActivityBar) {
-                this.setActivityBarHidden(true, true);
-            }
-            if (config.hideStatusBar) {
-                this.setStatusBarHidden(true, true);
-            }
-            if (config.hideLineNumbers) {
-                setLineNumbers('off');
-                this.state.runtime.zenMode.transitionDisposables.set("zenMode.hideLineNumbers" , this.mainPartEditorService.onDidVisibleEditorsChange(() => setLineNumbers('off')));
-            }
-            if (config.showTabs !== this.editorGroupService.partOptions.showTabs) {
-                this.state.runtime.zenMode.transitionDisposables.set("zenMode.showTabs" , this.editorGroupService.mainPart.enforcePartOptions({ showTabs: config.showTabs }));
-            }
-            if (config.silentNotifications && zenModeExitInfo.handleNotificationsDoNotDisturbMode) {
-                this.notificationService.setFilter(NotificationsFilter.ERROR);
-            }
-            if (config.centerLayout) {
-                this.centerMainEditorLayout(true, true);
-            }
-            this.state.runtime.zenMode.transitionDisposables.set('configurationChange', this.configurationService.onDidChangeConfiguration(e => {
-                if (e.affectsConfiguration("zenMode.hideActivityBar" )) {
-                    const zenModeHideActivityBar = this.configurationService.getValue("zenMode.hideActivityBar" );
-                    this.setActivityBarHidden(zenModeHideActivityBar, true);
-                }
-                if (e.affectsConfiguration("zenMode.hideStatusBar" )) {
-                    const zenModeHideStatusBar = this.configurationService.getValue("zenMode.hideStatusBar" );
-                    this.setStatusBarHidden(zenModeHideStatusBar, true);
-                }
-                if (e.affectsConfiguration("zenMode.centerLayout" )) {
-                    const zenModeCenterLayout = this.configurationService.getValue("zenMode.centerLayout" );
-                    this.centerMainEditorLayout(zenModeCenterLayout, true);
-                }
-                if (e.affectsConfiguration("zenMode.showTabs" )) {
-                    const zenModeShowTabs = this.configurationService.getValue("zenMode.showTabs" ) ?? 'multiple';
-                    this.state.runtime.zenMode.transitionDisposables.set("zenMode.showTabs" , this.editorGroupService.mainPart.enforcePartOptions({ showTabs: zenModeShowTabs }));
-                }
-                if (e.affectsConfiguration("zenMode.silentNotifications" )) {
-                    const zenModeSilentNotifications = !!this.configurationService.getValue("zenMode.silentNotifications" );
-                    if (zenModeExitInfo.handleNotificationsDoNotDisturbMode) {
-                        this.notificationService.setFilter(zenModeSilentNotifications ? NotificationsFilter.ERROR : NotificationsFilter.OFF);
-                    }
-                }
-                if (e.affectsConfiguration("zenMode.hideLineNumbers" )) {
-                    const lineNumbersType = this.configurationService.getValue("zenMode.hideLineNumbers" ) ? 'off' : undefined;
-                    setLineNumbers(lineNumbersType);
-                    this.state.runtime.zenMode.transitionDisposables.set("zenMode.hideLineNumbers" , this.mainPartEditorService.onDidVisibleEditorsChange(() => setLineNumbers(lineNumbersType)));
-                }
-            }));
-        }
-        else {
-            if (zenModeExitInfo.wasVisible.panel) {
-                this.setPanelHidden(false, true);
-            }
-            if (zenModeExitInfo.wasVisible.auxiliaryBar) {
-                this.setAuxiliaryBarHidden(false, true);
-            }
-            if (zenModeExitInfo.wasVisible.sideBar) {
-                this.setSideBarHidden(false, true);
-            }
-            if (!this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN, true)) {
-                this.setActivityBarHidden(false, true);
-            }
-            if (!this.stateModel.getRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN, true)) {
-                this.setStatusBarHidden(false, true);
-            }
-            if (zenModeExitInfo.transitionedToCenteredEditorLayout) {
-                this.centerMainEditorLayout(false, true);
-            }
-            if (zenModeExitInfo.handleNotificationsDoNotDisturbMode) {
-                this.notificationService.setFilter(NotificationsFilter.OFF);
-            }
-            setLineNumbers();
-            this.focus();
-            toggleMainWindowFullScreen = zenModeExitInfo.transitionedToFullScreen && this.state.runtime.mainWindowFullscreen;
-        }
-        if (!skipLayout) {
-            this.layout();
-        }
-        if (toggleMainWindowFullScreen) {
-            this.hostService.toggleFullScreen(mainWindow);
-        }
-        this._onDidChangeZenMode.fire(this.stateModel.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE));
-    }
-    setStatusBarHidden(hidden, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN, hidden);
-        if (hidden) {
-            this.mainContainer.classList.add(LayoutClasses.STATUSBAR_HIDDEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.STATUSBAR_HIDDEN);
-        }
-        this.workbenchGrid.setViewVisible(this.statusBarPartView, !hidden);
-    }
-    createWorkbenchLayout() {
-        const titleBar = this.getPart("workbench.parts.titlebar" );
-        const bannerPart = this.getPart("workbench.parts.banner" );
-        const editorPart = this.getPart("workbench.parts.editor" );
-        const activityBar = this.getPart("workbench.parts.activitybar" );
-        const panelPart = this.getPart("workbench.parts.panel" );
-        const auxiliaryBarPart = this.getPart("workbench.parts.auxiliarybar" );
-        const sideBar = this.getPart("workbench.parts.sidebar" );
-        const statusBar = this.getPart("workbench.parts.statusbar" );
-        this.titleBarPartView = titleBar;
-        this.bannerPartView = bannerPart;
-        this.sideBarPartView = sideBar;
-        this.activityBarPartView = activityBar;
-        this.editorPartView = editorPart;
-        this.panelPartView = panelPart;
-        this.auxiliaryBarPartView = auxiliaryBarPart;
-        this.statusBarPartView = statusBar;
-        const viewMap = {
-            ["workbench.parts.activitybar" ]: this.activityBarPartView,
-            ["workbench.parts.banner" ]: this.bannerPartView,
-            ["workbench.parts.titlebar" ]: this.titleBarPartView,
-            ["workbench.parts.editor" ]: this.editorPartView,
-            ["workbench.parts.panel" ]: this.panelPartView,
-            ["workbench.parts.sidebar" ]: this.sideBarPartView,
-            ["workbench.parts.statusbar" ]: this.statusBarPartView,
-            ["workbench.parts.auxiliarybar" ]: this.auxiliaryBarPartView
-        };
-        const fromJSON = ({ type }) => viewMap[type];
-        const workbenchGrid = SerializableGrid.deserialize(this.createGridDescriptor(), { fromJSON }, { proportionalLayout: false });
-        this.mainContainer.prepend(workbenchGrid.element);
-        this.mainContainer.setAttribute('role', 'application');
-        this.workbenchGrid = workbenchGrid;
-        this.workbenchGrid.edgeSnapping = this.state.runtime.mainWindowFullscreen;
-        for (const part of [titleBar, editorPart, activityBar, panelPart, sideBar, statusBar, auxiliaryBarPart, bannerPart]) {
-            this._register(part.onDidVisibilityChange((visible) => {
-                if (part === sideBar) {
-                    this.setSideBarHidden(!visible, true);
-                }
-                else if (part === panelPart) {
-                    this.setPanelHidden(!visible, true);
-                }
-                else if (part === auxiliaryBarPart) {
-                    this.setAuxiliaryBarHidden(!visible, true);
-                }
-                else if (part === editorPart) {
-                    this.setEditorHidden(!visible, true);
-                }
-                this._onDidChangePartVisibility.fire();
-                this.handleContainerDidLayout(this.mainContainer, this._mainContainerDimension);
-            }));
-        }
-        this._register(this.storageService.onWillSaveState(willSaveState => {
-            if (willSaveState.reason === WillSaveStateReason.SHUTDOWN) {
-                const sideBarSize = this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN)
-                    ? this.workbenchGrid.getViewCachedVisibleSize(this.sideBarPartView)
-                    : this.workbenchGrid.getViewSize(this.sideBarPartView).width;
-                this.stateModel.setInitializationValue(LayoutStateKeys.SIDEBAR_SIZE, sideBarSize);
-                const panelSize = this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN)
-                    ? this.workbenchGrid.getViewCachedVisibleSize(this.panelPartView)
-                    : (this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_POSITION) === 2  ? this.workbenchGrid.getViewSize(this.panelPartView).height : this.workbenchGrid.getViewSize(this.panelPartView).width);
-                this.stateModel.setInitializationValue(LayoutStateKeys.PANEL_SIZE, panelSize);
-                const auxiliaryBarSize = this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN)
-                    ? this.workbenchGrid.getViewCachedVisibleSize(this.auxiliaryBarPartView)
-                    : this.workbenchGrid.getViewSize(this.auxiliaryBarPartView).width;
-                this.stateModel.setInitializationValue(LayoutStateKeys.AUXILIARYBAR_SIZE, auxiliaryBarSize);
-                this.stateModel.save(true, true);
-            }
-        }));
-    }
-    layout() {
-        if (!this.disposed) {
-            this._mainContainerDimension = getClientArea(this.state.runtime.mainWindowFullscreen ?
-                mainWindow.document.body :
-                this.parent
-            );
-            this.logService.trace(`Layout#layout, height: ${this._mainContainerDimension.height}, width: ${this._mainContainerDimension.width}`);
-            position(this.mainContainer, 0, 0, 0, 0, 'relative');
-            size(this.mainContainer, this._mainContainerDimension.width, this._mainContainerDimension.height);
-            this.workbenchGrid.layout(this._mainContainerDimension.width, this._mainContainerDimension.height);
-            this.initialized = true;
-            this.handleContainerDidLayout(this.mainContainer, this._mainContainerDimension);
-        }
-    }
-    isMainEditorLayoutCentered() {
-        return this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED);
-    }
-    centerMainEditorLayout(active, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED, active);
-        const activeMainEditor = this.mainPartEditorService.activeEditor;
-        let isEditorComplex = false;
-        if (activeMainEditor instanceof DiffEditorInput) {
-            isEditorComplex = this.configurationService.getValue('diffEditor.renderSideBySide');
-        }
-        else if (activeMainEditor?.hasCapability(256 )) {
-            isEditorComplex = true;
-        }
-        const isCenteredLayoutAutoResizing = this.configurationService.getValue('workbench.editor.centeredLayoutAutoResize');
-        if (isCenteredLayoutAutoResizing &&
-            ((this.editorGroupService.mainPart.groups.length > 1 && !this.editorGroupService.mainPart.hasMaximizedGroup()) || isEditorComplex)) {
-            active = false;
-        }
-        if (this.editorGroupService.mainPart.isLayoutCentered() !== active) {
-            this.editorGroupService.mainPart.centerLayout(active);
-            if (!skipLayout) {
-                this.layout();
-            }
-        }
-        this._onDidChangeMainEditorCenteredLayout.fire(this.stateModel.getRuntimeValue(LayoutStateKeys.MAIN_EDITOR_CENTERED));
-    }
-    resizePart(part, sizeChangeWidth, sizeChangeHeight) {
-        const sizeChangePxWidth = Math.sign(sizeChangeWidth) * computeScreenAwareSize(getActiveWindow(), Math.abs(sizeChangeWidth));
-        const sizeChangePxHeight = Math.sign(sizeChangeHeight) * computeScreenAwareSize(getActiveWindow(), Math.abs(sizeChangeHeight));
-        let viewSize;
-        switch (part) {
-            case "workbench.parts.sidebar" :
-                viewSize = this.workbenchGrid.getViewSize(this.sideBarPartView);
-                this.workbenchGrid.resizeView(this.sideBarPartView, {
-                    width: viewSize.width + sizeChangePxWidth,
-                    height: viewSize.height
-                });
-                break;
-            case "workbench.parts.panel" :
-                viewSize = this.workbenchGrid.getViewSize(this.panelPartView);
-                this.workbenchGrid.resizeView(this.panelPartView, {
-                    width: viewSize.width + (this.getPanelPosition() !== 2  ? sizeChangePxWidth : 0),
-                    height: viewSize.height + (this.getPanelPosition() !== 2  ? 0 : sizeChangePxHeight)
-                });
-                break;
-            case "workbench.parts.auxiliarybar" :
-                viewSize = this.workbenchGrid.getViewSize(this.auxiliaryBarPartView);
-                this.workbenchGrid.resizeView(this.auxiliaryBarPartView, {
-                    width: viewSize.width + sizeChangePxWidth,
-                    height: viewSize.height
-                });
-                break;
-            case "workbench.parts.editor" :
-                viewSize = this.workbenchGrid.getViewSize(this.editorPartView);
-                if (this.editorGroupService.mainPart.count === 1) {
-                    this.workbenchGrid.resizeView(this.editorPartView, {
-                        width: viewSize.width + sizeChangePxWidth,
-                        height: viewSize.height + sizeChangePxHeight
-                    });
-                }
-                else {
-                    const activeGroup = this.editorGroupService.mainPart.activeGroup;
-                    const { width, height } = this.editorGroupService.mainPart.getSize(activeGroup);
-                    this.editorGroupService.mainPart.setSize(activeGroup, { width: width + sizeChangePxWidth, height: height + sizeChangePxHeight });
-                    const { width: newWidth, height: newHeight } = this.editorGroupService.mainPart.getSize(activeGroup);
-                    if ((sizeChangePxHeight && height === newHeight) || (sizeChangePxWidth && width === newWidth)) {
-                        this.workbenchGrid.resizeView(this.editorPartView, {
-                            width: viewSize.width + (sizeChangePxWidth && width === newWidth ? sizeChangePxWidth : 0),
-                            height: viewSize.height + (sizeChangePxHeight && height === newHeight ? sizeChangePxHeight : 0)
-                        });
-                    }
-                }
-                break;
-            default:
-                return;
-        }
-    }
-    setActivityBarHidden(hidden, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN, hidden);
-        this.workbenchGrid.setViewVisible(this.activityBarPartView, !hidden);
-    }
-    setBannerHidden(hidden) {
-        this.workbenchGrid.setViewVisible(this.bannerPartView, !hidden);
-    }
-    setEditorHidden(hidden, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN, hidden);
-        if (hidden) {
-            this.mainContainer.classList.add(LayoutClasses.MAIN_EDITOR_AREA_HIDDEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.MAIN_EDITOR_AREA_HIDDEN);
-        }
-        this.workbenchGrid.setViewVisible(this.editorPartView, !hidden);
-        if (hidden && !this.isVisible("workbench.parts.panel" )) {
-            this.setPanelHidden(false, true);
-        }
-    }
-    getLayoutClasses() {
-        return coalesce([
-            !this.isVisible("workbench.parts.sidebar" ) ? LayoutClasses.SIDEBAR_HIDDEN : undefined,
-            !this.isVisible("workbench.parts.editor" , mainWindow) ? LayoutClasses.MAIN_EDITOR_AREA_HIDDEN : undefined,
-            !this.isVisible("workbench.parts.panel" ) ? LayoutClasses.PANEL_HIDDEN : undefined,
-            !this.isVisible("workbench.parts.auxiliarybar" ) ? LayoutClasses.AUXILIARYBAR_HIDDEN : undefined,
-            !this.isVisible("workbench.parts.statusbar" ) ? LayoutClasses.STATUSBAR_HIDDEN : undefined,
-            this.state.runtime.mainWindowFullscreen ? LayoutClasses.FULLSCREEN : undefined
-        ]);
-    }
-    setSideBarHidden(hidden, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN, hidden);
-        if (hidden) {
-            this.mainContainer.classList.add(LayoutClasses.SIDEBAR_HIDDEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.SIDEBAR_HIDDEN);
-        }
-        if (hidden && this.paneCompositeService.getActivePaneComposite(0 )) {
-            this.paneCompositeService.hideActivePaneComposite(0 );
-            this.focusPanelOrEditor();
-        }
-        else if (!hidden && !this.paneCompositeService.getActivePaneComposite(0 )) {
-            const viewletToOpen = this.paneCompositeService.getLastActivePaneCompositeId(0 );
-            if (viewletToOpen) {
-                const viewlet = this.paneCompositeService.openPaneComposite(viewletToOpen, 0 , true);
-                if (!viewlet) {
-                    this.paneCompositeService.openPaneComposite(this.viewDescriptorService.getDefaultViewContainer(0 )?.id, 0 , true);
-                }
-            }
-        }
-        this.workbenchGrid.setViewVisible(this.sideBarPartView, !hidden);
-    }
-    hasViews(id) {
-        const viewContainer = this.viewDescriptorService.getViewContainerById(id);
-        if (!viewContainer) {
-            return false;
-        }
-        const viewContainerModel = this.viewDescriptorService.getViewContainerModel(viewContainer);
-        if (!viewContainerModel) {
-            return false;
-        }
-        return viewContainerModel.activeViewDescriptors.length >= 1;
-    }
-    adjustPartPositions(sideBarPosition, panelAlignment, panelPosition) {
-        const sideBarSiblingToEditor = panelPosition !== 2  || !(panelAlignment === 'center' || (sideBarPosition === 0  && panelAlignment === 'right') || (sideBarPosition === 1  && panelAlignment === 'left'));
-        const auxiliaryBarSiblingToEditor = panelPosition !== 2  || !(panelAlignment === 'center' || (sideBarPosition === 1  && panelAlignment === 'right') || (sideBarPosition === 0  && panelAlignment === 'left'));
-        const preMovePanelWidth = !this.isVisible("workbench.parts.panel" ) ? Sizing.Invisible(this.workbenchGrid.getViewCachedVisibleSize(this.panelPartView) ?? this.panelPartView.minimumWidth) : this.workbenchGrid.getViewSize(this.panelPartView).width;
-        const preMovePanelHeight = !this.isVisible("workbench.parts.panel" ) ? Sizing.Invisible(this.workbenchGrid.getViewCachedVisibleSize(this.panelPartView) ?? this.panelPartView.minimumHeight) : this.workbenchGrid.getViewSize(this.panelPartView).height;
-        const preMoveSideBarSize = !this.isVisible("workbench.parts.sidebar" ) ? Sizing.Invisible(this.workbenchGrid.getViewCachedVisibleSize(this.sideBarPartView) ?? this.sideBarPartView.minimumWidth) : this.workbenchGrid.getViewSize(this.sideBarPartView).width;
-        const preMoveAuxiliaryBarSize = !this.isVisible("workbench.parts.auxiliarybar" ) ? Sizing.Invisible(this.workbenchGrid.getViewCachedVisibleSize(this.auxiliaryBarPartView) ?? this.auxiliaryBarPartView.minimumWidth) : this.workbenchGrid.getViewSize(this.auxiliaryBarPartView).width;
-        if (sideBarPosition === 0 ) {
-            this.workbenchGrid.moveViewTo(this.activityBarPartView, [2, 0]);
-            this.workbenchGrid.moveView(this.sideBarPartView, preMoveSideBarSize, sideBarSiblingToEditor ? this.editorPartView : this.activityBarPartView, sideBarSiblingToEditor ? 2  : 3 );
-            if (auxiliaryBarSiblingToEditor) {
-                this.workbenchGrid.moveView(this.auxiliaryBarPartView, preMoveAuxiliaryBarSize, this.editorPartView, 3 );
-            }
-            else {
-                this.workbenchGrid.moveViewTo(this.auxiliaryBarPartView, [2, -1]);
-            }
-        }
-        else {
-            this.workbenchGrid.moveViewTo(this.activityBarPartView, [2, -1]);
-            this.workbenchGrid.moveView(this.sideBarPartView, preMoveSideBarSize, sideBarSiblingToEditor ? this.editorPartView : this.activityBarPartView, sideBarSiblingToEditor ? 3  : 2 );
-            if (auxiliaryBarSiblingToEditor) {
-                this.workbenchGrid.moveView(this.auxiliaryBarPartView, preMoveAuxiliaryBarSize, this.editorPartView, 2 );
-            }
-            else {
-                this.workbenchGrid.moveViewTo(this.auxiliaryBarPartView, [2, 0]);
-            }
-        }
-        if (panelPosition !== 2 ) {
-            this.workbenchGrid.moveView(this.panelPartView, preMovePanelWidth, this.editorPartView, panelPosition === 0  ? 2  : 3 );
-            this.workbenchGrid.resizeView(this.panelPartView, {
-                height: preMovePanelHeight,
-                width: preMovePanelWidth
-            });
-        }
-        if (this.isVisible("workbench.parts.sidebar" )) {
-            this.workbenchGrid.resizeView(this.sideBarPartView, {
-                height: this.workbenchGrid.getViewSize(this.sideBarPartView).height,
-                width: preMoveSideBarSize
-            });
-        }
-        if (this.isVisible("workbench.parts.auxiliarybar" )) {
-            this.workbenchGrid.resizeView(this.auxiliaryBarPartView, {
-                height: this.workbenchGrid.getViewSize(this.auxiliaryBarPartView).height,
-                width: preMoveAuxiliaryBarSize
-            });
-        }
-    }
-    setPanelAlignment(alignment, skipLayout) {
-        if (this.getPanelPosition() !== 2 ) {
-            this.setPanelPosition(2 );
-        }
-        if (alignment !== 'center' && this.isPanelMaximized()) {
-            this.toggleMaximizedPanel();
-        }
-        this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_ALIGNMENT, alignment);
-        this.adjustPartPositions(this.getSideBarPosition(), alignment, this.getPanelPosition());
-        this._onDidChangePanelAlignment.fire(alignment);
-    }
-    setPanelHidden(hidden, skipLayout) {
-        if (!this.workbenchGrid) {
-            return;
-        }
-        const wasHidden = !this.isVisible("workbench.parts.panel" );
-        this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_HIDDEN, hidden);
-        const isPanelMaximized = this.isPanelMaximized();
-        const panelOpensMaximized = this.panelOpensMaximized();
-        if (hidden) {
-            this.mainContainer.classList.add(LayoutClasses.PANEL_HIDDEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.PANEL_HIDDEN);
-        }
-        let focusEditor = false;
-        if (hidden && this.paneCompositeService.getActivePaneComposite(1 )) {
-            this.paneCompositeService.hideActivePaneComposite(1 );
-            focusEditor = isIOS ? false : true;
-        }
-        else if (!hidden && !this.paneCompositeService.getActivePaneComposite(1 )) {
-            let panelToOpen = this.paneCompositeService.getLastActivePaneCompositeId(1 );
-            if (!panelToOpen || !this.hasViews(panelToOpen)) {
-                panelToOpen = this.viewDescriptorService
-                    .getViewContainersByLocation(1 )
-                    .find(viewContainer => this.hasViews(viewContainer.id))?.id;
-            }
-            if (panelToOpen) {
-                const focus = !skipLayout;
-                this.paneCompositeService.openPaneComposite(panelToOpen, 1 , focus);
-            }
-        }
-        if (hidden && isPanelMaximized) {
-            this.toggleMaximizedPanel();
-        }
-        if (wasHidden === hidden) {
-            return;
-        }
-        this.workbenchGrid.setViewVisible(this.panelPartView, !hidden);
-        if (!hidden) {
-            if (!skipLayout && isPanelMaximized !== panelOpensMaximized) {
-                this.toggleMaximizedPanel();
-            }
-        }
-        else {
-            this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_WAS_LAST_MAXIMIZED, isPanelMaximized);
-        }
-        if (focusEditor) {
-            this.editorGroupService.mainPart.activeGroup.focus();
-        }
-    }
-    toggleMaximizedPanel() {
-        const size = this.workbenchGrid.getViewSize(this.panelPartView);
-        const panelPosition = this.getPanelPosition();
-        const isMaximized = this.isPanelMaximized();
-        if (!isMaximized) {
-            if (this.isVisible("workbench.parts.panel" )) {
-                if (panelPosition === 2 ) {
-                    this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_HEIGHT, size.height);
-                }
-                else {
-                    this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_WIDTH, size.width);
-                }
-            }
-            this.setEditorHidden(true);
-        }
-        else {
-            this.setEditorHidden(false);
-            this.workbenchGrid.resizeView(this.panelPartView, {
-                width: panelPosition === 2  ? size.width : this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_WIDTH),
-                height: panelPosition === 2  ? this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_HEIGHT) : size.height
-            });
-        }
-        this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_WAS_LAST_MAXIMIZED, !isMaximized);
-    }
-    panelOpensMaximized() {
-        if (this.getPanelAlignment() !== 'center' && this.getPanelPosition() === 2 ) {
-            return false;
-        }
-        const panelOpensMaximized = panelOpensMaximizedFromString(this.configurationService.getValue(WorkbenchLayoutSettings.PANEL_OPENS_MAXIMIZED));
-        const panelLastIsMaximized = this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_WAS_LAST_MAXIMIZED);
-        return panelOpensMaximized === 0  || (panelOpensMaximized === 2  && panelLastIsMaximized);
-    }
-    setAuxiliaryBarHidden(hidden, skipLayout) {
-        this.stateModel.setRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN, hidden);
-        if (hidden) {
-            this.mainContainer.classList.add(LayoutClasses.AUXILIARYBAR_HIDDEN);
-        }
-        else {
-            this.mainContainer.classList.remove(LayoutClasses.AUXILIARYBAR_HIDDEN);
-        }
-        if (hidden && this.paneCompositeService.getActivePaneComposite(2 )) {
-            this.paneCompositeService.hideActivePaneComposite(2 );
-            this.focusPanelOrEditor();
-        }
-        else if (!hidden && !this.paneCompositeService.getActivePaneComposite(2 )) {
-            let panelToOpen = this.paneCompositeService.getLastActivePaneCompositeId(2 );
-            if (!panelToOpen || !this.hasViews(panelToOpen)) {
-                panelToOpen = this.viewDescriptorService
-                    .getViewContainersByLocation(2 )
-                    .find(viewContainer => this.hasViews(viewContainer.id))?.id;
-            }
-            if (panelToOpen) {
-                const focus = !skipLayout;
-                this.paneCompositeService.openPaneComposite(panelToOpen, 2 , focus);
-            }
-        }
-        this.workbenchGrid.setViewVisible(this.auxiliaryBarPartView, !hidden);
-    }
-    setPartHidden(hidden, part, targetWindow = mainWindow) {
-        switch (part) {
-            case "workbench.parts.activitybar" :
-                return this.setActivityBarHidden(hidden);
-            case "workbench.parts.sidebar" :
-                return this.setSideBarHidden(hidden);
-            case "workbench.parts.editor" :
-                return this.setEditorHidden(hidden);
-            case "workbench.parts.banner" :
-                return this.setBannerHidden(hidden);
-            case "workbench.parts.auxiliarybar" :
-                return this.setAuxiliaryBarHidden(hidden);
-            case "workbench.parts.panel" :
-                return this.setPanelHidden(hidden);
-        }
-    }
-    hasMainWindowBorder() {
-        return this.state.runtime.mainWindowBorder;
-    }
-    getMainWindowBorderRadius() {
-        return this.state.runtime.mainWindowBorder && isMacintosh ? '5px' : undefined;
-    }
-    isPanelMaximized() {
-        return ((this.getPanelAlignment() === 'center' || this.getPanelPosition() !== 2) ) && !this.isVisible("workbench.parts.editor" , mainWindow);
-    }
-    getSideBarPosition() {
-        return this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON);
-    }
-    getPanelAlignment() {
-        return this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_ALIGNMENT);
-    }
-    updateMenubarVisibility(skipLayout) {
-        const shouldShowTitleBar = shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled);
-        if (!skipLayout && this.workbenchGrid && shouldShowTitleBar !== this.isVisible("workbench.parts.titlebar" , mainWindow)) {
-            this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowTitleBar);
-        }
-    }
-    updateCustomTitleBarVisibility() {
-        const shouldShowTitleBar = shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled);
-        const titlebarVisible = this.isVisible("workbench.parts.titlebar" );
-        if (shouldShowTitleBar !== titlebarVisible) {
-            this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowTitleBar);
-        }
-    }
-    toggleMenuBar() {
-        let currentVisibilityValue = getMenuBarVisibility(this.configurationService);
-        if (typeof currentVisibilityValue !== 'string') {
-            currentVisibilityValue = 'classic';
-        }
-        let newVisibilityValue;
-        if (currentVisibilityValue === 'visible' || currentVisibilityValue === 'classic') {
-            newVisibilityValue = hasNativeTitlebar(this.configurationService) ? 'toggle' : 'compact';
-        }
-        else {
-            newVisibilityValue = 'classic';
-        }
-        this.configurationService.updateValue('window.menuBarVisibility', newVisibilityValue);
-    }
-    getPanelPosition() {
-        return this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_POSITION);
-    }
-    setPanelPosition(position) {
-        if (!this.isVisible("workbench.parts.panel" )) {
-            this.setPanelHidden(false);
-        }
-        const panelPart = this.getPart("workbench.parts.panel" );
-        const oldPositionValue = positionToString(this.getPanelPosition());
-        const newPositionValue = positionToString(position);
-        const panelContainer = assertIsDefined(panelPart.getContainer());
-        panelContainer.classList.remove(oldPositionValue);
-        panelContainer.classList.add(newPositionValue);
-        panelPart.updateStyles();
-        const size = this.workbenchGrid.getViewSize(this.panelPartView);
-        const sideBarSize = this.workbenchGrid.getViewSize(this.sideBarPartView);
-        const auxiliaryBarSize = this.workbenchGrid.getViewSize(this.auxiliaryBarPartView);
-        let editorHidden = !this.isVisible("workbench.parts.editor" , mainWindow);
-        if (newPositionValue !== oldPositionValue && !editorHidden) {
-            if (position === 2 ) {
-                this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_WIDTH, size.width);
-            }
-            else if (positionFromString(oldPositionValue) === 2 ) {
-                this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_HEIGHT, size.height);
-            }
-        }
-        if (position === 2  && this.getPanelAlignment() !== 'center' && editorHidden) {
-            this.toggleMaximizedPanel();
-            editorHidden = false;
-        }
-        this.stateModel.setRuntimeValue(LayoutStateKeys.PANEL_POSITION, position);
-        const sideBarVisible = this.isVisible("workbench.parts.sidebar" );
-        const auxiliaryBarVisible = this.isVisible("workbench.parts.auxiliarybar" );
-        if (position === 2 ) {
-            this.workbenchGrid.moveView(this.panelPartView, editorHidden ? size.height : this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_HEIGHT), this.editorPartView, 1 );
-        }
-        else if (position === 1 ) {
-            this.workbenchGrid.moveView(this.panelPartView, editorHidden ? size.width : this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_WIDTH), this.editorPartView, 3 );
-        }
-        else {
-            this.workbenchGrid.moveView(this.panelPartView, editorHidden ? size.width : this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_LAST_NON_MAXIMIZED_WIDTH), this.editorPartView, 2 );
-        }
-        this.workbenchGrid.resizeView(this.sideBarPartView, sideBarSize);
-        if (!sideBarVisible) {
-            this.setSideBarHidden(true);
-        }
-        this.workbenchGrid.resizeView(this.auxiliaryBarPartView, auxiliaryBarSize);
-        if (!auxiliaryBarVisible) {
-            this.setAuxiliaryBarHidden(true);
-        }
-        if (position === 2 ) {
-            this.adjustPartPositions(this.getSideBarPosition(), this.getPanelAlignment(), position);
-        }
-        this._onDidChangePanelPosition.fire(newPositionValue);
-    }
-    isWindowMaximized(targetWindow) {
-        return ( this.state.runtime.maximized.has(getWindowId(targetWindow)));
-    }
-    updateWindowMaximizedState(targetWindow, maximized) {
-        this.mainContainer.classList.toggle(LayoutClasses.MAXIMIZED, maximized);
-        const targetWindowId = getWindowId(targetWindow);
-        if (maximized === ( this.state.runtime.maximized.has(targetWindowId))) {
-            return;
-        }
-        if (maximized) {
-            this.state.runtime.maximized.add(targetWindowId);
-        }
-        else {
-            this.state.runtime.maximized.delete(targetWindowId);
-        }
-        this.updateWindowsBorder();
-        this._onDidChangeWindowMaximized.fire({ windowId: targetWindowId, maximized });
-    }
-    getVisibleNeighborPart(part, direction) {
-        if (!this.workbenchGrid) {
-            return undefined;
-        }
-        if (!this.isVisible(part, mainWindow)) {
-            return undefined;
-        }
-        const neighborViews = this.workbenchGrid.getNeighborViews(this.getPart(part), direction, false);
-        if (!neighborViews) {
-            return undefined;
-        }
-        for (const neighborView of neighborViews) {
-            const neighborPart = ["workbench.parts.activitybar" , "workbench.parts.editor" , "workbench.parts.panel" , "workbench.parts.auxiliarybar" , "workbench.parts.sidebar" , "workbench.parts.statusbar" , "workbench.parts.titlebar" ]
-                .find(partId => this.getPart(partId) === neighborView && this.isVisible(partId, mainWindow));
-            if (neighborPart !== undefined) {
-                return neighborPart;
-            }
-        }
-        return undefined;
-    }
-    onDidChangeWCO() {
-        const bannerFirst = this.workbenchGrid.getNeighborViews(this.titleBarPartView, 0 , false).length > 0;
-        const shouldBannerBeFirst = this.shouldShowBannerFirst();
-        if (bannerFirst !== shouldBannerBeFirst) {
-            this.workbenchGrid.moveView(this.bannerPartView, Sizing.Distribute, this.titleBarPartView, shouldBannerBeFirst ? 0  : 1 );
-        }
-        this.workbenchGrid.setViewVisible(this.titleBarPartView, shouldShowCustomTitleBar(this.configurationService, mainWindow, this.state.runtime.menuBar.toggled));
-    }
-    arrangeEditorNodes(nodes, availableHeight, availableWidth) {
-        if (!nodes.sideBar && !nodes.auxiliaryBar) {
-            nodes.editor.size = availableHeight;
-            return nodes.editor;
-        }
-        const result = [nodes.editor];
-        nodes.editor.size = availableWidth;
-        if (nodes.sideBar) {
-            if (this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON) === 0 ) {
-                result.splice(0, 0, nodes.sideBar);
-            }
-            else {
-                result.push(nodes.sideBar);
-            }
-            nodes.editor.size -= this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN) ? 0 : nodes.sideBar.size;
-        }
-        if (nodes.auxiliaryBar) {
-            if (this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON) === 1 ) {
-                result.splice(0, 0, nodes.auxiliaryBar);
-            }
-            else {
-                result.push(nodes.auxiliaryBar);
-            }
-            nodes.editor.size -= this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN) ? 0 : nodes.auxiliaryBar.size;
-        }
-        return {
-            type: 'branch',
-            data: result,
-            size: availableHeight
-        };
-    }
-    arrangeMiddleSectionNodes(nodes, availableWidth, availableHeight) {
-        const activityBarSize = this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN) ? 0 : nodes.activityBar.size;
-        const sideBarSize = this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN) ? 0 : nodes.sideBar.size;
-        const auxiliaryBarSize = this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN) ? 0 : nodes.auxiliaryBar.size;
-        const panelSize = this.stateModel.getInitializationValue(LayoutStateKeys.PANEL_SIZE) ? 0 : nodes.panel.size;
-        const result = [];
-        if (this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_POSITION) !== 2 ) {
-            result.push(nodes.editor);
-            nodes.editor.size = availableWidth - activityBarSize - sideBarSize - panelSize - auxiliaryBarSize;
-            if (this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_POSITION) === 1 ) {
-                result.push(nodes.panel);
-            }
-            else {
-                result.splice(0, 0, nodes.panel);
-            }
-            if (this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON) === 0 ) {
-                result.push(nodes.auxiliaryBar);
-                result.splice(0, 0, nodes.sideBar);
-                result.splice(0, 0, nodes.activityBar);
-            }
-            else {
-                result.splice(0, 0, nodes.auxiliaryBar);
-                result.push(nodes.sideBar);
-                result.push(nodes.activityBar);
-            }
-        }
-        else {
-            const panelAlignment = this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_ALIGNMENT);
-            const sideBarPosition = this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON);
-            const sideBarNextToEditor = !(panelAlignment === 'center' || (sideBarPosition === 0  && panelAlignment === 'right') || (sideBarPosition === 1  && panelAlignment === 'left'));
-            const auxiliaryBarNextToEditor = !(panelAlignment === 'center' || (sideBarPosition === 1  && panelAlignment === 'right') || (sideBarPosition === 0  && panelAlignment === 'left'));
-            const editorSectionWidth = availableWidth - activityBarSize - (sideBarNextToEditor ? 0 : sideBarSize) - (auxiliaryBarNextToEditor ? 0 : auxiliaryBarSize);
-            result.push({
-                type: 'branch',
-                data: [this.arrangeEditorNodes({
-                        editor: nodes.editor,
-                        sideBar: sideBarNextToEditor ? nodes.sideBar : undefined,
-                        auxiliaryBar: auxiliaryBarNextToEditor ? nodes.auxiliaryBar : undefined
-                    }, availableHeight - panelSize, editorSectionWidth), nodes.panel],
-                size: editorSectionWidth
-            });
-            if (!sideBarNextToEditor) {
-                if (sideBarPosition === 0 ) {
-                    result.splice(0, 0, nodes.sideBar);
-                }
-                else {
-                    result.push(nodes.sideBar);
-                }
-            }
-            if (!auxiliaryBarNextToEditor) {
-                if (sideBarPosition === 1 ) {
-                    result.splice(0, 0, nodes.auxiliaryBar);
-                }
-                else {
-                    result.push(nodes.auxiliaryBar);
-                }
-            }
-            if (sideBarPosition === 0 ) {
-                result.splice(0, 0, nodes.activityBar);
-            }
-            else {
-                result.push(nodes.activityBar);
-            }
-        }
-        return result;
-    }
-    createGridDescriptor() {
-        const { width, height } = this.stateModel.getInitializationValue(LayoutStateKeys.GRID_SIZE);
-        const sideBarSize = this.stateModel.getInitializationValue(LayoutStateKeys.SIDEBAR_SIZE);
-        const auxiliaryBarPartSize = this.stateModel.getInitializationValue(LayoutStateKeys.AUXILIARYBAR_SIZE);
-        const panelSize = this.stateModel.getInitializationValue(LayoutStateKeys.PANEL_SIZE);
-        const titleBarHeight = this.titleBarPartView.minimumHeight;
-        const bannerHeight = this.bannerPartView.minimumHeight;
-        const statusBarHeight = this.statusBarPartView.minimumHeight;
-        const activityBarWidth = this.activityBarPartView.minimumWidth;
-        const middleSectionHeight = height - titleBarHeight - statusBarHeight;
-        const titleAndBanner = [
-            {
-                type: 'leaf',
-                data: { type: "workbench.parts.titlebar"  },
-                size: titleBarHeight,
-                visible: this.isVisible("workbench.parts.titlebar" , mainWindow)
-            },
-            {
-                type: 'leaf',
-                data: { type: "workbench.parts.banner"  },
-                size: bannerHeight,
-                visible: false
-            }
-        ];
-        const activityBarNode = {
-            type: 'leaf',
-            data: { type: "workbench.parts.activitybar"  },
-            size: activityBarWidth,
-            visible: !this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN)
-        };
-        const sideBarNode = {
-            type: 'leaf',
-            data: { type: "workbench.parts.sidebar"  },
-            size: sideBarSize,
-            visible: !this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN)
-        };
-        const auxiliaryBarNode = {
-            type: 'leaf',
-            data: { type: "workbench.parts.auxiliarybar"  },
-            size: auxiliaryBarPartSize,
-            visible: this.isVisible("workbench.parts.auxiliarybar" )
-        };
-        const editorNode = {
-            type: 'leaf',
-            data: { type: "workbench.parts.editor"  },
-            size: 0,
-            visible: !this.stateModel.getRuntimeValue(LayoutStateKeys.EDITOR_HIDDEN)
-        };
-        const panelNode = {
-            type: 'leaf',
-            data: { type: "workbench.parts.panel"  },
-            size: panelSize,
-            visible: !this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN)
-        };
-        const middleSection = this.arrangeMiddleSectionNodes({
-            activityBar: activityBarNode,
-            auxiliaryBar: auxiliaryBarNode,
-            editor: editorNode,
-            panel: panelNode,
-            sideBar: sideBarNode
-        }, width, middleSectionHeight);
-        const result = {
-            root: {
-                type: 'branch',
-                size: width,
-                data: [
-                    ...(this.shouldShowBannerFirst() ? titleAndBanner.reverse() : titleAndBanner),
-                    {
-                        type: 'branch',
-                        data: middleSection,
-                        size: middleSectionHeight
-                    },
-                    {
-                        type: 'leaf',
-                        data: { type: "workbench.parts.statusbar"  },
-                        size: statusBarHeight,
-                        visible: !this.stateModel.getRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN)
-                    }
-                ]
-            },
-            orientation: 0 ,
-            width,
-            height
-        };
-        const layoutDescriptor = {
-            activityBarVisible: !this.stateModel.getRuntimeValue(LayoutStateKeys.ACTIVITYBAR_HIDDEN),
-            sideBarVisible: !this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_HIDDEN),
-            auxiliaryBarVisible: !this.stateModel.getRuntimeValue(LayoutStateKeys.AUXILIARYBAR_HIDDEN),
-            panelVisible: !this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_HIDDEN),
-            statusbarVisible: !this.stateModel.getRuntimeValue(LayoutStateKeys.STATUSBAR_HIDDEN),
-            sideBarPosition: positionToString(this.stateModel.getRuntimeValue(LayoutStateKeys.SIDEBAR_POSITON)),
-            panelPosition: positionToString(this.stateModel.getRuntimeValue(LayoutStateKeys.PANEL_POSITION)),
-        };
-        this.telemetryService.publicLog2('startupLayout', layoutDescriptor);
-        return result;
-    }
-    dispose() {
-        super.dispose();
-        this.disposed = true;
-    }
-}
-function getZenModeConfiguration(configurationService) {
-    return configurationService.getValue(WorkbenchLayoutSettings.ZEN_MODE_CONFIG);
-}
-class WorkbenchLayoutStateKey {
-    constructor(name, scope, target, defaultValue) {
-        this.name = name;
-        this.scope = scope;
-        this.target = target;
-        this.defaultValue = defaultValue;
-    }
-}
-class RuntimeStateKey extends WorkbenchLayoutStateKey {
-    constructor(name, scope, target, defaultValue, zenModeIgnore) {
-        super(name, scope, target, defaultValue);
-        this.zenModeIgnore = zenModeIgnore;
-        this.runtime = true;
-    }
-}
-class InitializationStateKey extends WorkbenchLayoutStateKey {
-    constructor() {
-        super(...arguments);
-        this.runtime = false;
-    }
-}
-const LayoutStateKeys = {
-    MAIN_EDITOR_CENTERED: ( new RuntimeStateKey(
-        'editor.centered',
-        1 ,
-        1 ,
-        false
-    )),
-    ZEN_MODE_ACTIVE: ( new RuntimeStateKey(
-        'zenMode.active',
-        1 ,
-        1 ,
-        false
-    )),
-    ZEN_MODE_EXIT_INFO: ( new RuntimeStateKey(
-        'zenMode.exitInfo',
-        1 ,
-        1 ,
-        {
-            transitionedToCenteredEditorLayout: false,
-            transitionedToFullScreen: false,
-            handleNotificationsDoNotDisturbMode: false,
-            wasVisible: {
-                auxiliaryBar: false,
-                panel: false,
-                sideBar: false,
-            },
-        }
-    )),
-    GRID_SIZE: ( new InitializationStateKey(
-        'grid.size',
-        0 ,
-        1 ,
-        { width: 800, height: 600 }
-    )),
-    SIDEBAR_SIZE: ( new InitializationStateKey(
-        'sideBar.size',
-        0 ,
-        1 ,
-        200
-    )),
-    AUXILIARYBAR_SIZE: ( new InitializationStateKey(
-        'auxiliaryBar.size',
-        0 ,
-        1 ,
-        200
-    )),
-    PANEL_SIZE: ( new InitializationStateKey(
-        'panel.size',
-        0 ,
-        1 ,
-        300
-    )),
-    PANEL_LAST_NON_MAXIMIZED_HEIGHT: ( new RuntimeStateKey(
-        'panel.lastNonMaximizedHeight',
-        0 ,
-        1 ,
-        300
-    )),
-    PANEL_LAST_NON_MAXIMIZED_WIDTH: ( new RuntimeStateKey(
-        'panel.lastNonMaximizedWidth',
-        0 ,
-        1 ,
-        300
-    )),
-    PANEL_WAS_LAST_MAXIMIZED: ( new RuntimeStateKey(
-        'panel.wasLastMaximized',
-        1 ,
-        1 ,
-        false
-    )),
-    SIDEBAR_POSITON: ( new RuntimeStateKey(
-        'sideBar.position',
-        1 ,
-        1 ,
-        0
-    )),
-    PANEL_POSITION: ( new RuntimeStateKey(
-        'panel.position',
-        1 ,
-        1 ,
-        2
-    )),
-    PANEL_ALIGNMENT: ( new RuntimeStateKey(
-        'panel.alignment',
-        0 ,
-        0 ,
-        'center'
-    )),
-    ACTIVITYBAR_HIDDEN: ( new RuntimeStateKey(
-        'activityBar.hidden',
-        1 ,
-        1 ,
-        false,
-        true
-    )),
-    SIDEBAR_HIDDEN: ( new RuntimeStateKey(
-        'sideBar.hidden',
-        1 ,
-        1 ,
-        false
-    )),
-    EDITOR_HIDDEN: ( new RuntimeStateKey(
-        'editor.hidden',
-        1 ,
-        1 ,
-        false
-    )),
-    PANEL_HIDDEN: ( new RuntimeStateKey(
-        'panel.hidden',
-        1 ,
-        1 ,
-        true
-    )),
-    AUXILIARYBAR_HIDDEN: ( new RuntimeStateKey(
-        'auxiliaryBar.hidden',
-        1 ,
-        1 ,
-        true
-    )),
-    STATUSBAR_HIDDEN: ( new RuntimeStateKey(
-        'statusBar.hidden',
-        1 ,
-        1 ,
-        false,
-        true
-    ))
-};
-var WorkbenchLayoutSettings;
-( (function(WorkbenchLayoutSettings) {
-    WorkbenchLayoutSettings["PANEL_POSITION"] = "workbench.panel.defaultLocation";
-    WorkbenchLayoutSettings["PANEL_OPENS_MAXIMIZED"] = "workbench.panel.opensMaximized";
-    WorkbenchLayoutSettings["ZEN_MODE_CONFIG"] = "zenMode";
-    WorkbenchLayoutSettings["EDITOR_CENTERED_LAYOUT_AUTO_RESIZE"] = "workbench.editor.centeredLayoutAutoResize";
-})(WorkbenchLayoutSettings || (WorkbenchLayoutSettings = {})));
-var LegacyWorkbenchLayoutSettings;
-( (function(LegacyWorkbenchLayoutSettings) {
-    LegacyWorkbenchLayoutSettings["STATUSBAR_VISIBLE"] = "workbench.statusBar.visible";
-    LegacyWorkbenchLayoutSettings["SIDEBAR_POSITION"] = "workbench.sideBar.location";
-})(LegacyWorkbenchLayoutSettings || (LegacyWorkbenchLayoutSettings = {})));
-class LayoutStateModel extends Disposable {
-    static { this.STORAGE_PREFIX = 'workbench.'; }
-    constructor(storageService, configurationService, contextService, container) {
-        super();
-        this.storageService = storageService;
-        this.configurationService = configurationService;
-        this.contextService = contextService;
-        this.container = container;
-        this._onDidChangeState = this._register(( new Emitter()));
-        this.onDidChangeState = this._onDidChangeState.event;
-        this.stateCache = ( new Map());
-        this._register(this.configurationService.onDidChangeConfiguration(configurationChange => this.updateStateFromLegacySettings(configurationChange)));
-    }
-    updateStateFromLegacySettings(configurationChangeEvent) {
-        const isZenMode = this.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-        if (configurationChangeEvent.affectsConfiguration("workbench.activityBar.location" ) && !isZenMode) {
-            this.setRuntimeValueAndFire(LayoutStateKeys.ACTIVITYBAR_HIDDEN, this.isActivityBarHidden());
-        }
-        if (configurationChangeEvent.affectsConfiguration(LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE) && !isZenMode) {
-            this.setRuntimeValueAndFire(LayoutStateKeys.STATUSBAR_HIDDEN, !this.configurationService.getValue(LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE));
-        }
-        if (configurationChangeEvent.affectsConfiguration(LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION)) {
-            this.setRuntimeValueAndFire(LayoutStateKeys.SIDEBAR_POSITON, positionFromString(this.configurationService.getValue(LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION) ?? 'left'));
-        }
-    }
-    updateLegacySettingsFromState(key, value) {
-        const isZenMode = this.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-        if (key.zenModeIgnore && isZenMode) {
-            return;
-        }
-        if (key === LayoutStateKeys.ACTIVITYBAR_HIDDEN) {
-            this.configurationService.updateValue("workbench.activityBar.location" , value ? "hidden"  : undefined);
-        }
-        else if (key === LayoutStateKeys.STATUSBAR_HIDDEN) {
-            this.configurationService.updateValue(LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE, !value);
-        }
-        else if (key === LayoutStateKeys.SIDEBAR_POSITON) {
-            this.configurationService.updateValue(LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION, positionToString(value));
-        }
-    }
-    load() {
-        let key;
-        for (key in LayoutStateKeys) {
-            const stateKey = LayoutStateKeys[key];
-            const value = this.loadKeyFromStorage(stateKey);
-            if (value !== undefined) {
-                this.stateCache.set(stateKey.name, value);
-            }
-        }
-        this.stateCache.set(LayoutStateKeys.ACTIVITYBAR_HIDDEN.name, this.isActivityBarHidden());
-        this.stateCache.set(LayoutStateKeys.STATUSBAR_HIDDEN.name, !this.configurationService.getValue(LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE));
-        this.stateCache.set(LayoutStateKeys.SIDEBAR_POSITON.name, positionFromString(this.configurationService.getValue(LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION) ?? 'left'));
-        const workbenchDimensions = getClientArea(this.container);
-        LayoutStateKeys.PANEL_POSITION.defaultValue = positionFromString(this.configurationService.getValue(WorkbenchLayoutSettings.PANEL_POSITION) ?? 'bottom');
-        LayoutStateKeys.GRID_SIZE.defaultValue = { height: workbenchDimensions.height, width: workbenchDimensions.width };
-        LayoutStateKeys.SIDEBAR_SIZE.defaultValue = Math.min(300, workbenchDimensions.width / 4);
-        LayoutStateKeys.AUXILIARYBAR_SIZE.defaultValue = Math.min(300, workbenchDimensions.width / 4);
-        LayoutStateKeys.PANEL_SIZE.defaultValue = (this.stateCache.get(LayoutStateKeys.PANEL_POSITION.name) ?? LayoutStateKeys.PANEL_POSITION.defaultValue) === 2  ? workbenchDimensions.height / 3 : workbenchDimensions.width / 4;
-        LayoutStateKeys.SIDEBAR_HIDDEN.defaultValue = this.contextService.getWorkbenchState() === 1 ;
-        for (key in LayoutStateKeys) {
-            const stateKey = LayoutStateKeys[key];
-            if (this.stateCache.get(stateKey.name) === undefined) {
-                this.stateCache.set(stateKey.name, stateKey.defaultValue);
-            }
-        }
-        this._register(this.storageService.onDidChangeValue(0 , undefined, this._register(( new DisposableStore())))(storageChangeEvent => {
-            let key;
-            for (key in LayoutStateKeys) {
-                const stateKey = LayoutStateKeys[key];
-                if (stateKey instanceof RuntimeStateKey && stateKey.scope === 0  && stateKey.target === 0 ) {
-                    if (`${LayoutStateModel.STORAGE_PREFIX}${stateKey.name}` === storageChangeEvent.key) {
-                        const value = this.loadKeyFromStorage(stateKey) ?? stateKey.defaultValue;
-                        if (this.stateCache.get(stateKey.name) !== value) {
-                            this.stateCache.set(stateKey.name, value);
-                            this._onDidChangeState.fire({ key: stateKey, value });
-                        }
-                    }
-                }
-            }
-        }));
-    }
-    save(workspace, global) {
-        let key;
-        const isZenMode = this.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-        for (key in LayoutStateKeys) {
-            const stateKey = LayoutStateKeys[key];
-            if (((workspace && stateKey.scope === 1) ) ||
-                ((global && stateKey.scope === 0) )) {
-                if (isZenMode && stateKey instanceof RuntimeStateKey && stateKey.zenModeIgnore) {
-                    continue;
-                }
-                this.saveKeyToStorage(stateKey);
-            }
-        }
-    }
-    getInitializationValue(key) {
-        return this.stateCache.get(key.name);
-    }
-    setInitializationValue(key, value) {
-        this.stateCache.set(key.name, value);
-    }
-    getRuntimeValue(key, fallbackToSetting) {
-        if (fallbackToSetting) {
-            switch (key) {
-                case LayoutStateKeys.ACTIVITYBAR_HIDDEN:
-                    this.stateCache.set(key.name, this.isActivityBarHidden());
-                    break;
-                case LayoutStateKeys.STATUSBAR_HIDDEN:
-                    this.stateCache.set(key.name, !this.configurationService.getValue(LegacyWorkbenchLayoutSettings.STATUSBAR_VISIBLE));
-                    break;
-                case LayoutStateKeys.SIDEBAR_POSITON:
-                    this.stateCache.set(key.name, this.configurationService.getValue(LegacyWorkbenchLayoutSettings.SIDEBAR_POSITION) ?? 'left');
-                    break;
-            }
-        }
-        return this.stateCache.get(key.name);
-    }
-    setRuntimeValue(key, value) {
-        this.stateCache.set(key.name, value);
-        const isZenMode = this.getRuntimeValue(LayoutStateKeys.ZEN_MODE_ACTIVE);
-        if (key.scope === 0 ) {
-            if (!isZenMode || !key.zenModeIgnore) {
-                this.saveKeyToStorage(key);
-                this.updateLegacySettingsFromState(key, value);
-            }
-        }
-    }
-    isActivityBarHidden() {
-        const oldValue = this.configurationService.getValue('workbench.activityBar.visible');
-        if (oldValue !== undefined) {
-            return !oldValue;
-        }
-        return this.configurationService.getValue("workbench.activityBar.location" ) !== "default" ;
-    }
-    setRuntimeValueAndFire(key, value) {
-        const previousValue = this.stateCache.get(key.name);
-        if (previousValue === value) {
-            return;
-        }
-        this.setRuntimeValue(key, value);
-        this._onDidChangeState.fire({ key, value });
-    }
-    saveKeyToStorage(key) {
-        const value = this.stateCache.get(key.name);
-        this.storageService.store(`${LayoutStateModel.STORAGE_PREFIX}${key.name}`, typeof value === 'object' ? JSON.stringify(value) : value, key.scope, key.target);
-    }
-    loadKeyFromStorage(key) {
-        let value = this.storageService.get(`${LayoutStateModel.STORAGE_PREFIX}${key.name}`, key.scope);
-        if (value !== undefined) {
-            switch (typeof key.defaultValue) {
-                case 'boolean':
-                    value = value === 'true';
-                    break;
-                case 'number':
-                    value = parseInt(value);
-                    break;
-                case 'object':
-                    value = JSON.parse(value);
-                    break;
-            }
-        }
-        return value;
-    }
-}
-export { Layout, TITLE_BAR_SETTINGS };