@codingame/monaco-vscode-api 1.82.2 → 1.82.4-next.0

package/vscode/src/vs/workbench/browser/parts/titlebar/titlebarPart.js

@@ -0,0 +1,365 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/titlebarpart.css.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Part } from '../../part.js';
+import { isWCOEnabled, getZoomFactor } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { getTitleBarStyle, getMenuBarVisibility } from '../../../../platform/window/common/window.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { StandardMouseEvent } from 'monaco-editor/esm/vs/base/browser/mouseEvent.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../../services/environment/browser/environmentService.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { TITLE_BAR_INACTIVE_BACKGROUND, TITLE_BAR_ACTIVE_BACKGROUND, WORKBENCH_BACKGROUND, TITLE_BAR_INACTIVE_FOREGROUND, TITLE_BAR_ACTIVE_FOREGROUND, TITLE_BAR_BORDER } from '../../../common/theme.js';
+import { isWeb, isMacintosh, isWindows, isLinux, isNative, platformLocale } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { append, $, reset, prepend, EventType, addDisposableListener, EventHelper, isAncestor, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { CustomMenubarControl } from './menubarControl.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { WindowTitle } from './windowTitle.js';
+import { CommandCenterControl } from './commandCenterControl.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { MenuWorkbenchToolBar } from 'monaco-editor/esm/vs/platform/actions/browser/toolbar.js';
+var TitlebarPart_1;
+let TitlebarPart = class TitlebarPart extends Part {
+    static { TitlebarPart_1 = this; }
+    static { this.configCommandCenter = 'window.commandCenter'; }
+    get minimumHeight() {
+        const value = this.isCommandCenterVisible || (isWeb && isWCOEnabled()) ? 35 : 30;
+        return value / (this.useCounterZoom ? getZoomFactor() : 1);
+    }
+    get maximumHeight() { return this.minimumHeight; }
+    constructor(contextMenuService, configurationService, environmentService, instantiationService, themeService, storageService, layoutService, contextKeyService, hostService, hoverService) {
+        super("workbench.parts.titlebar" , { hasTitle: false }, themeService, storageService, layoutService);
+        this.contextMenuService = contextMenuService;
+        this.configurationService = configurationService;
+        this.environmentService = environmentService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.hostService = hostService;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this._onMenubarVisibilityChange = this._register(( new Emitter()));
+        this.onMenubarVisibilityChange = this._onMenubarVisibilityChange.event;
+        this._onDidChangeCommandCenterVisibility = ( new Emitter());
+        this.onDidChangeCommandCenterVisibility = this._onDidChangeCommandCenterVisibility.event;
+        this.titleDisposables = this._register(( new DisposableStore()));
+        this.isInactive = false;
+        this.windowTitle = this._register(instantiationService.createInstance(WindowTitle));
+        this.titleBarStyle = getTitleBarStyle(this.configurationService);
+        this.hoverDelegate = new (class {
+            constructor() {
+                this._lastHoverHideTime = 0;
+                this.showHover = hoverService.showHover.bind(hoverService);
+                this.placement = 'element';
+            }
+            get delay() {
+                return Date.now() - this._lastHoverHideTime < 200
+                    ? 0
+                    : configurationService.getValue('workbench.hover.delay');
+            }
+            onDidHideHover() {
+                this._lastHoverHideTime = Date.now();
+            }
+        });
+        this.registerListeners();
+    }
+    updateProperties(properties) {
+        this.windowTitle.updateProperties(properties);
+    }
+    get isCommandCenterVisible() {
+        return this.configurationService.getValue(TitlebarPart_1.configCommandCenter);
+    }
+    registerListeners() {
+        this._register(this.hostService.onDidChangeFocus(focused => focused ? this.onFocus() : this.onBlur()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationChanged(e)));
+    }
+    onBlur() {
+        this.isInactive = true;
+        this.updateStyles();
+    }
+    onFocus() {
+        this.isInactive = false;
+        this.updateStyles();
+    }
+    onConfigurationChanged(event) {
+        if (this.titleBarStyle !== 'native' && (!isMacintosh || isWeb)) {
+            if (event.affectsConfiguration('window.menuBarVisibility')) {
+                if (this.currentMenubarVisibility === 'compact') {
+                    this.uninstallMenubar();
+                }
+                else {
+                    this.installMenubar();
+                }
+            }
+        }
+        if (this.titleBarStyle !== 'native' && this.layoutControls && event.affectsConfiguration('workbench.layoutControl.enabled')) {
+            this.layoutControls.classList.toggle('show-layout-control', this.layoutControlEnabled);
+            this._onDidChange.fire(undefined);
+        }
+        if (event.affectsConfiguration(TitlebarPart_1.configCommandCenter)) {
+            this.updateTitle();
+            this._onDidChangeCommandCenterVisibility.fire();
+            this._onDidChange.fire(undefined);
+        }
+    }
+    onMenubarVisibilityChanged(visible) {
+        if (isWeb || isWindows || isLinux) {
+            if (this.lastLayoutDimensions) {
+                this.layout(this.lastLayoutDimensions.width, this.lastLayoutDimensions.height);
+            }
+            this._onMenubarVisibilityChange.fire(visible);
+        }
+    }
+    uninstallMenubar() {
+        if (this.customMenubar) {
+            this.customMenubar.dispose();
+            this.customMenubar = undefined;
+        }
+        if (this.menubar) {
+            this.menubar.remove();
+            this.menubar = undefined;
+        }
+        this.onMenubarVisibilityChanged(false);
+    }
+    installMenubar() {
+        if (this.menubar) {
+            return;
+        }
+        this.customMenubar = this._register(this.instantiationService.createInstance(CustomMenubarControl));
+        this.menubar = append(this.leftContent, $('div.menubar'));
+        this.menubar.setAttribute('role', 'menubar');
+        this._register(this.customMenubar.onVisibilityChange(e => this.onMenubarVisibilityChanged(e)));
+        this.customMenubar.create(this.menubar);
+    }
+    updateTitle() {
+        this.titleDisposables.clear();
+        if (!this.isCommandCenterVisible) {
+            this.title.innerText = this.windowTitle.value;
+            this.titleDisposables.add(this.windowTitle.onDidChange(() => {
+                this.title.innerText = this.windowTitle.value;
+            }));
+        }
+        else {
+            const commandCenter = this.instantiationService.createInstance(CommandCenterControl, this.windowTitle, this.hoverDelegate);
+            reset(this.title, commandCenter.element);
+            this.titleDisposables.add(commandCenter);
+        }
+    }
+    createContentArea(parent) {
+        this.element = parent;
+        this.rootContainer = append(parent, $('.titlebar-container'));
+        this.leftContent = append(this.rootContainer, $('.titlebar-left'));
+        this.centerContent = append(this.rootContainer, $('.titlebar-center'));
+        this.rightContent = append(this.rootContainer, $('.titlebar-right'));
+        if (!isMacintosh && !isWeb) {
+            this.appIcon = prepend(this.leftContent, $('a.window-appicon'));
+            if (isWeb) {
+                const homeIndicator = this.environmentService.options?.homeIndicator;
+                if (homeIndicator) {
+                    const icon = getIconRegistry().getIcon(homeIndicator.icon) ? { id: homeIndicator.icon } : Codicon.code;
+                    this.appIcon.setAttribute('href', homeIndicator.href);
+                    this.appIcon.classList.add(...ThemeIcon.asClassNameArray(icon));
+                    this.appIconBadge = document.createElement('div');
+                    this.appIconBadge.classList.add('home-bar-icon-badge');
+                    this.appIcon.appendChild(this.appIconBadge);
+                }
+            }
+        }
+        this.dragRegion = prepend(this.rootContainer, $('div.titlebar-drag-region'));
+        if (this.titleBarStyle !== 'native'
+            && (!isMacintosh || isWeb)
+            && this.currentMenubarVisibility !== 'compact') {
+            this.installMenubar();
+        }
+        this.title = append(this.centerContent, $('div.window-title'));
+        this.updateTitle();
+        if (this.titleBarStyle !== 'native') {
+            this.layoutControls = append(this.rightContent, $('div.layout-controls-container'));
+            this.layoutControls.classList.toggle('show-layout-control', this.layoutControlEnabled);
+            this.layoutToolbar = this.instantiationService.createInstance(MenuWorkbenchToolBar, this.layoutControls, MenuId.LayoutControlMenu, {
+                contextMenu: MenuId.TitleBarContext,
+                toolbarOptions: { primaryGroup: () => true },
+                actionViewItemProvider: action => {
+                    return createActionViewItem(this.instantiationService, action, { hoverDelegate: this.hoverDelegate });
+                }
+            });
+        }
+        let primaryControlLocation = isMacintosh ? 'left' : 'right';
+        if (isMacintosh && isNative) {
+            const localeInfo = new Intl.Locale(platformLocale);
+            if (localeInfo?.textInfo?.direction === 'rtl') {
+                primaryControlLocation = 'right';
+            }
+        }
+        this.primaryWindowControls = append(primaryControlLocation === 'left' ? this.leftContent : this.rightContent, $('div.window-controls-container.primary'));
+        append(primaryControlLocation === 'left' ? this.rightContent : this.leftContent, $('div.window-controls-container.secondary'));
+        [EventType.CONTEXT_MENU, EventType.MOUSE_DOWN].forEach(event => {
+            this._register(addDisposableListener(this.rootContainer, event, e => {
+                if (e.type === EventType.CONTEXT_MENU || (e.target === this.title && e.metaKey)) {
+                    EventHelper.stop(e);
+                    this.onContextMenu(e, e.target === this.title ? MenuId.TitleBarTitleContext : MenuId.TitleBarContext);
+                }
+            }));
+        });
+        this._register(addDisposableListener(this.element, EventType.MOUSE_DOWN, e => {
+            if (e.target && this.menubar && isAncestor(e.target, this.menubar)) {
+                return;
+            }
+            if (e.target && this.layoutToolbar && isAncestor(e.target, this.layoutToolbar.getElement())) {
+                return;
+            }
+            if (e.target && isAncestor(e.target, this.title)) {
+                return;
+            }
+            const active = document.activeElement;
+            setTimeout(() => {
+                if (active instanceof HTMLElement) {
+                    active.focus();
+                }
+            }, 0 );
+        }, true ));
+        this.updateStyles();
+        const that = this;
+        registerAction2(class FocusTitleBar extends Action2 {
+            constructor() {
+                super({
+                    id: `workbench.action.focusTitleBar`,
+                    title: { value: ( localize('focusTitleBar', "Focus Title Bar")), original: 'Focus Title Bar' },
+                    category: Categories.View,
+                    f1: true,
+                });
+            }
+            run(accessor, ...args) {
+                if (that.customMenubar) {
+                    that.customMenubar.toggleFocus();
+                }
+                else {
+                    that.element.querySelector('[tabindex]:not([tabindex="-1"])').focus();
+                }
+            }
+        });
+        return this.element;
+    }
+    updateStyles() {
+        super.updateStyles();
+        if (this.element) {
+            if (this.isInactive) {
+                this.element.classList.add('inactive');
+            }
+            else {
+                this.element.classList.remove('inactive');
+            }
+            const titleBackground = this.getColor(this.isInactive ? TITLE_BAR_INACTIVE_BACKGROUND : TITLE_BAR_ACTIVE_BACKGROUND, (color, theme) => {
+                return color.isOpaque() ? color : color.makeOpaque(WORKBENCH_BACKGROUND(theme));
+            }) || '';
+            this.element.style.backgroundColor = titleBackground;
+            if (this.appIconBadge) {
+                this.appIconBadge.style.backgroundColor = titleBackground;
+            }
+            if (titleBackground && ( Color.fromHex(titleBackground)).isLighter()) {
+                this.element.classList.add('light');
+            }
+            else {
+                this.element.classList.remove('light');
+            }
+            const titleForeground = this.getColor(this.isInactive ? TITLE_BAR_INACTIVE_FOREGROUND : TITLE_BAR_ACTIVE_FOREGROUND);
+            this.element.style.color = titleForeground || '';
+            const titleBorder = this.getColor(TITLE_BAR_BORDER);
+            this.element.style.borderBottom = titleBorder ? `1px solid ${titleBorder}` : '';
+        }
+    }
+    onContextMenu(e, menuId) {
+        const event = ( new StandardMouseEvent(e));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => event,
+            menuId,
+            contextKeyService: this.contextKeyService,
+            domForShadowRoot: isMacintosh && isNative ? event.target : undefined
+        });
+    }
+    get currentMenubarVisibility() {
+        return getMenuBarVisibility(this.configurationService);
+    }
+    get layoutControlEnabled() {
+        return this.configurationService.getValue('workbench.layoutControl.enabled');
+    }
+    get useCounterZoom() {
+        const zoomFactor = getZoomFactor();
+        const noMenubar = this.currentMenubarVisibility === 'hidden' || (!isWeb && isMacintosh);
+        const noCommandCenter = !this.isCommandCenterVisible;
+        const noLayoutControls = !this.layoutControlEnabled;
+        return zoomFactor < 1 || (noMenubar && noCommandCenter && noLayoutControls);
+    }
+    updateLayout(dimension) {
+        this.lastLayoutDimensions = dimension;
+        if (getTitleBarStyle(this.configurationService) === 'custom') {
+            const zoomFactor = getZoomFactor();
+            this.element.style.setProperty('--zoom-factor', ( zoomFactor.toString()));
+            this.rootContainer.classList.toggle('counter-zoom', this.useCounterZoom);
+            if (this.customMenubar) {
+                const menubarDimension = ( new Dimension(0, dimension.height));
+                this.customMenubar.layout(menubarDimension);
+            }
+        }
+    }
+    layout(width, height) {
+        this.updateLayout(( new Dimension(width, height)));
+        super.layoutContents(width, height);
+    }
+    toJSON() {
+        return {
+            type: "workbench.parts.titlebar"
+        };
+    }
+};
+TitlebarPart = TitlebarPart_1 = ( __decorate([
+    ( __param(0, IContextMenuService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IBrowserWorkbenchEnvironmentService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IWorkbenchLayoutService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IHostService)),
+    ( __param(9, IHoverService))
+], TitlebarPart));
+class ToogleConfigAction extends Action2 {
+    constructor(section, title, order) {
+        super({
+            id: `toggle.${section}`,
+            title,
+            toggled: ( ContextKeyExpr.equals(`config.${section}`, true)),
+            menu: { id: MenuId.TitleBarContext, order }
+        });
+        this.section = section;
+    }
+    run(accessor, ...args) {
+        const configService = accessor.get(IConfigurationService);
+        const value = configService.getValue(this.section);
+        configService.updateValue(this.section, !value);
+    }
+}
+registerAction2(class ToogleCommandCenter extends ToogleConfigAction {
+    constructor() {
+        super('window.commandCenter', ( localize('toggle.commandCenter', 'Command Center')), 1);
+    }
+});
+registerAction2(class ToogleLayoutControl extends ToogleConfigAction {
+    constructor() {
+        super('workbench.layoutControl.enabled', ( localize('toggle.layout', 'Layout Controls')), 2);
+    }
+});
+export { TitlebarPart };

package/vscode/src/vs/workbench/browser/parts/titlebar/windowTitle.js

@@ -0,0 +1,216 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { dirname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IBrowserWorkbenchEnvironmentService } from '../../../services/environment/browser/environmentService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { isWindows, isMacintosh, isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { trim } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { template } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { getVirtualWorkspaceLocation } from '../../../../platform/workspace/common/virtualWorkspace.js';
+import { IUserDataProfileService } from '../../../services/userDataProfile/common/userDataProfile.js';
+import { IViewsService } from '../../../common/views.js';
+var WindowTitle_1;
+let WindowTitle = class WindowTitle extends Disposable {
+    static { WindowTitle_1 = this; }
+    static { this.NLS_USER_IS_ADMIN = isWindows ? ( localize('userIsAdmin', "[Administrator]")) : ( localize('userIsSudo', "[Superuser]")); }
+    static { this.NLS_EXTENSION_HOST = ( localize('devExtensionWindowTitlePrefix', "[Extension Development Host]")); }
+    static { this.TITLE_DIRTY = '\u25cf '; }
+    constructor(configurationService, editorService, environmentService, contextService, instantiationService, labelService, userDataProfileService, productService, viewsService) {
+        super();
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.environmentService = environmentService;
+        this.contextService = contextService;
+        this.instantiationService = instantiationService;
+        this.labelService = labelService;
+        this.userDataProfileService = userDataProfileService;
+        this.productService = productService;
+        this.viewsService = viewsService;
+        this.properties = { isPure: true, isAdmin: false, prefix: undefined };
+        this.activeEditorListeners = this._register(( new DisposableStore()));
+        this.titleUpdater = this._register(( new RunOnceScheduler(() => this.doUpdateTitle(), 0)));
+        this.onDidChangeEmitter = ( new Emitter());
+        this.onDidChange = this.onDidChangeEmitter.event;
+        this.registerListeners();
+    }
+    get value() {
+        return this.title ?? '';
+    }
+    get workspaceName() {
+        return this.labelService.getWorkspaceLabel(this.contextService.getWorkspace());
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationChanged(e)));
+        this._register(this.editorService.onDidActiveEditorChange(() => this.onActiveEditorChange()));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.titleUpdater.schedule()));
+        this._register(this.contextService.onDidChangeWorkbenchState(() => this.titleUpdater.schedule()));
+        this._register(this.contextService.onDidChangeWorkspaceName(() => this.titleUpdater.schedule()));
+        this._register(this.labelService.onDidChangeFormatters(() => this.titleUpdater.schedule()));
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => this.titleUpdater.schedule()));
+        this._register(this.viewsService.onDidChangeFocusedView(() => this.titleUpdater.schedule()));
+    }
+    onConfigurationChanged(event) {
+        if (event.affectsConfiguration("window.title" ) || event.affectsConfiguration("window.titleSeparator" )) {
+            this.titleUpdater.schedule();
+        }
+    }
+    onActiveEditorChange() {
+        this.activeEditorListeners.clear();
+        this.titleUpdater.schedule();
+        const activeEditor = this.editorService.activeEditor;
+        if (activeEditor) {
+            this.activeEditorListeners.add(activeEditor.onDidChangeDirty(() => this.titleUpdater.schedule()));
+            this.activeEditorListeners.add(activeEditor.onDidChangeLabel(() => this.titleUpdater.schedule()));
+        }
+    }
+    doUpdateTitle() {
+        const title = this.getFullWindowTitle();
+        if (title !== this.title) {
+            let nativeTitle = title;
+            if (!trim(nativeTitle)) {
+                nativeTitle = this.productService.nameLong;
+            }
+            if (!window.document.title && isMacintosh && nativeTitle === this.productService.nameLong) {
+                window.document.title = `${this.productService.nameLong} ${WindowTitle_1.TITLE_DIRTY}`;
+            }
+            window.document.title = nativeTitle;
+            this.title = title;
+            this.onDidChangeEmitter.fire();
+        }
+    }
+    getFullWindowTitle() {
+        let title = this.getWindowTitle() || this.productService.nameLong;
+        const { prefix, suffix } = this.getTitleDecorations();
+        if (prefix) {
+            title = `${prefix} ${title}`;
+        }
+        if (suffix) {
+            title = `${title} ${suffix}`;
+        }
+        title = title.replace(/[^\S ]/g, ' ');
+        return title;
+    }
+    getTitleDecorations() {
+        let prefix;
+        let suffix;
+        if (this.properties.prefix) {
+            prefix = this.properties.prefix;
+        }
+        if (this.environmentService.isExtensionDevelopment) {
+            prefix = !prefix
+                ? WindowTitle_1.NLS_EXTENSION_HOST
+                : `${WindowTitle_1.NLS_EXTENSION_HOST} - ${prefix}`;
+        }
+        if (this.properties.isAdmin) {
+            suffix = WindowTitle_1.NLS_USER_IS_ADMIN;
+        }
+        return { prefix, suffix };
+    }
+    updateProperties(properties) {
+        const isAdmin = typeof properties.isAdmin === 'boolean' ? properties.isAdmin : this.properties.isAdmin;
+        const isPure = typeof properties.isPure === 'boolean' ? properties.isPure : this.properties.isPure;
+        const prefix = typeof properties.prefix === 'string' ? properties.prefix : this.properties.prefix;
+        if (isAdmin !== this.properties.isAdmin || isPure !== this.properties.isPure || prefix !== this.properties.prefix) {
+            this.properties.isAdmin = isAdmin;
+            this.properties.isPure = isPure;
+            this.properties.prefix = prefix;
+            this.titleUpdater.schedule();
+        }
+    }
+    getWindowTitle() {
+        const editor = this.editorService.activeEditor;
+        const workspace = this.contextService.getWorkspace();
+        let root;
+        if (workspace.configuration) {
+            root = workspace.configuration;
+        }
+        else if (workspace.folders.length) {
+            root = workspace.folders[0].uri;
+        }
+        const editorResource = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        let editorFolderResource = editorResource ? dirname(editorResource) : undefined;
+        if (editorFolderResource?.path === '.') {
+            editorFolderResource = undefined;
+        }
+        let folder = undefined;
+        if (this.contextService.getWorkbenchState() === 2 ) {
+            folder = workspace.folders[0];
+        }
+        else if (editorResource) {
+            folder = this.contextService.getWorkspaceFolder(editorResource) ?? undefined;
+        }
+        let remoteName = undefined;
+        if (this.environmentService.remoteAuthority && !isWeb) {
+            remoteName = this.labelService.getHostLabel(Schemas.vscodeRemote, this.environmentService.remoteAuthority);
+        }
+        else {
+            const virtualWorkspaceLocation = getVirtualWorkspaceLocation(workspace);
+            if (virtualWorkspaceLocation) {
+                remoteName = this.labelService.getHostLabel(virtualWorkspaceLocation.scheme, virtualWorkspaceLocation.authority);
+            }
+        }
+        const activeEditorShort = editor ? editor.getTitle(0 ) : '';
+        const activeEditorMedium = editor ? editor.getTitle(1 ) : activeEditorShort;
+        const activeEditorLong = editor ? editor.getTitle(2 ) : activeEditorMedium;
+        const activeFolderShort = editorFolderResource ? basename(editorFolderResource) : '';
+        const activeFolderMedium = editorFolderResource ? this.labelService.getUriLabel(editorFolderResource, { relative: true }) : '';
+        const activeFolderLong = editorFolderResource ? this.labelService.getUriLabel(editorFolderResource) : '';
+        const rootName = this.labelService.getWorkspaceLabel(workspace);
+        const rootNameShort = this.labelService.getWorkspaceLabel(workspace, { verbose: 0  });
+        const rootPath = root ? this.labelService.getUriLabel(root) : '';
+        const folderName = folder ? folder.name : '';
+        const folderPath = folder ? this.labelService.getUriLabel(folder.uri) : '';
+        const dirty = editor?.isDirty() && !editor.isSaving() ? WindowTitle_1.TITLE_DIRTY : '';
+        const appName = this.productService.nameLong;
+        const profileName = this.userDataProfileService.currentProfile.isDefault ? '' : this.userDataProfileService.currentProfile.name;
+        const separator = this.configurationService.getValue("window.titleSeparator" );
+        const titleTemplate = this.configurationService.getValue("window.title" );
+        const focusedView = this.viewsService.getFocusedViewName();
+        return template(titleTemplate, {
+            activeEditorShort,
+            activeEditorLong,
+            activeEditorMedium,
+            activeFolderShort,
+            activeFolderMedium,
+            activeFolderLong,
+            rootName,
+            rootPath,
+            rootNameShort,
+            folderName,
+            folderPath,
+            dirty,
+            appName,
+            remoteName,
+            profileName,
+            focusedView,
+            separator: { label: separator }
+        });
+    }
+    isCustomTitleFormat() {
+        const title = this.configurationService.inspect("window.title" );
+        const titleSeparator = this.configurationService.inspect("window.titleSeparator" );
+        return title.value !== title.defaultValue || titleSeparator.value !== titleSeparator.defaultValue;
+    }
+};
+WindowTitle = WindowTitle_1 = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IBrowserWorkbenchEnvironmentService)),
+    ( __param(3, IWorkspaceContextService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, IUserDataProfileService)),
+    ( __param(7, IProductService)),
+    ( __param(8, IViewsService))
+], WindowTitle));
+export { WindowTitle };

package/vscode/src/vs/workbench/common/contextkeys.js

@@ -29,8 +29,16 @@ const VirtualWorkspaceContext = ( new RawContextKey('virtualWorkspace', '', ( lo
     'virtualWorkspace',
     "The scheme of the current workspace is from a virtual file system or an empty string."
 ))));
+const TemporaryWorkspaceContext = ( new RawContextKey('temporaryWorkspace', false, ( localize(
+    'temporaryWorkspace',
+    "The scheme of the current workspace is from a temporary file system."
+))));
 const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
 const HasWebFileSystemAccess = ( new RawContextKey('hasWebFileSystemAccess', false, true));
+const EmbedderIdentifierContext = ( new RawContextKey('embedderIdentifier', undefined, ( localize(
+    'embedderIdentifier',
+    'The identifier of the embedder according to the product service, if one is defined'
+))));
 const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
 const ActiveEditorPinnedContext = ( new RawContextKey('activeEditorIsNotPreview', false, ( localize(
     'activeEditorIsNotPreview',
@@ -45,10 +53,12 @@ const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastIn
     "Whether the active editor is the last one in its group"
 ))));
 const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
+const ActiveEditorReadonlyContext = ( new RawContextKey('activeEditorIsReadonly', false, ( localize('activeEditorIsReadonly', "Whether the active editor is read-only"))));
 const ActiveEditorCanToggleReadonlyContext = ( new RawContextKey('activeEditorCanToggleReadonly', true, ( localize(
     'activeEditorCanToggleReadonly',
     "Whether the active editor can toggle between being read-only or writeable"
 ))));
+const ActiveEditorCanRevertContext = ( new RawContextKey('activeEditorCanRevert', false, ( localize('activeEditorCanRevert', "Whether the active editor can revert"))));
 const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
 const ActiveEditorContext = ( new RawContextKey('activeEditor', null, { type: 'string', description: ( localize('activeEditor', "The identifier of the active editor")) }));
 const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
@@ -60,15 +70,24 @@ const TextCompareEditorActiveContext = ( new RawContextKey('textCompareEditorAct
 const SideBySideEditorActiveContext = ( new RawContextKey('sideBySideEditorActive', false, ( localize('sideBySideEditorActive', "Whether a side by side editor is active"))));
 const EditorGroupEditorsCountContext = ( new RawContextKey('groupEditorsCount', 0, ( localize('groupEditorsCount', "The number of opened editor groups"))));
 const ActiveEditorGroupEmptyContext = ( new RawContextKey('activeEditorGroupEmpty', false, ( localize('activeEditorGroupEmpty', "Whether the active editor group is empty"))));
+const ActiveEditorGroupIndexContext = ( new RawContextKey('activeEditorGroupIndex', 0, ( localize('activeEditorGroupIndex', "The index of the active editor group"))));
+const ActiveEditorGroupLastContext = ( new RawContextKey('activeEditorGroupLast', false, ( localize(
+    'activeEditorGroupLast',
+    "Whether the active editor group is the last group"
+))));
 const ActiveEditorGroupLockedContext = ( new RawContextKey('activeEditorGroupLocked', false, ( localize('activeEditorGroupLocked', "Whether the active editor group is locked"))));
 const MultipleEditorGroupsContext = ( new RawContextKey('multipleEditorGroups', false, ( localize('multipleEditorGroups', "Whether there are multiple editor groups opened"))));
+const EditorsVisibleContext = ( new RawContextKey('editorIsOpen', false, ( localize('editorIsOpen', "Whether an editor is open"))));
 const InEditorZenModeContext = ( new RawContextKey('inZenMode', false, ( localize('inZenMode', "Whether Zen mode is enabled"))));
 const IsCenteredLayoutContext = ( new RawContextKey('isCenteredLayout', false, ( localize('isCenteredLayout', "Whether centered layout is enabled"))));
+const SplitEditorsVertically = ( new RawContextKey('splitEditorsVertically', false, ( localize('splitEditorsVertically', "Whether editors split vertically"))));
+const EditorAreaVisibleContext = ( new RawContextKey('editorAreaVisible', true, ( localize('editorAreaVisible', "Whether the editor area is visible"))));
 const EditorTabsVisibleContext = ( new RawContextKey('editorTabsVisible', true, ( localize('editorTabsVisible', "Whether editor tabs are visible"))));
 const SideBarVisibleContext = ( new RawContextKey('sideBarVisible', false, ( localize('sideBarVisible', "Whether the sidebar is visible"))));
 const SidebarFocusContext = ( new RawContextKey('sideBarFocus', false, ( localize('sideBarFocus', "Whether the sidebar has keyboard focus"))));
 const ActiveViewletContext = ( new RawContextKey('activeViewlet', '', ( localize('activeViewlet', "The identifier of the active viewlet"))));
 const StatusBarFocused = ( new RawContextKey('statusBarFocused', false, ( localize('statusBarFocused', "Whether the status bar has keyboard focus"))));
+const BannerFocused = ( new RawContextKey('bannerFocused', false, ( localize('bannerFocused', "Whether the banner has keyboard focus"))));
 const NotificationFocusedContext = ( new RawContextKey('notificationFocus', true, ( localize('notificationFocus', "Whether a notification has keyboard focus"))));
 const NotificationsCenterVisibleContext = ( new RawContextKey('notificationCenterVisible', false, ( localize('notificationCenterVisible', "Whether the notifications center is visible"))));
 const NotificationsToastsVisibleContext = ( new RawContextKey('notificationToastsVisible', false, ( localize('notificationToastsVisible', "Whether a notification toast is visible"))));
@@ -83,6 +102,7 @@ const PanelAlignmentContext = ( new RawContextKey('panelAlignment', 'center', (
     "The alignment of the panel, either 'center', 'left', 'right' or 'justify'"
 ))));
 const PanelVisibleContext = ( new RawContextKey('panelVisible', false, ( localize('panelVisible', "Whether the panel is visible"))));
+const PanelMaximizedContext = ( new RawContextKey('panelMaximized', false, ( localize('panelMaximized', "Whether the panel is maximized"))));
 const FocusedViewContext = ( new RawContextKey('focusedView', '', ( localize('focusedView', "The identifier of the view that has keyboard focus"))));
 function getVisbileViewContextKey(viewId) { return `view.${viewId}.visible`; }
 function getEnabledViewContainerContextKey(viewContainerId) { return `viewContainer.${viewContainerId}.enabled`; }
@@ -220,4 +240,4 @@ function applyAvailableEditorIds(contextKey, editor, editorResolverService) {
         contextKey.set(editors.join(','));
     }
 }
-export { ActiveAuxiliaryContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, StatusBarFocused, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getEnabledViewContainerContextKey, getVisbileViewContextKey };
+export { ActiveAuxiliaryContext, ActiveEditorAvailableEditorIdsContext, ActiveEditorCanRevertContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupIndexContext, ActiveEditorGroupLastContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorReadonlyContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarFocusContext, AuxiliaryBarVisibleContext, BannerFocused, DirtyWorkingCopiesContext, EditorAreaVisibleContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EditorsVisibleContext, EmbedderIdentifierContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelMaximizedContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, SplitEditorsVertically, StatusBarFocused, TemporaryWorkspaceContext, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, applyAvailableEditorIds, getEnabledViewContainerContextKey, getVisbileViewContextKey };