@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/browser/parts/titlebar/menubarControl.js

@@ -0,0 +1,600 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/menubarControl.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { MenuId, SubmenuItemAction, registerAction2, Action2, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { getMenuBarVisibility, getTitleBarStyle } from '../../../../platform/window/common/window.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Separator, Action, ActionRunner, SubmenuAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { addDisposableListener, EventType, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { isMacintosh, isNative, isWeb, isIOS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isRecentFolder, isRecentWorkspace, IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IUpdateService } from '../../../../platform/update/common/update.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { MenuBar } from '../../../../base/browser/ui/menu/menubar.js';
+import { Direction } from 'monaco-editor/esm/vs/base/browser/ui/menu/menu.js';
+import { unmnemonicLabel, mnemonicMenuLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { isFullscreen } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
+import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { OpenRecentAction } from '../../actions/windowActions.js';
+import { isICommandActionToggleInfo } from 'monaco-editor/esm/vs/platform/action/common/action.js';
+import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { defaultMenuStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+class MenubarControl extends Disposable {
+    constructor(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, hostService, commandService) {
+        super();
+        this.menuService = menuService;
+        this.workspacesService = workspacesService;
+        this.contextKeyService = contextKeyService;
+        this.keybindingService = keybindingService;
+        this.configurationService = configurationService;
+        this.labelService = labelService;
+        this.updateService = updateService;
+        this.storageService = storageService;
+        this.notificationService = notificationService;
+        this.preferencesService = preferencesService;
+        this.environmentService = environmentService;
+        this.accessibilityService = accessibilityService;
+        this.hostService = hostService;
+        this.commandService = commandService;
+        this.keys = [
+            'window.menuBarVisibility',
+            'window.enableMenuBarMnemonics',
+            'window.customMenuBarAltFocus',
+            'workbench.sideBar.location',
+            'window.nativeTabs'
+        ];
+        this.menus = {};
+        this.topLevelTitles = {};
+        this.recentlyOpened = { files: [], workspaces: [] };
+        this.mainMenu = this._register(this.menuService.createMenu(MenuId.MenubarMainMenu, this.contextKeyService));
+        this.mainMenuDisposables = this._register(( new DisposableStore()));
+        this.setupMainMenu();
+        this.menuUpdater = this._register(( new RunOnceScheduler(() => this.doUpdateMenubar(false), 200)));
+        this.notifyUserOfCustomMenubarAccessibility();
+    }
+    registerListeners() {
+        this._register(this.hostService.onDidChangeFocus(e => this.onDidChangeWindowFocus(e)));
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        this.updateService.onStateChange(() => this.onUpdateStateChange());
+        this._register(this.workspacesService.onDidChangeRecentlyOpened(() => { this.onDidChangeRecentlyOpened(); }));
+        this._register(this.keybindingService.onDidUpdateKeybindings(() => this.updateMenubar()));
+        this._register(this.labelService.onDidChangeFormatters(() => { this.onDidChangeRecentlyOpened(); }));
+        this._register(this.mainMenu.onDidChange(() => { this.setupMainMenu(); this.doUpdateMenubar(true); }));
+    }
+    setupMainMenu() {
+        this.mainMenuDisposables.clear();
+        this.menus = {};
+        this.topLevelTitles = {};
+        const [, mainMenuActions] = this.mainMenu.getActions()[0];
+        for (const mainMenuAction of mainMenuActions) {
+            if (mainMenuAction instanceof SubmenuItemAction && typeof mainMenuAction.item.title !== 'string') {
+                this.menus[mainMenuAction.item.title.original] = this.mainMenuDisposables.add(this.menuService.createMenu(mainMenuAction.item.submenu, this.contextKeyService, { emitEventsForSubmenuChanges: true }));
+                this.topLevelTitles[mainMenuAction.item.title.original] = mainMenuAction.item.title.mnemonicTitle ?? mainMenuAction.item.title.value;
+            }
+        }
+    }
+    updateMenubar() {
+        this.menuUpdater.schedule();
+    }
+    calculateActionLabel(action) {
+        const label = action.label;
+        return label;
+    }
+    onUpdateStateChange() {
+        this.updateMenubar();
+    }
+    onUpdateKeybindings() {
+        this.updateMenubar();
+    }
+    getOpenRecentActions() {
+        if (!this.recentlyOpened) {
+            return [];
+        }
+        const { workspaces, files } = this.recentlyOpened;
+        const result = [];
+        if (workspaces.length > 0) {
+            for (let i = 0; i < MenubarControl.MAX_MENU_RECENT_ENTRIES && i < workspaces.length; i++) {
+                result.push(this.createOpenRecentMenuAction(workspaces[i]));
+            }
+            result.push(( new Separator()));
+        }
+        if (files.length > 0) {
+            for (let i = 0; i < MenubarControl.MAX_MENU_RECENT_ENTRIES && i < files.length; i++) {
+                result.push(this.createOpenRecentMenuAction(files[i]));
+            }
+            result.push(( new Separator()));
+        }
+        return result;
+    }
+    onDidChangeWindowFocus(hasFocus) {
+        if (hasFocus) {
+            this.onDidChangeRecentlyOpened();
+        }
+    }
+    onConfigurationUpdated(event) {
+        if (( this.keys.some(key => event.affectsConfiguration(key)))) {
+            this.updateMenubar();
+        }
+        if (event.affectsConfiguration('editor.accessibilitySupport')) {
+            this.notifyUserOfCustomMenubarAccessibility();
+        }
+        if (event.affectsConfiguration('window.menuBarVisibility')) {
+            this.onDidChangeRecentlyOpened();
+        }
+    }
+    get menubarHidden() {
+        return isMacintosh && isNative ? false : getMenuBarVisibility(this.configurationService) === 'hidden';
+    }
+    onDidChangeRecentlyOpened() {
+        if (!this.menubarHidden) {
+            this.workspacesService.getRecentlyOpened().then(recentlyOpened => {
+                this.recentlyOpened = recentlyOpened;
+                this.updateMenubar();
+            });
+        }
+    }
+    createOpenRecentMenuAction(recent) {
+        let label;
+        let uri;
+        let commandId;
+        let openable;
+        const remoteAuthority = recent.remoteAuthority;
+        if (isRecentFolder(recent)) {
+            uri = recent.folderUri;
+            label = recent.label || this.labelService.getWorkspaceLabel(uri, { verbose: 2  });
+            commandId = 'openRecentFolder';
+            openable = { folderUri: uri };
+        }
+        else if (isRecentWorkspace(recent)) {
+            uri = recent.workspace.configPath;
+            label = recent.label || this.labelService.getWorkspaceLabel(recent.workspace, { verbose: 2  });
+            commandId = 'openRecentWorkspace';
+            openable = { workspaceUri: uri };
+        }
+        else {
+            uri = recent.fileUri;
+            label = recent.label || this.labelService.getUriLabel(uri);
+            commandId = 'openRecentFile';
+            openable = { fileUri: uri };
+        }
+        const ret = ( new Action(commandId, unmnemonicLabel(label), undefined, undefined, event => {
+            const browserEvent = event;
+            const openInNewWindow = event && ((!isMacintosh && (browserEvent.ctrlKey || browserEvent.shiftKey)) || (isMacintosh && (browserEvent.metaKey || browserEvent.altKey)));
+            return this.hostService.openWindow([openable], {
+                forceNewWindow: !!openInNewWindow,
+                remoteAuthority: remoteAuthority || null
+            });
+        }));
+        return Object.assign(ret, { uri, remoteAuthority });
+    }
+    notifyUserOfCustomMenubarAccessibility() {
+        if (isWeb || isMacintosh) {
+            return;
+        }
+        const hasBeenNotified = this.storageService.getBoolean('menubar/accessibleMenubarNotified', -1 , false);
+        const usingCustomMenubar = getTitleBarStyle(this.configurationService) === 'custom';
+        if (hasBeenNotified || usingCustomMenubar || !this.accessibilityService.isScreenReaderOptimized()) {
+            return;
+        }
+        const message = ( localize(
+            'menubar.customTitlebarAccessibilityNotification',
+            "Accessibility support is enabled for you. For the most accessible experience, we recommend the custom title bar style."
+        ));
+        this.notificationService.prompt(Severity.Info, message, [
+            {
+                label: ( localize('goToSetting', "Open Settings")),
+                run: () => {
+                    return this.preferencesService.openUserSettings({ query: 'window.titleBarStyle' });
+                }
+            }
+        ]);
+        this.storageService.store('menubar/accessibleMenubarNotified', true, -1 , 0 );
+    }
+}
+MenubarControl.MAX_MENU_RECENT_ENTRIES = 10;
+let CustomMenubarControl = class CustomMenubarControl extends MenubarControl {
+    constructor(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, layoutService, telemetryService, hostService, commandService) {
+        super(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, hostService, commandService);
+        this.layoutService = layoutService;
+        this.telemetryService = telemetryService;
+        this.alwaysOnMnemonics = false;
+        this.focusInsideMenubar = false;
+        this.pendingFirstTimeUpdate = false;
+        this.visible = true;
+        this.webNavigationMenu = this._register(this.menuService.createMenu(MenuId.MenubarHomeMenu, this.contextKeyService));
+        this.reinstallDisposables = this._register(( new DisposableStore()));
+        this._onVisibilityChange = this._register(( new Emitter()));
+        this._onFocusStateChange = this._register(( new Emitter()));
+        this.actionRunner = this._register(( new ActionRunner()));
+        this.actionRunner.onDidRun(e => {
+            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'menu' });
+        });
+        this.workspacesService.getRecentlyOpened().then((recentlyOpened) => {
+            this.recentlyOpened = recentlyOpened;
+        });
+        this.registerListeners();
+        this.registerActions();
+    }
+    doUpdateMenubar(firstTime) {
+        if (!this.focusInsideMenubar) {
+            this.setupCustomMenubar(firstTime);
+        }
+        if (firstTime) {
+            this.pendingFirstTimeUpdate = true;
+        }
+    }
+    registerActions() {
+        const that = this;
+        if (isWeb) {
+            this._register(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: `workbench.actions.menubar.focus`,
+                        title: { value: ( localize('focusMenu', "Focus Application Menu")), original: 'Focus Application Menu' },
+                        keybinding: {
+                            primary: 68 ,
+                            weight: 200 ,
+                            when: IsWebContext
+                        },
+                        f1: true
+                    });
+                }
+                async run() {
+                    that.menubar?.toggleFocus();
+                }
+            }));
+        }
+    }
+    getUpdateAction() {
+        const state = this.updateService.state;
+        switch (state.type) {
+            case "uninitialized" :
+                return null;
+            case "idle" :
+                return ( new Action('update.check', ( localize(
+                    { key: 'checkForUpdates', comment: ['&& denotes a mnemonic'] },
+                    "Check for &&Updates..."
+                )), undefined, true, () => this.updateService.checkForUpdates(true)));
+            case "checking for updates" :
+                return ( new Action('update.checking', ( localize('checkingForUpdates', "Checking for Updates...")), undefined, false));
+            case "available for download" :
+                return ( new Action('update.downloadNow', ( localize(
+                    { key: 'download now', comment: ['&& denotes a mnemonic'] },
+                    "D&&ownload Update"
+                )), undefined, true, () => this.updateService.downloadUpdate()));
+            case "downloading" :
+                return ( new Action('update.downloading', ( localize('DownloadingUpdate', "Downloading Update...")), undefined, false));
+            case "downloaded" :
+                return ( new Action('update.install', ( localize(
+                    { key: 'installUpdate...', comment: ['&& denotes a mnemonic'] },
+                    "Install &&Update..."
+                )), undefined, true, () => this.updateService.applyUpdate()));
+            case "updating" :
+                return ( new Action('update.updating', ( localize('installingUpdate', "Installing Update...")), undefined, false));
+            case "ready" :
+                return ( new Action('update.restart', ( localize(
+                    { key: 'restartToUpdate', comment: ['&& denotes a mnemonic'] },
+                    "Restart to &&Update"
+                )), undefined, true, () => this.updateService.quitAndInstall()));
+        }
+    }
+    get currentMenubarVisibility() {
+        return getMenuBarVisibility(this.configurationService);
+    }
+    get currentDisableMenuBarAltFocus() {
+        const settingValue = this.configurationService.getValue('window.customMenuBarAltFocus');
+        let disableMenuBarAltBehavior = false;
+        if (typeof settingValue === 'boolean') {
+            disableMenuBarAltBehavior = !settingValue;
+        }
+        return disableMenuBarAltBehavior;
+    }
+    insertActionsBefore(nextAction, target) {
+        switch (nextAction.id) {
+            case OpenRecentAction.ID:
+                target.push(...this.getOpenRecentActions());
+                break;
+            case 'workbench.action.showAboutDialog':
+                if (!isMacintosh && !isWeb) {
+                    const updateAction = this.getUpdateAction();
+                    if (updateAction) {
+                        updateAction.label = mnemonicMenuLabel(updateAction.label);
+                        target.push(updateAction);
+                        target.push(( new Separator()));
+                    }
+                }
+                break;
+        }
+    }
+    get currentEnableMenuBarMnemonics() {
+        let enableMenuBarMnemonics = this.configurationService.getValue('window.enableMenuBarMnemonics');
+        if (typeof enableMenuBarMnemonics !== 'boolean') {
+            enableMenuBarMnemonics = true;
+        }
+        return enableMenuBarMnemonics && (!isWeb || isFullscreen());
+    }
+    get currentCompactMenuMode() {
+        if (this.currentMenubarVisibility !== 'compact') {
+            return undefined;
+        }
+        const currentSidebarLocation = this.configurationService.getValue('workbench.sideBar.location');
+        return currentSidebarLocation === 'right' ? Direction.Left : Direction.Right;
+    }
+    onDidVisibilityChange(visible) {
+        this.visible = visible;
+        this.onDidChangeRecentlyOpened();
+        this._onVisibilityChange.fire(visible);
+    }
+    toActionsArray(menu) {
+        const result = [];
+        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result);
+        return result;
+    }
+    setupCustomMenubar(firstTime) {
+        if (!this.container) {
+            return;
+        }
+        if (firstTime) {
+            if (this.menubar) {
+                this.reinstallDisposables.clear();
+            }
+            this.menubar = this.reinstallDisposables.add(( new MenuBar(this.container, this.getMenuBarOptions(), defaultMenuStyles)));
+            this.accessibilityService.alwaysUnderlineAccessKeys().then(val => {
+                this.alwaysOnMnemonics = val;
+                this.menubar?.update(this.getMenuBarOptions());
+            });
+            this.reinstallDisposables.add(this.menubar.onFocusStateChange(focused => {
+                this._onFocusStateChange.fire(focused);
+                if (!focused) {
+                    if (this.pendingFirstTimeUpdate) {
+                        this.setupCustomMenubar(true);
+                        this.pendingFirstTimeUpdate = false;
+                    }
+                    else {
+                        this.updateMenubar();
+                    }
+                    this.focusInsideMenubar = false;
+                }
+            }));
+            this.reinstallDisposables.add(this.menubar.onVisibilityChange(e => this.onDidVisibilityChange(e)));
+            this.reinstallDisposables.add(addDisposableListener(this.container, EventType.FOCUS_IN, () => {
+                this.focusInsideMenubar = true;
+            }));
+            this.reinstallDisposables.add(addDisposableListener(this.container, EventType.FOCUS_OUT, () => {
+                this.focusInsideMenubar = false;
+            }));
+            if (this.menubar.isVisible) {
+                this.onDidVisibilityChange(true);
+            }
+        }
+        else {
+            this.menubar?.update(this.getMenuBarOptions());
+        }
+        const updateActions = (menuActions, target, topLevelTitle) => {
+            target.splice(0);
+            for (const menuItem of menuActions) {
+                this.insertActionsBefore(menuItem, target);
+                if (menuItem instanceof Separator) {
+                    target.push(menuItem);
+                }
+                else if (menuItem instanceof SubmenuItemAction || menuItem instanceof MenuItemAction) {
+                    let title = typeof menuItem.item.title === 'string'
+                        ? menuItem.item.title
+                        : menuItem.item.title.mnemonicTitle ?? menuItem.item.title.value;
+                    if (menuItem instanceof SubmenuItemAction) {
+                        const submenuActions = [];
+                        updateActions(menuItem.actions, submenuActions, topLevelTitle);
+                        if (submenuActions.length > 0) {
+                            target.push(( new SubmenuAction(menuItem.id, mnemonicMenuLabel(title), submenuActions)));
+                        }
+                    }
+                    else {
+                        if (isICommandActionToggleInfo(menuItem.item.toggled)) {
+                            title = menuItem.item.toggled.mnemonicTitle ?? menuItem.item.toggled.title ?? title;
+                        }
+                        const newAction = ( new Action(
+                            menuItem.id,
+                            mnemonicMenuLabel(title),
+                            menuItem.class,
+                            menuItem.enabled,
+                            () => this.commandService.executeCommand(menuItem.id)
+                        ));
+                        newAction.tooltip = menuItem.tooltip;
+                        newAction.checked = menuItem.checked;
+                        target.push(newAction);
+                    }
+                }
+            }
+            if (topLevelTitle === 'File' && this.currentCompactMenuMode === undefined) {
+                const webActions = this.getWebNavigationActions();
+                if (webActions.length) {
+                    target.push(...webActions);
+                }
+            }
+        };
+        for (const title of ( Object.keys(this.topLevelTitles))) {
+            const menu = this.menus[title];
+            if (firstTime && menu) {
+                this.reinstallDisposables.add(menu.onDidChange(() => {
+                    if (!this.focusInsideMenubar) {
+                        const actions = [];
+                        updateActions(this.toActionsArray(menu), actions, title);
+                        this.menubar?.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
+                    }
+                }));
+                if (menu === this.menus.File) {
+                    this.reinstallDisposables.add(this.webNavigationMenu.onDidChange(() => {
+                        if (!this.focusInsideMenubar) {
+                            const actions = [];
+                            updateActions(this.toActionsArray(menu), actions, title);
+                            this.menubar?.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
+                        }
+                    }));
+                }
+            }
+            const actions = [];
+            if (menu) {
+                updateActions(this.toActionsArray(menu), actions, title);
+            }
+            if (this.menubar) {
+                if (!firstTime) {
+                    this.menubar.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
+                }
+                else {
+                    this.menubar.push({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
+                }
+            }
+        }
+    }
+    getWebNavigationActions() {
+        if (!isWeb) {
+            return [];
+        }
+        const webNavigationActions = [];
+        for (const groups of this.webNavigationMenu.getActions()) {
+            const [, actions] = groups;
+            for (const action of actions) {
+                if (action instanceof MenuItemAction) {
+                    const title = typeof action.item.title === 'string'
+                        ? action.item.title
+                        : action.item.title.mnemonicTitle ?? action.item.title.value;
+                    webNavigationActions.push(( new Action(
+                        action.id,
+                        mnemonicMenuLabel(title),
+                        action.class,
+                        action.enabled,
+                        async (event) => {
+                            this.commandService.executeCommand(action.id, event);
+                        }
+                    )));
+                }
+            }
+            webNavigationActions.push(( new Separator()));
+        }
+        if (webNavigationActions.length) {
+            webNavigationActions.pop();
+        }
+        return webNavigationActions;
+    }
+    getMenuBarOptions() {
+        return {
+            enableMnemonics: this.currentEnableMenuBarMnemonics,
+            disableAltFocus: this.currentDisableMenuBarAltFocus,
+            visibility: this.currentMenubarVisibility,
+            actionRunner: this.actionRunner,
+            getKeybinding: (action) => this.keybindingService.lookupKeybinding(action.id),
+            alwaysOnMnemonics: this.alwaysOnMnemonics,
+            compactMode: this.currentCompactMenuMode,
+            getCompactMenuActions: () => {
+                if (!isWeb) {
+                    return [];
+                }
+                return this.getWebNavigationActions();
+            }
+        };
+    }
+    onDidChangeWindowFocus(hasFocus) {
+        if (!this.visible) {
+            return;
+        }
+        super.onDidChangeWindowFocus(hasFocus);
+        if (this.container) {
+            if (hasFocus) {
+                this.container.classList.remove('inactive');
+            }
+            else {
+                this.container.classList.add('inactive');
+                this.menubar?.blur();
+            }
+        }
+    }
+    onUpdateStateChange() {
+        if (!this.visible) {
+            return;
+        }
+        super.onUpdateStateChange();
+    }
+    onDidChangeRecentlyOpened() {
+        if (!this.visible) {
+            return;
+        }
+        super.onDidChangeRecentlyOpened();
+    }
+    onUpdateKeybindings() {
+        if (!this.visible) {
+            return;
+        }
+        super.onUpdateKeybindings();
+    }
+    registerListeners() {
+        super.registerListeners();
+        this._register(addDisposableListener(window, EventType.RESIZE, () => {
+            if (this.menubar && !(isIOS && BrowserFeatures.pointerEvents)) {
+                this.menubar.blur();
+            }
+        }));
+        if (isWeb) {
+            this._register(this.layoutService.onDidChangeFullscreen(e => this.updateMenubar()));
+            this._register(this.webNavigationMenu.onDidChange(() => this.updateMenubar()));
+        }
+    }
+    get onVisibilityChange() {
+        return this._onVisibilityChange.event;
+    }
+    get onFocusStateChange() {
+        return this._onFocusStateChange.event;
+    }
+    getMenubarItemsDimensions() {
+        if (this.menubar) {
+            return ( new Dimension(this.menubar.getWidth(), this.menubar.getHeight()));
+        }
+        return ( new Dimension(0, 0));
+    }
+    create(parent) {
+        this.container = parent;
+        if (this.container) {
+            this.doUpdateMenubar(true);
+        }
+        return this.container;
+    }
+    layout(dimension) {
+        this.menubar?.update(this.getMenuBarOptions());
+    }
+    toggleFocus() {
+        this.menubar?.toggleFocus();
+    }
+};
+CustomMenubarControl = ( __decorate([
+    ( __param(0, IMenuService)),
+    ( __param(1, IWorkspacesService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ILabelService)),
+    ( __param(6, IUpdateService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, INotificationService)),
+    ( __param(9, IPreferencesService)),
+    ( __param(10, IWorkbenchEnvironmentService)),
+    ( __param(11, IAccessibilityService)),
+    ( __param(12, IWorkbenchLayoutService)),
+    ( __param(13, ITelemetryService)),
+    ( __param(14, IHostService)),
+    ( __param(15, ICommandService))
+], CustomMenubarControl));
+export { CustomMenubarControl, MenubarControl };

package/dist/vscode/vs/workbench/browser/parts/views/checkbox.js

@@ -0,0 +1,80 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Toggle } from 'monaco-editor/esm/vs/base/browser/ui/toggle/toggle.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+class CheckboxStateHandler extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeCheckboxState = this._register(( new Emitter()));
+        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
+    }
+    setCheckboxState(node) {
+        this._onDidChangeCheckboxState.fire([node]);
+    }
+}
+class TreeItemCheckbox extends Disposable {
+    constructor(container, checkboxStateHandler) {
+        super();
+        this.checkboxStateHandler = checkboxStateHandler;
+        this.isDisposed = false;
+        this._onDidChangeState = ( new Emitter());
+        this.onDidChangeState = this._onDidChangeState.event;
+        this.checkboxContainer = container;
+    }
+    render(node) {
+        if (node.checkbox) {
+            if (!this.toggle) {
+                this.createCheckbox(node);
+            }
+            else {
+                this.toggle.checked = node.checkbox.isChecked;
+                this.toggle.setIcon(this.toggle.checked ? Codicon.check : undefined);
+            }
+        }
+    }
+    createCheckbox(node) {
+        if (node.checkbox) {
+            this.toggle = ( new Toggle({
+                isChecked: node.checkbox.isChecked,
+                title: this.createCheckboxTitle(node.checkbox),
+                icon: node.checkbox.isChecked ? Codicon.check : undefined,
+                ...defaultToggleStyles
+            }));
+            this.toggle.domNode.classList.add(TreeItemCheckbox.checkboxClass);
+            dom.append(this.checkboxContainer, this.toggle.domNode);
+            this.registerListener(node);
+        }
+    }
+    registerListener(node) {
+        if (this.toggle) {
+            this._register({ dispose: () => this.removeCheckbox() });
+            this._register(this.toggle);
+            this._register(this.toggle.onChange(() => {
+                this.setCheckbox(node);
+            }));
+        }
+    }
+    setCheckbox(node) {
+        if (this.toggle && node.checkbox) {
+            node.checkbox.isChecked = this.toggle.checked;
+            this.toggle.setIcon(this.toggle.checked ? Codicon.check : undefined);
+            this.toggle.setTitle(this.createCheckboxTitle(node.checkbox));
+            this.checkboxStateHandler.setCheckboxState(node);
+        }
+    }
+    createCheckboxTitle(checkbox) {
+        return checkbox.tooltip ? checkbox.tooltip :
+            checkbox.isChecked ? ( localize('checked', 'Checked')) : ( localize('unchecked', 'Unchecked'));
+    }
+    removeCheckbox() {
+        const children = this.checkboxContainer.children;
+        for (const child of children) {
+            this.checkboxContainer.removeChild(child);
+        }
+    }
+}
+TreeItemCheckbox.checkboxClass = 'custom-view-tree-node-item-checkbox';
+export { CheckboxStateHandler, TreeItemCheckbox };