@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

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

@@ -0,0 +1,150 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Dimension } from '../../../../base/browser/dom.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { MultiEditorTabsControl } from './multiEditorTabsControl.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { StickyEditorGroupModel, UnstickyEditorGroupModel } from '../../../common/editor/filteredEditorGroupModel.js';
+let MultiRowEditorControl = class MultiRowEditorControl extends Disposable {
+    constructor(parent, editorPartsView, groupsView, groupView, model, instantiationService) {
+        super();
+        this.parent = parent;
+        this.groupsView = groupsView;
+        this.groupView = groupView;
+        this.model = model;
+        this.instantiationService = instantiationService;
+        const stickyModel = this._register(( new StickyEditorGroupModel(this.model)));
+        const unstickyModel = this._register(( new UnstickyEditorGroupModel(this.model)));
+        this.stickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, editorPartsView, this.groupsView, this.groupView, stickyModel));
+        this.unstickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, editorPartsView, this.groupsView, this.groupView, unstickyModel));
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    handlePinnedTabsSeparateRowToolbars() {
+        if (this.groupView.count === 0) {
+            return;
+        }
+        if (this.groupView.count === this.groupView.stickyCount) {
+            this.parent.classList.toggle('two-tab-bars', false);
+        }
+        else {
+            this.parent.classList.toggle('two-tab-bars', true);
+        }
+    }
+    getEditorTabsController(editor) {
+        return this.model.isSticky(editor) ? this.stickyEditorTabsControl : this.unstickyEditorTabsControl;
+    }
+    openEditor(editor, options) {
+        const [editorTabController, otherTabController] = this.model.isSticky(editor) ? [this.stickyEditorTabsControl, this.unstickyEditorTabsControl] : [this.unstickyEditorTabsControl, this.stickyEditorTabsControl];
+        const didChange = editorTabController.openEditor(editor, options);
+        if (didChange) {
+            otherTabController.openEditors([]);
+            this.handleOpenedEditors();
+        }
+        return didChange;
+    }
+    openEditors(editors) {
+        const stickyEditors = editors.filter(e => this.model.isSticky(e));
+        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
+        const didChangeOpenEditorsSticky = this.stickyEditorTabsControl.openEditors(stickyEditors);
+        const didChangeOpenEditorsUnSticky = this.unstickyEditorTabsControl.openEditors(unstickyEditors);
+        const didChange = didChangeOpenEditorsSticky || didChangeOpenEditorsUnSticky;
+        if (didChange) {
+            this.handleOpenedEditors();
+        }
+        return didChange;
+    }
+    handleOpenedEditors() {
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    beforeCloseEditor(editor) {
+        this.getEditorTabsController(editor).beforeCloseEditor(editor);
+    }
+    closeEditor(editor) {
+        this.stickyEditorTabsControl.closeEditor(editor);
+        this.unstickyEditorTabsControl.closeEditor(editor);
+        this.handleClosedEditors();
+    }
+    closeEditors(editors) {
+        const stickyEditors = editors.filter(e => this.model.isSticky(e));
+        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
+        this.stickyEditorTabsControl.closeEditors(stickyEditors);
+        this.unstickyEditorTabsControl.closeEditors(unstickyEditors);
+        this.handleClosedEditors();
+    }
+    handleClosedEditors() {
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    moveEditor(editor, fromIndex, targetIndex, stickyStateChange) {
+        if (stickyStateChange) {
+            if (this.model.isSticky(editor)) {
+                this.stickyEditorTabsControl.openEditor(editor);
+                this.unstickyEditorTabsControl.closeEditor(editor);
+            }
+            else {
+                this.stickyEditorTabsControl.closeEditor(editor);
+                this.unstickyEditorTabsControl.openEditor(editor);
+            }
+            this.handlePinnedTabsSeparateRowToolbars();
+        }
+        else {
+            if (this.model.isSticky(editor)) {
+                this.stickyEditorTabsControl.moveEditor(editor, fromIndex, targetIndex, stickyStateChange);
+            }
+            else {
+                this.unstickyEditorTabsControl.moveEditor(editor, fromIndex - this.model.stickyCount, targetIndex - this.model.stickyCount, stickyStateChange);
+            }
+        }
+    }
+    pinEditor(editor) {
+        this.getEditorTabsController(editor).pinEditor(editor);
+    }
+    stickEditor(editor) {
+        this.unstickyEditorTabsControl.closeEditor(editor);
+        this.stickyEditorTabsControl.openEditor(editor);
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    unstickEditor(editor) {
+        this.stickyEditorTabsControl.closeEditor(editor);
+        this.unstickyEditorTabsControl.openEditor(editor);
+        this.handlePinnedTabsSeparateRowToolbars();
+    }
+    setActive(isActive) {
+        this.stickyEditorTabsControl.setActive(isActive);
+        this.unstickyEditorTabsControl.setActive(isActive);
+    }
+    updateEditorLabel(editor) {
+        this.getEditorTabsController(editor).updateEditorLabel(editor);
+    }
+    updateEditorDirty(editor) {
+        this.getEditorTabsController(editor).updateEditorDirty(editor);
+    }
+    updateOptions(oldOptions, newOptions) {
+        this.stickyEditorTabsControl.updateOptions(oldOptions, newOptions);
+        this.unstickyEditorTabsControl.updateOptions(oldOptions, newOptions);
+    }
+    layout(dimensions) {
+        const stickyDimensions = this.stickyEditorTabsControl.layout(dimensions);
+        const unstickyAvailableDimensions = {
+            container: dimensions.container,
+            available: ( new Dimension(
+                dimensions.available.width,
+                dimensions.available.height - stickyDimensions.height
+            ))
+        };
+        const unstickyDimensions = this.unstickyEditorTabsControl.layout(unstickyAvailableDimensions);
+        return ( new Dimension(
+            dimensions.container.width,
+            stickyDimensions.height + unstickyDimensions.height
+        ));
+    }
+    getHeight() {
+        return this.stickyEditorTabsControl.getHeight() + this.unstickyEditorTabsControl.getHeight();
+    }
+    dispose() {
+        this.parent.classList.toggle('two-tab-bars', false);
+        super.dispose();
+    }
+};
+MultiRowEditorControl = ( __decorate([
+    ( __param(5, IInstantiationService))
+], MultiRowEditorControl));
+export { MultiRowEditorControl };

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

@@ -0,0 +1,52 @@
+import './media/singleeditortabscontrol.css.js';
+import { EditorTabsControl } from './editorTabsControl.js';
+import { Dimension } from '../../../../base/browser/dom.js';
+class NoEditorTabsControl extends EditorTabsControl {
+    constructor() {
+        super(...arguments);
+        this.activeEditor = null;
+    }
+    prepareEditorActions(editorActions) {
+        return {
+            primary: [],
+            secondary: []
+        };
+    }
+    openEditor(editor) {
+        return this.handleOpenedEditors();
+    }
+    openEditors(editors) {
+        return this.handleOpenedEditors();
+    }
+    handleOpenedEditors() {
+        const didChange = this.activeEditorChanged();
+        this.activeEditor = this.tabsModel.activeEditor;
+        return didChange;
+    }
+    activeEditorChanged() {
+        if (!this.activeEditor && this.tabsModel.activeEditor ||
+            this.activeEditor && !this.tabsModel.activeEditor ||
+            (!this.activeEditor || !this.tabsModel.isActive(this.activeEditor))
+        ) {
+            return true;
+        }
+        return false;
+    }
+    beforeCloseEditor(editor) { }
+    closeEditor(editor) { }
+    closeEditors(editors) { }
+    moveEditor(editor, fromIndex, targetIndex) { }
+    pinEditor(editor) { }
+    stickEditor(editor) { }
+    unstickEditor(editor) { }
+    setActive(isActive) { }
+    updateEditorLabel(editor) { }
+    updateEditorDirty(editor) { }
+    getHeight() {
+        return 0;
+    }
+    layout(dimensions) {
+        return ( new Dimension(dimensions.container.width, this.getHeight()));
+    }
+}
+export { NoEditorTabsControl };

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

@@ -0,0 +1,260 @@
+import './media/singleeditortabscontrol.css.js';
+import { preventEditorClose, EditorCloseMethod, EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { EditorTabsControl } from './editorTabsControl.js';
+import { ResourceLabel } from '../../labels.js';
+import { TAB_ACTIVE_FOREGROUND, TAB_UNFOCUSED_ACTIVE_FOREGROUND } from '../../../common/theme.js';
+import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+import { addDisposableListener, EventType, DragAndDropObserver, EventHelper, isAncestor, Dimension } from '../../../../base/browser/dom.js';
+import { CLOSE_EDITOR_COMMAND_ID, UNLOCK_GROUP_COMMAND_ID } from './editorCommands.js';
+import { Color } from '../../../../base/common/color.js';
+import { assertIsDefined, assertAllDefined } from '../../../../base/common/types.js';
+import { equals } from '../../../../base/common/objects.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { defaultBreadcrumbsWidgetStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { BreadcrumbsControlFactory } from './breadcrumbsControl.js';
+class SingleEditorTabsControl extends EditorTabsControl {
+    constructor() {
+        super(...arguments);
+        this.activeLabel = Object.create(null);
+    }
+    get breadcrumbsControl() { return this.breadcrumbsControlFactory?.control; }
+    create(parent) {
+        super.create(parent);
+        const titleContainer = this.titleContainer = parent;
+        titleContainer.draggable = true;
+        this.registerContainerListeners(titleContainer);
+        this._register(Gesture.addTarget(titleContainer));
+        const labelContainer = document.createElement('div');
+        labelContainer.classList.add('label-container');
+        titleContainer.appendChild(labelContainer);
+        this.editorLabel = this._register(this.instantiationService.createInstance(ResourceLabel, labelContainer, undefined)).element;
+        this._register(addDisposableListener(this.editorLabel.element, EventType.CLICK, e => this.onTitleLabelClick(e)));
+        this.breadcrumbsControlFactory = this._register(this.instantiationService.createInstance(BreadcrumbsControlFactory, labelContainer, this.groupView, {
+            showFileIcons: false,
+            showSymbolIcons: true,
+            showDecorationColors: false,
+            widgetStyles: { ...defaultBreadcrumbsWidgetStyles, breadcrumbsBackground: ( Color.transparent.toString()) },
+            showPlaceholder: false
+        }));
+        this._register(this.breadcrumbsControlFactory.onDidEnablementChange(() => this.handleBreadcrumbsEnablementChange()));
+        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
+        this._register(toDisposable(() => titleContainer.classList.remove('breadcrumbs')));
+        this.createEditorActionsToolBar(titleContainer, ['title-actions']);
+    }
+    registerContainerListeners(titleContainer) {
+        let lastDragEvent = undefined;
+        let isNewWindowOperation = false;
+        this._register(( new DragAndDropObserver(titleContainer, {
+            onDragStart: e => { isNewWindowOperation = this.onGroupDragStart(e, titleContainer); },
+            onDrag: e => { lastDragEvent = e; },
+            onDragEnd: e => { this.onGroupDragEnd(e, lastDragEvent, titleContainer, isNewWindowOperation); },
+        })));
+        this._register(addDisposableListener(titleContainer, EventType.DBLCLICK, e => this.onTitleDoubleClick(e)));
+        this._register(addDisposableListener(titleContainer, EventType.AUXCLICK, e => this.onTitleAuxClick(e)));
+        this._register(addDisposableListener(titleContainer, EventType$1.Tap, (e) => this.onTitleTap(e)));
+        for (const event of [EventType.CONTEXT_MENU, EventType$1.Contextmenu]) {
+            this._register(addDisposableListener(titleContainer, event, e => {
+                if (this.tabsModel.activeEditor) {
+                    this.onTabContextMenu(this.tabsModel.activeEditor, e, titleContainer);
+                }
+            }));
+        }
+    }
+    onTitleLabelClick(e) {
+        EventHelper.stop(e, false);
+        setTimeout(() => this.quickInputService.quickAccess.show());
+    }
+    onTitleDoubleClick(e) {
+        EventHelper.stop(e);
+        this.groupView.pinEditor();
+    }
+    onTitleAuxClick(e) {
+        if (e.button === 1  && this.tabsModel.activeEditor) {
+            EventHelper.stop(e, true );
+            if (!preventEditorClose(this.tabsModel, this.tabsModel.activeEditor, EditorCloseMethod.MOUSE, this.groupsView.partOptions)) {
+                this.groupView.closeEditor(this.tabsModel.activeEditor);
+            }
+        }
+    }
+    onTitleTap(e) {
+        const target = e.initialTarget;
+        if (!(target instanceof HTMLElement) || !this.editorLabel || !isAncestor(target, this.editorLabel.element)) {
+            return;
+        }
+        setTimeout(() => this.quickInputService.quickAccess.show(), 50);
+    }
+    openEditor(editor) {
+        return this.doHandleOpenEditor();
+    }
+    openEditors(editors) {
+        return this.doHandleOpenEditor();
+    }
+    doHandleOpenEditor() {
+        const activeEditorChanged = this.ifActiveEditorChanged(() => this.redraw());
+        if (!activeEditorChanged) {
+            this.ifActiveEditorPropertiesChanged(() => this.redraw());
+        }
+        return activeEditorChanged;
+    }
+    beforeCloseEditor(editor) {
+    }
+    closeEditor(editor) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    closeEditors(editors) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    moveEditor(editor, fromIndex, targetIndex) {
+        this.ifActiveEditorChanged(() => this.redraw());
+    }
+    pinEditor(editor) {
+        this.ifEditorIsActive(editor, () => this.redraw());
+    }
+    stickEditor(editor) {
+    }
+    unstickEditor(editor) {
+    }
+    setActive(isActive) {
+        this.redraw();
+    }
+    updateEditorLabel(editor) {
+        this.ifEditorIsActive(editor, () => this.redraw());
+    }
+    updateEditorDirty(editor) {
+        this.ifEditorIsActive(editor, () => {
+            const titleContainer = assertIsDefined(this.titleContainer);
+            if (editor.isDirty() && !editor.isSaving()) {
+                titleContainer.classList.add('dirty');
+            }
+            else {
+                titleContainer.classList.remove('dirty');
+            }
+        });
+    }
+    updateOptions(oldOptions, newOptions) {
+        super.updateOptions(oldOptions, newOptions);
+        if (oldOptions.labelFormat !== newOptions.labelFormat || !equals(oldOptions.decorations, newOptions.decorations)) {
+            this.redraw();
+        }
+    }
+    updateStyles() {
+        this.redraw();
+    }
+    handleBreadcrumbsEnablementChange() {
+        const titleContainer = assertIsDefined(this.titleContainer);
+        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
+        this.redraw();
+    }
+    ifActiveEditorChanged(fn) {
+        if (!this.activeLabel.editor && this.tabsModel.activeEditor ||
+            this.activeLabel.editor && !this.tabsModel.activeEditor ||
+            (!this.activeLabel.editor || !this.tabsModel.isActive(this.activeLabel.editor))
+        ) {
+            fn();
+            return true;
+        }
+        return false;
+    }
+    ifActiveEditorPropertiesChanged(fn) {
+        if (!this.activeLabel.editor || !this.tabsModel.activeEditor) {
+            return;
+        }
+        if (this.activeLabel.pinned !== this.tabsModel.isPinned(this.tabsModel.activeEditor)) {
+            fn();
+        }
+    }
+    ifEditorIsActive(editor, fn) {
+        if (this.tabsModel.isActive(editor)) {
+            fn();
+        }
+    }
+    redraw() {
+        const editor = this.tabsModel.activeEditor ?? undefined;
+        const options = this.groupsView.partOptions;
+        const isEditorPinned = editor ? this.tabsModel.isPinned(editor) : false;
+        const isGroupActive = this.groupsView.activeGroup === this.groupView;
+        this.activeLabel = { editor, pinned: isEditorPinned };
+        if (this.breadcrumbsControl) {
+            if (isGroupActive) {
+                this.breadcrumbsControl.update();
+                this.breadcrumbsControl.domNode.classList.toggle('preview', !isEditorPinned);
+            }
+            else {
+                this.breadcrumbsControl.hide();
+            }
+        }
+        const [titleContainer, editorLabel] = assertAllDefined(this.titleContainer, this.editorLabel);
+        if (!editor) {
+            titleContainer.classList.remove('dirty');
+            editorLabel.clear();
+            this.clearEditorActionsToolbar();
+        }
+        else {
+            this.updateEditorDirty(editor);
+            const { labelFormat } = this.groupsView.partOptions;
+            let description;
+            if (this.breadcrumbsControl && !this.breadcrumbsControl.isHidden()) {
+                description = '';
+            }
+            else if (labelFormat === 'default' && !isGroupActive) {
+                description = '';
+            }
+            else {
+                description = editor.getDescription(this.getVerbosity(labelFormat)) || '';
+            }
+            let title = editor.getTitle(2 );
+            if (description === title) {
+                title = '';
+            }
+            editorLabel.setResource({
+                resource: EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH }),
+                name: editor.getName(),
+                description
+            }, {
+                title,
+                italic: !isEditorPinned,
+                extraClasses: ['single-tab', 'title-label'].concat(editor.getLabelExtraClasses()),
+                fileDecorations: {
+                    colors: Boolean(options.decorations?.colors),
+                    badges: Boolean(options.decorations?.badges)
+                },
+                icon: editor.getIcon(),
+                hideIcon: options.showIcons === false,
+            });
+            if (isGroupActive) {
+                titleContainer.style.color = this.getColor(TAB_ACTIVE_FOREGROUND) || '';
+            }
+            else {
+                titleContainer.style.color = this.getColor(TAB_UNFOCUSED_ACTIVE_FOREGROUND) || '';
+            }
+            this.updateEditorActionsToolbar();
+        }
+    }
+    getVerbosity(style) {
+        switch (style) {
+            case 'short': return 0 ;
+            case 'long': return 2 ;
+            default: return 1 ;
+        }
+    }
+    prepareEditorActions(editorActions) {
+        const isGroupActive = this.groupsView.activeGroup === this.groupView;
+        if (isGroupActive) {
+            return editorActions;
+        }
+        else {
+            return {
+                primary: editorActions.primary.filter(action => action.id === CLOSE_EDITOR_COMMAND_ID || action.id === UNLOCK_GROUP_COMMAND_ID),
+                secondary: editorActions.secondary
+            };
+        }
+    }
+    getHeight() {
+        return this.tabHeight;
+    }
+    layout(dimensions) {
+        this.breadcrumbsControl?.layout(undefined);
+        return ( new Dimension(dimensions.container.width, this.getHeight()));
+    }
+}
+export { SingleEditorTabsControl };

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

@@ -46,7 +46,7 @@ let AbstractTextEditor = class AbstractTextEditor extends AbstractEditorWithView
         }
     }
     shouldHandleConfigurationChangeEvent(e, resource) {
-        return e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'problems');
+        return e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'problems.visibility');
     }
     consumePendingConfigurationChangeEvent() {
         if (this.hasPendingConfigurationChange) {

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

@@ -93,7 +93,7 @@ let TextResourceEditor = class TextResourceEditor extends AbstractTextResourceEd
         }
     }
     onDidEditorPaste(e, codeEditor) {
-        if (this.input instanceof UntitledTextEditorInput && this.input.model.hasLanguageSetExplicitly) {
+        if (this.input instanceof UntitledTextEditorInput && this.input.hasLanguageSetExplicitly) {
             return;
         }
         if (e.range.startLineNumber !== 1 || e.range.startColumn !== 1) {
@@ -126,7 +126,7 @@ let TextResourceEditor = class TextResourceEditor extends AbstractTextResourceEd
         }
         if (candidateLanguage && candidateLanguage.id !== PLAINTEXT_LANGUAGE_ID) {
             if (this.input instanceof UntitledTextEditorInput && candidateLanguage.source === 'event') {
-                this.input.model.setLanguageId(candidateLanguage.id);
+                this.input.setLanguageId(candidateLanguage.id);
             }
             else {
                 textModel.setLanguage(this.languageService.createById(candidateLanguage.id));

package/vscode/src/vs/workbench/browser/parts/globalCompositeBar.js

@@ -24,7 +24,7 @@ import { GLOBAL_ACTIVITY_ID } from '../../common/activity.js';
 import { ACTIVITY_BAR_BADGE_BACKGROUND, ACTIVITY_BAR_BADGE_FOREGROUND } from '../../common/theme.js';
 import { NumberBadge, IActivityService } from '../../services/activity/common/activity.js';
 import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
-import { IHoverService } from '../../services/hover/browser/hover.js';
+import { IHoverService } from '../../../platform/hover/browser/hover.js';
 import { IUserDataProfileService } from '../../services/userDataProfile/common/userDataProfile.js';
 import { DEFAULT_ICON } from '../../services/userDataProfile/common/userDataProfileIcons.js';
 let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
@@ -41,12 +41,14 @@ let GlobalCompositeBar = class GlobalCompositeBar extends Disposable {
         this.instantiationService = instantiationService;
         this.globalActivityAction = this._register(( new Action(GLOBAL_ACTIVITY_ID)));
         this.element = document.createElement('div');
-        const anchorAlignment = configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ;
-        const anchorAxisAlignment = 1 ;
+        const contextMenuAlignmentOptions = () => ({
+            anchorAlignment: configurationService.getValue('workbench.sideBar.location') === 'left' ? 1  : 0 ,
+            anchorAxisAlignment: 1
+        });
         this.globalActivityActionBar = this._register(( new ActionBar(this.element, {
             actionViewItemProvider: action => {
                 if (action.id === GLOBAL_ACTIVITY_ID) {
-                    return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { colors: this.colors, hoverOptions: this.activityHoverOptions }, anchorAlignment, anchorAxisAlignment);
+                    return this.instantiationService.createInstance(GlobalActivityActionViewItem, this.contextMenuActionsProvider, { colors: this.colors, hoverOptions: this.activityHoverOptions }, contextMenuAlignmentOptions);
                 }
                 throw new Error(`No view item for action '${action.id}'`);
             },
@@ -75,12 +77,11 @@ GlobalCompositeBar = ( __decorate([
     ( __param(4, IInstantiationService))
 ], GlobalCompositeBar));
 let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionViewItem extends CompoisteBarActionViewItem {
-    constructor(menuId, action, options, contextMenuActionsProvider, anchorAlignment, anchorAxisAlignment, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
+    constructor(menuId, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService) {
         super(action, { draggable: false, icon: true, hasPopup: true, ...options }, () => true, themeService, hoverService, configurationService, keybindingService);
         this.menuId = menuId;
         this.contextMenuActionsProvider = contextMenuActionsProvider;
-        this.anchorAlignment = anchorAlignment;
-        this.anchorAxisAlignment = anchorAxisAlignment;
+        this.contextMenuAlignmentOptions = contextMenuAlignmentOptions;
         this.menuService = menuService;
         this.contextMenuService = contextMenuService;
         this.contextKeyService = contextKeyService;
@@ -156,10 +157,11 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
         const disposables = ( new DisposableStore());
         const menu = disposables.add(this.menuService.createMenu(this.menuId, this.contextKeyService));
         const actions = await this.resolveMainMenuActions(menu, disposables);
+        const { anchorAlignment, anchorAxisAlignment } = this.contextMenuAlignmentOptions() ?? { anchorAlignment: undefined, anchorAxisAlignment: undefined };
         this.contextMenuService.showContextMenu({
             getAnchor: () => this.label,
-            anchorAlignment: this.anchorAlignment,
-            anchorAxisAlignment: this.anchorAxisAlignment,
+            anchorAlignment,
+            anchorAxisAlignment,
             getActions: () => actions,
             onHide: () => disposables.dispose(),
             menuActionOptions: { renderShortTitle: true },
@@ -172,23 +174,23 @@ let AbstractGlobalActivityActionViewItem = class AbstractGlobalActivityActionVie
     }
 };
 AbstractGlobalActivityActionViewItem = ( __decorate([
-    ( __param(6, IThemeService)),
-    ( __param(7, IHoverService)),
-    ( __param(8, IMenuService)),
-    ( __param(9, IContextMenuService)),
-    ( __param(10, IContextKeyService)),
-    ( __param(11, IConfigurationService)),
-    ( __param(12, IKeybindingService)),
-    ( __param(13, IActivityService))
+    ( __param(5, IThemeService)),
+    ( __param(6, IHoverService)),
+    ( __param(7, IMenuService)),
+    ( __param(8, IContextMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IConfigurationService)),
+    ( __param(11, IKeybindingService)),
+    ( __param(12, IActivityService))
 ], AbstractGlobalActivityActionViewItem));
 let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends AbstractGlobalActivityActionViewItem {
-    constructor(contextMenuActionsProvider, options, anchorAlignment, anchorAxisAlignment, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
+    constructor(contextMenuActionsProvider, options, contextMenuAlignmentOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
         const action = instantiationService.createInstance(CompositeBarAction, {
             id: GLOBAL_ACTIVITY_ID,
             name: ( localizeWithPath('vs/workbench/browser/parts/globalCompositeBar', 'manage', "Manage")),
             classNames: ThemeIcon.asClassNameArray(userDataProfileService.currentProfile.icon ? ThemeIcon.fromId(userDataProfileService.currentProfile.icon) : DEFAULT_ICON)
         });
-        super(MenuId.GlobalActivity, action, options, contextMenuActionsProvider, anchorAlignment, anchorAxisAlignment, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
+        super(MenuId.GlobalActivity, action, options, contextMenuActionsProvider, contextMenuAlignmentOptions, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, keybindingService, activityService);
         this.userDataProfileService = userDataProfileService;
         this._register(action);
         this._register(this.userDataProfileService.onDidChangeCurrentProfile(e => {
@@ -213,15 +215,16 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
         if (this.userDataProfileService.currentProfile.isDefault) {
             return;
         }
-        if (this.action.activity) {
+        if (this.userDataProfileService.currentProfile.icon && this.userDataProfileService.currentProfile.icon !== DEFAULT_ICON.id) {
             return;
         }
-        if (!this.userDataProfileService.currentProfile.icon || this.userDataProfileService.currentProfile.icon === DEFAULT_ICON.id) {
-            this.profileBadgeContent.classList.toggle('profile-text-overlay', true);
-            this.profileBadgeContent.classList.toggle('profile-icon-overlay', false);
-            this.profileBadgeContent.textContent = this.userDataProfileService.currentProfile.name.substring(0, 2).toUpperCase();
+        if (this.action.activity) {
+            return;
         }
         show(this.profileBadge);
+        this.profileBadgeContent.classList.toggle('profile-text-overlay', true);
+        this.profileBadgeContent.classList.toggle('profile-icon-overlay', false);
+        this.profileBadgeContent.textContent = this.userDataProfileService.currentProfile.name.substring(0, 2).toUpperCase();
     }
     updateActivity() {
         super.updateActivity();
@@ -237,17 +240,17 @@ let GlobalActivityActionViewItem = class GlobalActivityActionViewItem extends Ab
     }
 };
 GlobalActivityActionViewItem = ( __decorate([
-    ( __param(4, IUserDataProfileService)),
-    ( __param(5, IThemeService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, IConfigurationService)),
-    ( __param(11, IWorkbenchEnvironmentService)),
-    ( __param(12, IKeybindingService)),
-    ( __param(13, IInstantiationService)),
-    ( __param(14, IActivityService))
+    ( __param(3, IUserDataProfileService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, IHoverService)),
+    ( __param(6, IMenuService)),
+    ( __param(7, IContextMenuService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IWorkbenchEnvironmentService)),
+    ( __param(11, IKeybindingService)),
+    ( __param(12, IInstantiationService)),
+    ( __param(13, IActivityService))
 ], GlobalActivityActionViewItem));
 let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewItem extends GlobalActivityActionViewItem {
     constructor(hoverOptions, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService) {
@@ -258,7 +261,7 @@ let SimpleGlobalActivityActionViewItem = class SimpleGlobalActivityActionViewIte
             }),
             hoverOptions,
             compact: true,
-        }, undefined, undefined, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService);
+        }, () => undefined, userDataProfileService, themeService, hoverService, menuService, contextMenuService, contextKeyService, configurationService, environmentService, keybindingService, instantiationService, activityService);
     }
 };
 SimpleGlobalActivityActionViewItem = ( __decorate([