@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -0,0 +1,2059 @@
+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 };